AutoTracingPlugin._rebind drops the staticmethod descriptor, breaking wrapped classes

[DVDH-000]

Summary

AutoTracingPlugin._wrap_module discovers class members with inspect.getmembers, which returns the underlying plain function for a @staticmethod. _rebind then setattrs a plain wrapper function back onto the class without re-wrapping it in staticmethod(...).

After that, accessing the attribute through an instance re-engages the descriptor protocol and binds the instance as the first positional argument. Any static method whose first parameter is a real parameter now receives self in that slot.

plugins/auto_tracing_plugin.py (2.7.0), _wrap_module around L145 and _rebind around L164:

for member_name, member in inspect.getmembers(attr):
    ...
    if not inspect.isfunction(member):
        continue
    ...
    self._rebind(attr, member_name, member)

# _rebind
setattr(owner, name, auto_tracing_helpers.build_tracing_wrapper(fn, self._tracer, self._caps))

Reproduction

import inspect

class C:
    @staticmethod
    def static(a, b=None):
        return ("static", a, b)

# what _wrap_module sees:
member = dict(inspect.getmembers(C))["static"]
assert inspect.isfunction(member)        # True -- passes the filter

# what _rebind does:
def make_wrapper(fn):
    def wrapper(*a, **kw):
        return fn(*a, **kw)
    return wrapper

setattr(C, "static", make_wrapper(member))

C().static(a=1)
# TypeError: C.static() got multiple values for argument 'a'

Observed in the wild against google.genai.Client._get_api_client, which is a @staticmethod whose first parameter happens to be named vertexai:

TypeError: Client._get_api_client() got multiple values for argument 'vertexai'

The instance lands in vertexai positionally and collides with the explicit vertexai= keyword at the call site.

Scope, checked rather than assumed

member kind	getmembers returns	isfunction	reaches _rebind
staticmethod	plain function	True	yes, corrupted
classmethod	bound method	False	no, skipped
ordinary method	plain function	True	yes, correct (binding self is right)

So classmethod escapes by accident, via the isfunction filter. Only staticmethod is affected.

Suggested fix

Determine the descriptor kind from the class __dict__ rather than the getmembers result, and re-wrap before setattr:

raw = owner.__dict__.get(name) if isinstance(owner, type) else None
wrapper = auto_tracing_helpers.build_tracing_wrapper(fn, self._tracer, self._caps)
if isinstance(raw, staticmethod):
    wrapper = staticmethod(wrapper)
setattr(owner, name, wrapper)

inspect.getattr_static would work too. Happy to open a PR if that would help.

Related: _add_agent_scope cannot be constrained to first-party modules

Separate but compounding. _add_agent_scope walks objects reachable from the agent to depth 30 and adds any module prefix it finds to the plugin scope. Passing extra_scope_prefixes=("my_package",) still resulted in google.genai.client being instrumented, because something in the agent object graph resolved to it.

Combined with the bug above, enabling the plugin instruments arbitrary third-party modules and then corrupts any staticmethod it finds there. In one short trial that broke two unrelated call paths.

Would a strict allowlist mode for _add_agent_scope be something you would consider?

Worth saying

The plugin does work where this does not bite. Spans on ordinary functions carried genuinely useful adk.fn.arg.* and adk.fn.return detail with no hand instrumentation, which is exactly what we were evaluating it for. These two issues are what stopped us adopting it, not the idea.

Version: google-adk 2.7.0, Python 3.13.

[surajksharma07]

@DVDH-000 _rebind setattrs the wrapper without re-wrapping it in staticmethod() so instance access binds self into whatever the first real param is exactly like your vertexai case. #6820 fixes it by checking the class dict before rewrapping and it held up in our own tests too.

Could you pull that branch and run it against your actual staticmethods to confirm it holds?
Please give it a proper test pass before raising anything separate since #6820 already covers this.

[DVDH-000]

Pulled #6820 and ran it. The fix holds. Two things back, one of them about the test.

Against real staticmethods

Applied 2.7.0's shipped _rebind and then #6820's to each class and called through an instance:

target	ADK 2.7.0	with #6820
google.genai.Client._get_api_client	TypeError: got multiple values for argument 'vertexai'	PASS
a keyword-only @staticmethod in our own code	TypeError: takes 0 positional arguments but 1 was given	PASS

The second row is a different symptom of the same cause and worth having in mind: when the static method is keyword-only there is no first positional parameter for self to collide with, so it surfaces as an arity error rather than a duplicate-argument error. Both clear with the descriptor restored.

The new test cannot fail for the reason it exists

assert fixture.module.C.static(a=1) == ("static", 1, None)

That is class access, and class access never engages the descriptor. Measured, simulating both _rebind variants:

ADK 2.7.0 as shipped (buggy)
  C.static(a=1)      -> PASS
  C().static(a=1)    -> TypeError: got multiple values for argument 'a'

with #6820
  C.static(a=1)      -> PASS
  C().static(a=1)    -> PASS

So the assertion passes on unfixed code too. The discriminating call is C().static(a=1). Worth changing, or the regression can come back green.

A keyword-only variant would be a cheap second case, since it fails with a different error and would catch a partial fix.

On the classmethod branch

elif isinstance(raw, classmethod) is unreachable through the current path: inspect.getmembers returns a bound method for a classmethod, so _wrap_module's if not inspect.isfunction(member): continue drops it before _rebind sees it. Verified. Not wrong to have it, and it is the right thing if that filter ever widens, but it is not currently exercised by anything.

Second issue from the original report

_add_agent_scope walking to depth 30 and pulling unrelated third-party modules into scope is untouched by #6820, as expected. Happy to keep that on this issue or split it out, whichever you prefer.

Not raising anything separate, per your note.