Tip: I like to do this:

func main() {
  err := run()
  if err != nil {
    fmt.Fprintf(os.Stderr, "%v\n", err)
    os.Exit(1)
  }
}

func run() error {
... real work....
}

because then we can just return an error. Two advantages:

• A little more compact
• It makes it easier to refactor the code into functions; the top-level function is a special-case in terms of error handling, so I try to make that special-case as small as possible.

This is nice. Reduce code for error handling

Nit: it's clearer (IMO) without the line break between the thing which generates the error and which checks the error

a, err := foo()
if err != nil {

Technically the key should include the api group, in case two kinds are named the same in two apigroups.

Two ways to do that:

• Invent some delimiter that is "safe": m[obj.APIGroup + "::" + obj.Kind] = true
• Use a struct:

struct key {
  APIGroup string
  Kind string
}

For cases like this where I'm not really reading the values back, I tend to just use the string trick. If I'm reading them back or parsing the keys I tend to use a struct.

Alternatives:

• map[string]bool lets you do if m[obj.Kind] { and I tend to use this
• map[string]struct{} is the go way of writing that there are no values, so it is a little more memory efficient. You have to use the longer way of checking though (as you've done here), so if it's not verified as performance critical I tend to use the simpler boolean form.

There's a pluralize helper in kubebuilder I think, which I guess we should probably use. I agree this is annoying though :-)

It's technically the resource name, which might be completely different to the kind. In practice, it's the plural (and lower cased).

Nit: we might want a string enum (as otherwise we tend to end up with lots of flags :-) )