Should extending this require you to pass self? Seems redundant. I think it would be better if self was implied here. Might require implementing some kind of helper module via def self.extended.

I think it'd be a good idea to add some more robust comments above the def line here for each of these functions, that explain how these functions are used and what they produce.

Minor, but if this is only used once, would it be simpler to just merge this into line 33? Over declaring the variable? Or there a scope issue where this helps side-step local variables dropping out of scope when defining Module#new?

This implementation might be problematic when done in bulk if I'm tracing dozens of functions. If I'm understanding it correctly, it would create and prepend a module per function, no?

I think it would be worthwhile making sure all the traced methods end up in one prepended module instead of many.

There are a number of strategies you could employ, but I think the challenge with how the current API is designed is that the user invokes trace_methods and trace_class_methods separately, such that each is an atomic operation which would needfully create a module per invocation.

If you're willing to change the API a little bit, you could consider employing a builder pattern instead, in which you build each in transaction before committing the result. e.g this could look like:

def MyClass
  extend Datadog::MethodTracing

  datadog_tracing do
    trace_methods :foo, :bar
    trace_class_methods :baz
  end
end

This is just the first idea that came to mind, so there might be a better/simpler way which would still allow us to avoid adding multiple modules. Let me know your thoughts!