From f47b59c684b564ab4b65fbc775095ffdaef7c0d2 Mon Sep 17 00:00:00 2001 From: Nikhil Pareek Date: Fri, 30 Oct 2026 20:39:46 -0700 Subject: [PATCH 1/2] fix(mcp): preserve native transports and propagation lifecycle Prepare traceAI-mcp 0.1.3 with caller-owned metadata isolation, teardown and reinstall safety, native transport regression coverage, and the resolved MCP CI exception removed. Co-Authored-By: Claude Code --- .github/python-tests-known-broken.txt | 1 - python/frameworks/mcp/CHANGELOG.md | 10 + python/frameworks/mcp/README.md | 27 +- python/frameworks/mcp/pyproject.toml | 2 +- .../mcp/tests/constraints-floor.txt | 4 + .../mcp/tests/local_http_server_r4.py | 21 ++ .../frameworks/mcp/tests/local_server_r2.py | 28 ++ .../frameworks/mcp/tests/local_server_r3.py | 52 ++++ .../mcp/tests/test_local_exchange_r2.py | 58 ++++ .../mcp/tests/test_native_lifecycle.py | 77 +++++ .../mcp/tests/test_native_message_compat.py | 57 ++++ .../mcp/tests/test_null_metadata_r5.py | 76 +++++ .../mcp/tests/test_r2_regressions.py | 82 +++++ .../frameworks/mcp/tests/test_r3_liveness.py | 285 ++++++++++++++++++ python/frameworks/mcp/tests/test_r4_reuse.py | 214 +++++++++++++ python/frameworks/mcp/traceai_mcp/__init__.py | 237 +++++++++------ python/frameworks/mcp/traceai_mcp/package.py | 2 +- python/tests/test_framework_mcp.py | 241 +++++++++------ 18 files changed, 1292 insertions(+), 182 deletions(-) create mode 100644 python/frameworks/mcp/tests/constraints-floor.txt create mode 100644 python/frameworks/mcp/tests/local_http_server_r4.py create mode 100644 python/frameworks/mcp/tests/local_server_r2.py create mode 100644 python/frameworks/mcp/tests/local_server_r3.py create mode 100644 python/frameworks/mcp/tests/test_local_exchange_r2.py create mode 100644 python/frameworks/mcp/tests/test_native_lifecycle.py create mode 100644 python/frameworks/mcp/tests/test_native_message_compat.py create mode 100644 python/frameworks/mcp/tests/test_null_metadata_r5.py create mode 100644 python/frameworks/mcp/tests/test_r2_regressions.py create mode 100644 python/frameworks/mcp/tests/test_r3_liveness.py create mode 100644 python/frameworks/mcp/tests/test_r4_reuse.py diff --git a/.github/python-tests-known-broken.txt b/.github/python-tests-known-broken.txt index 66234c3f7..4a20ec07c 100644 --- a/.github/python-tests-known-broken.txt +++ b/.github/python-tests-known-broken.txt @@ -21,7 +21,6 @@ huggingface | 3 tests expect llm.system; 1 expects generated text that is no lon instructor | 6 tests: instructor.core no longer exists in current instructor (5), and a dependency string check (1) litellm | 3 tests use SpanAttributes.FI_SPAN_KIND, which no longer exists llama_index | 14 tests: llama_index.core.base.agent no longer exists; 1 expects SpanAttributes.LLM_MODEL_NAME; 1 a dependency count -mcp | 1 test expects two instrumentation dependencies, the package declares one mistralai | 1 test expects raw.input where the code now writes input.value ollama | 2 tests expect llm.system; 2 expect generated text and embedding size that are no longer recorded openai-agents | its own tests do not load (conftest imports traceai_openai, not installed); 2 core tests expect raw.output and a trace-start call diff --git a/python/frameworks/mcp/CHANGELOG.md b/python/frameworks/mcp/CHANGELOG.md index 24783ca8e..d24ce7f13 100644 --- a/python/frameworks/mcp/CHANGELOG.md +++ b/python/frameworks/mcp/CHANGELOG.md @@ -1,3 +1,13 @@ +## [0.1.3] - 2026-10-31 +### Fixed +- Support both streamable HTTP client names and the MCP SDK's two- and three-item transport tuples. +- Disable propagation on existing streams during teardown, restore owned hooks without replacing other libraries' wrappers, and reactivate existing instrumented streams after reinstall. +- Propagate context without mutating caller-owned messages or metadata, including null metadata; preserve original messages when there is no context to inject. +- Keep queued server messages and native transport errors intact across instrumentation transitions. + +### Changed +- Align the runtime SDK dependency check with the declared MCP 1.8.1 minimum. + ## [0.1.0] - 2025-06-05 ### Feature - Added support for MCP framework \ No newline at end of file diff --git a/python/frameworks/mcp/README.md b/python/frameworks/mcp/README.md index 329b01a6d..789241767 100644 --- a/python/frameworks/mcp/README.md +++ b/python/frameworks/mcp/README.md @@ -49,4 +49,29 @@ OpenAIInstrumentor().instrument(tracer_provider=trace_provider) MCPInstrumentor().instrument(tracer_provider=tracer_provider) ``` -Start your MCP server as usual. TraceAI will automatically trace all MCP requests which will be visible in the FutureAGI platform. \ No newline at end of file +Start your MCP server as usual. TraceAI will automatically trace all MCP requests which will be visible in the FutureAGI platform. + +### MCP 1.8.1 dependency compatibility + +MCP 1.8.1 uses a private Pydantic API that is absent in Pydantic 2.14.2. +If you must stay on MCP 1.8.1, pin its compatible Pydantic dependency: + +```bash +pip install "traceAI-mcp" "mcp==1.8.1" "pydantic==2.11.10" +``` + +This pin applies only to MCP 1.8.1; do not impose it on newer SDK versions. + +### Instrumentation lifecycle + +`uninstrument()` disables this instrumentor's per-message propagation on +already-instrumented open streams as well as on newly opened transports; it +does not close sessions or remove wrappers installed by other libraries. +Reinstalling re-enables the existing instrumented streams and instruments new +transports exactly once. Sessions created while instrumentation is off are +not retroactively wrapped; reopen them after reinstall to instrument them. +Queued server messages remain intact across transitions; context captured while +enabled is attached only if the reader is enabled when it consumes the item. +An already-running request retains the context under which it started. Native +MCP SDK tracing remains independent and can continue when this instrumentor is +off, particularly with MCP 2.x. diff --git a/python/frameworks/mcp/pyproject.toml b/python/frameworks/mcp/pyproject.toml index f37bc6df3..87409b451 100644 --- a/python/frameworks/mcp/pyproject.toml +++ b/python/frameworks/mcp/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "traceAI-mcp" -version = "0.1.2" +version = "0.1.3" description = "OpenTelemetry instrumentation for MCP" authors = ["Future AGI "] readme = "README.md" diff --git a/python/frameworks/mcp/tests/constraints-floor.txt b/python/frameworks/mcp/tests/constraints-floor.txt new file mode 100644 index 000000000..7f6810e88 --- /dev/null +++ b/python/frameworks/mcp/tests/constraints-floor.txt @@ -0,0 +1,4 @@ +# MCP 1.8.1 imports a private Pydantic API removed in newer releases. +# This is a tested floor matrix cell, not a package-wide runtime constraint. +mcp==1.8.1 +pydantic==2.11.10 diff --git a/python/frameworks/mcp/tests/local_http_server_r4.py b/python/frameworks/mcp/tests/local_http_server_r4.py new file mode 100644 index 000000000..fbce0dda7 --- /dev/null +++ b/python/frameworks/mcp/tests/local_http_server_r4.py @@ -0,0 +1,21 @@ +"""Independent traced loopback server for raw native HTTP message reuse.""" +import json +import sys +from importlib.metadata import version +from opentelemetry import trace +from traceai_mcp import MCPInstrumentor +import uvicorn + +MCPInstrumentor().instrument(skip_dep_check=True) +if version('mcp').startswith('1.'): + from mcp.server.fastmcp import FastMCP as Server +else: + from mcp.server.mcpserver import MCPServer as Server +server = Server('local-http-r4') + +@server.tool() +async def echo(value: str) -> str: + return json.dumps({'value': value, 'trace_id': trace.get_current_span().get_span_context().trace_id}) + +if __name__ == '__main__': + uvicorn.run(server.streamable_http_app(), host='127.0.0.1', port=int(sys.argv[1]), log_level='error') diff --git a/python/frameworks/mcp/tests/local_server_r2.py b/python/frameworks/mcp/tests/local_server_r2.py new file mode 100644 index 000000000..6f3d26cfb --- /dev/null +++ b/python/frameworks/mcp/tests/local_server_r2.py @@ -0,0 +1,28 @@ +"""Offline real MCP stdio server used by test_local_exchange_r2.""" +import json +import sys +from importlib.metadata import version +from opentelemetry import trace + +if '--traced' in sys.argv: + from traceai_mcp import MCPInstrumentor + MCPInstrumentor().instrument(skip_dep_check=True) + +if int(version('mcp').split('.')[0]) >= 2: + from mcp.server.mcpserver import MCPServer as Server +else: + from mcp.server.fastmcp import FastMCP as Server + +server = Server('local-r2') + +@server.tool() +async def echo(value: str) -> str: + span = trace.get_current_span().get_span_context() + return json.dumps({'value': value, 'trace_id': span.trace_id}) + +@server.tool() +async def fail() -> str: + raise ValueError('local-tool-failure') + +if __name__ == '__main__': + server.run(transport='stdio') diff --git a/python/frameworks/mcp/tests/local_server_r3.py b/python/frameworks/mcp/tests/local_server_r3.py new file mode 100644 index 000000000..e678187fa --- /dev/null +++ b/python/frameworks/mcp/tests/local_server_r3.py @@ -0,0 +1,52 @@ +"""Real MCP server with instrumentor-only propagation counters for lifecycle tests.""" +import asyncio +import json +from importlib.metadata import version +from opentelemetry import trace +import traceai_mcp +from traceai_mcp import MCPInstrumentor + +class Tap: + def __init__(self, original): + self.original = original + self.injects = self.extracts = 0 + def get_global_textmap(self): + original = self.original.get_global_textmap() + tap = self + class Injector: + def inject(self, *args, **kwargs): + tap.injects += 1 + return original.inject(*args, **kwargs) + return Injector() + def extract(self, *args, **kwargs): + self.extracts += 1 + return self.original.extract(*args, **kwargs) + +tap = Tap(traceai_mcp.propagate) +traceai_mcp.propagate = tap +instrumentor = MCPInstrumentor() +instrumentor.instrument(skip_dep_check=True) +if int(version('mcp').split('.')[0]) >= 2: + from mcp.server.mcpserver import MCPServer as Server +else: + from mcp.server.fastmcp import FastMCP as Server +server = Server('local-r3') +started = asyncio.Event() +release = asyncio.Event() + +@server.tool() +async def control(action: str) -> str: + if action == 'wait': + started.set() + await asyncio.wait_for(release.wait(), 8) + elif action == 'release': + release.set() + elif action == 'off': + instrumentor.uninstrument() + elif action == 'on': + instrumentor.instrument(skip_dep_check=True) + return json.dumps({'action': action, 'trace_id': trace.get_current_span().get_span_context().trace_id, + 'started': started.is_set(), 'extracts': tap.extracts, 'injects': tap.injects}) + +if __name__ == '__main__': + server.run(transport='stdio') diff --git a/python/frameworks/mcp/tests/test_local_exchange_r2.py b/python/frameworks/mcp/tests/test_local_exchange_r2.py new file mode 100644 index 000000000..9041a03f3 --- /dev/null +++ b/python/frameworks/mcp/tests/test_local_exchange_r2.py @@ -0,0 +1,58 @@ +"""End-to-end local stdio exchanges with genuine MCP clients and servers.""" +import asyncio +import json +from pathlib import Path +from importlib.metadata import version +import sys + +from mcp import ClientSession, StdioServerParameters +import mcp.client.stdio as stdio +from opentelemetry import context, trace +from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags +from traceai_mcp import MCPInstrumentor + + +def test_real_client_server_exchange_context_concurrency_and_failure(): + async def run(traced): + instrumentor = MCPInstrumentor() + if traced: + instrumentor.instrument(skip_dep_check=True) + args = ['-I', str(Path(__file__).with_name('local_server_r2.py'))] + if traced: + args.append('--traced') + try: + async with stdio.stdio_client(StdioServerParameters(command=sys.executable, args=args)) as (read, write): + async with ClientSession(read, write) as session: + await session.initialize() + tools = await session.list_tools() + assert {'echo', 'fail'} <= {tool.name for tool in tools.tools} + async def one(n): + span = NonRecordingSpan(SpanContext(n, n + 100, False, TraceFlags(1))) + token = context.attach(trace.set_span_in_context(span)) + try: + result = await session.call_tool('echo', {'value': str(n)}) + assert not getattr(result, 'is_error', getattr(result, 'isError', False)) + body = json.loads(result.content[0].text) + assert body['value'] == str(n) + # MCP 2.x propagates OTel context natively; 1.x + # relies on the instrumentor for this transport. + native_propagation = int(version('mcp').split('.')[0]) >= 2 + assert body['trace_id'] == (n if traced or native_propagation else 0) + assert trace.get_current_span().get_span_context().trace_id == n + return body['value'] + finally: + context.detach(token) + values = await asyncio.gather(*(one(n) for n in range(1, 6))) + failure = await session.call_tool('fail', {}) + assert getattr(failure, 'is_error', getattr(failure, 'isError', False)) + failure_text = failure.content[0].text + assert 'fail' in failure_text.lower() + assert not trace.get_current_span().get_span_context().is_valid + return values, failure_text + finally: + if traced: + instrumentor.uninstrument() + untraced = asyncio.run(run(False)) + traced = asyncio.run(run(True)) + assert traced == untraced + assert traced[0] == ['1', '2', '3', '4', '5'] diff --git a/python/frameworks/mcp/tests/test_native_lifecycle.py b/python/frameworks/mcp/tests/test_native_lifecycle.py new file mode 100644 index 000000000..f545c7db9 --- /dev/null +++ b/python/frameworks/mcp/tests/test_native_lifecycle.py @@ -0,0 +1,77 @@ +"""Exercise install, removal and pending import hooks in fresh interpreters.""" +import subprocess +import sys +import textwrap + + +def run(script): + subprocess.run([sys.executable, "-c", textwrap.dedent(script)], check=True) + + +def test_real_transport_restored_and_reinstrumented(): + run(''' + import mcp.client.streamable_http as module + from traceai_mcp import MCPInstrumentor + name = "streamable_http_client" if hasattr(module, "streamable_http_client") else "streamablehttp_client" + original = getattr(module, name) + i = MCPInstrumentor() + for _ in range(2): + i.instrument(skip_dep_check=True) + assert getattr(module, name) is not original + i.uninstrument() + assert getattr(module, name) is original + ''') + + +def test_pending_hook_does_not_wrap_after_uninstrument(): + run(''' + from traceai_mcp import MCPInstrumentor + i = MCPInstrumentor() + i.instrument(skip_dep_check=True) + i.uninstrument() + import mcp.client.streamable_http as module + name = "streamable_http_client" if hasattr(module, "streamable_http_client") else "streamablehttp_client" + from wrapt import ObjectProxy + assert not isinstance(getattr(module, name), ObjectProxy) + ''') + + +def test_pending_hooks_reinstall_once(): + run(''' + import asyncio + from traceai_mcp import MCPInstrumentor, InstrumentedStreamReader + i = MCPInstrumentor() + i.instrument(skip_dep_check=True) + i.uninstrument() + i.instrument(skip_dep_check=True) + import mcp.client.streamable_http as module + name = "streamable_http_client" if hasattr(module, "streamable_http_client") else "streamablehttp_client" + async def check(): + async with getattr(module, name)("http://localhost:9/mcp") as streams: + assert isinstance(streams[0], InstrumentedStreamReader) + assert not isinstance(streams[0].__wrapped__, InstrumentedStreamReader) + asyncio.run(check()) + i.uninstrument() + ''') + + +def test_both_transport_aliases_are_wrapped_and_restored(): + from types import ModuleType + from unittest.mock import patch + from traceai_mcp import MCPInstrumentor + + module = ModuleType("dual_alias_fixture") + def transport(): + pass + module.streamable_http_client = transport + module.streamablehttp_client = transport + hooks = {} + instrumentor = MCPInstrumentor() + with patch.object(instrumentor, "_pending_hooks", set(), create=True), patch("traceai_mcp.register_post_import_hook", side_effect=lambda fn, name: hooks.setdefault(name, fn)): + instrumentor._instrument() + hooks["mcp.client.streamable_http"](module) + assert module.streamable_http_client is not transport + assert module.streamablehttp_client is not transport + instrumentor._uninstrument() + assert module.streamable_http_client is transport + assert module.streamablehttp_client is transport diff --git a/python/frameworks/mcp/tests/test_native_message_compat.py b/python/frameworks/mcp/tests/test_native_message_compat.py new file mode 100644 index 000000000..4e058f28f --- /dev/null +++ b/python/frameworks/mcp/tests/test_native_message_compat.py @@ -0,0 +1,57 @@ +"""Compatibility checks using the installed MCP SDK's actual message models.""" +import asyncio + +from mcp.shared.message import SessionMessage +from mcp.types import JSONRPCMessage, JSONRPCRequest, JSONRPCNotification +from opentelemetry import context, trace +from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags + +from traceai_mcp import InstrumentedStreamReader, InstrumentedStreamWriter + + +def session_message(value): + # The public union became a type alias in MCP 2.x. + try: + value = JSONRPCMessage(root=value) + except TypeError: + pass + return SessionMessage(value) + + +def test_native_request_roundtrip_and_context(): + async def run(): + request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping") + item = session_message(request) + class Sink: + async def send(self, value): + return value + span = NonRecordingSpan(SpanContext(0x123, 0x456, False, TraceFlags(1))) + token = context.attach(trace.set_span_in_context(span)) + try: + sent = await InstrumentedStreamWriter(Sink()).send(item) + finally: + context.detach(token) + assert sent is not item + assert request.params is None + sent_request = getattr(sent.message, "root", sent.message) + assert sent_request.params["_meta"]["traceparent"].endswith("0000000000000456-01") + class Source: + def __aiter__(self): + async def generate(): + yield sent + return generate() + async for received in InstrumentedStreamReader(Source()): + assert received is sent + assert trace.get_current_span().get_span_context().trace_id == 0x123 + assert not trace.get_current_span().get_span_context().is_valid + asyncio.run(run()) + + +def test_notification_remains_unchanged(): + async def run(): + item = session_message(JSONRPCNotification(jsonrpc="2.0", method="ready")) + class Sink: + async def send(self, value): + return value + assert await InstrumentedStreamWriter(Sink()).send(item) is item + asyncio.run(run()) diff --git a/python/frameworks/mcp/tests/test_null_metadata_r5.py b/python/frameworks/mcp/tests/test_null_metadata_r5.py new file mode 100644 index 000000000..10f33579c --- /dev/null +++ b/python/frameworks/mcp/tests/test_null_metadata_r5.py @@ -0,0 +1,76 @@ +import asyncio +from contextlib import nullcontext + +import pytest +from mcp.shared.message import SessionMessage +from mcp.types import CallToolRequestParams, JSONRPCMessage, JSONRPCRequest +from opentelemetry import context, trace + +from traceai_mcp import InstrumentedStreamWriter + + +class Sink: + async def send(self, item): + self.item = item + return "sent" + + +def envelope(request): + try: + return SessionMessage(JSONRPCMessage(root=request)) + except TypeError: + return SessionMessage(request) + + +@pytest.mark.parametrize("active_span", (False, True)) +def test_optional_null_metadata_is_safe_and_caller_owned(active_span): + asyncio.run(check_optional_metadata(active_span)) + + +async def check_optional_metadata(active_span): + params = {"name": "echo", "arguments": {"value": "hello"}, "_meta": None} + assert CallToolRequestParams.model_validate(params).meta is None + request = JSONRPCRequest(jsonrpc="2.0", id=1, method="tools/call", params=params) + item = envelope(request) + sink = Sink() + writer = InstrumentedStreamWriter(sink) + token = context.attach(context.Context()) + span = trace.NonRecordingSpan( + trace.SpanContext(42, 43, False, trace.TraceFlags(1), trace.TraceState()) + ) + try: + with trace.use_span(span) if active_span else nullcontext(): + assert await writer.send(item) == "sent" + finally: + context.detach(token) + assert request.params["_meta"] is None + assert params["_meta"] is None + assert request.params["arguments"] is params["arguments"] + sent_request = getattr(sink.item.message, "root", sink.item.message) + if active_span: + assert sink.item is not item + assert sent_request.params["_meta"]["traceparent"] == ( + "00-0000000000000000000000000000002a-000000000000002b-01" + ) + else: + assert sink.item is item + assert sent_request.params["_meta"] is None + + +def test_no_propagation_does_not_add_empty_metadata(): + asyncio.run(check_no_propagation()) + + +async def check_no_propagation(): + request = JSONRPCRequest( + jsonrpc="2.0", id=1, method="tools/call", params={"name": "echo"} + ) + item = envelope(request) + sink = Sink() + token = context.attach(context.Context()) + try: + assert await InstrumentedStreamWriter(sink).send(item) == "sent" + finally: + context.detach(token) + assert sink.item is item + assert "_meta" not in request.params diff --git a/python/frameworks/mcp/tests/test_r2_regressions.py b/python/frameworks/mcp/tests/test_r2_regressions.py new file mode 100644 index 000000000..3489f688a --- /dev/null +++ b/python/frameworks/mcp/tests/test_r2_regressions.py @@ -0,0 +1,82 @@ +"""MCP SDK lifecycle and transport transparency regressions.""" +import asyncio +import subprocess +import sys +import textwrap + +import anyio +from traceai_mcp import InstrumentedStreamReader + + +def test_exception_item_identity(): + async def run(): + send, receive = anyio.create_memory_object_stream(1) + error = ValueError('transport error') + await send.send(error) + await send.aclose() + items = [item async for item in InstrumentedStreamReader(receive)] + assert len(items) == 1 and items[0] is error + asyncio.run(run()) + + +def test_foreign_wrapper_survives_disable_and_reinstall(): + script = ''' +import asyncio +import mcp.client.streamable_http as module +from wrapt import wrap_function_wrapper +from traceai_mcp import MCPInstrumentor, InstrumentedStreamReader +name = 'streamable_http_client' if hasattr(module, 'streamable_http_client') else 'streamablehttp_client' +i = MCPInstrumentor() +calls = [] +def foreign(wrapped, instance, args, kwargs): + calls.append(1) + return wrapped(*args, **kwargs) +async def check(expected): + async with getattr(module, name)('http://localhost:9/mcp') as streams: + reader = streams[0] + assert isinstance(reader, InstrumentedStreamReader) == expected + if expected: + assert not isinstance(reader.__wrapped__, InstrumentedStreamReader) +i.instrument(skip_dep_check=True) +wrap_function_wrapper(module, name, foreign) +foreign_installed = getattr(module, name) +i.uninstrument() +assert getattr(module, name) is foreign_installed +asyncio.run(check(False)) +i.instrument(skip_dep_check=True) +asyncio.run(check(True)) +i.uninstrument() +assert getattr(module, name) is foreign_installed +asyncio.run(check(False)) +assert len(calls) == 3 +''' + subprocess.run([sys.executable, '-I', '-c', textwrap.dedent(script)], check=True, timeout=20) + + +def test_real_stdio_malformed_message_is_exception(): + # The SDK's stdio transport parses this invalid line and puts the actual + # Pydantic parse exception on its receive stream rather than raising it. + async def run(traced): + from mcp import StdioServerParameters + import mcp.client.stdio as stdio + from traceai_mcp import MCPInstrumentor + i = MCPInstrumentor() + if traced: + i.instrument(skip_dep_check=True) + try: + params = StdioServerParameters(command=sys.executable, args=['-I', '-c', "print('not-json', flush=True)"]) + async with stdio.stdio_client(params) as (reader, writer): + with anyio.fail_after(5): + iterator = reader.__aiter__() + try: + item = await anext(iterator) + finally: + if hasattr(iterator, 'aclose'): + await iterator.aclose() + await writer.aclose() + assert isinstance(item, Exception), repr(item) + return type(item).__name__ + finally: + if traced: + i.uninstrument() + assert asyncio.run(run(False)) == asyncio.run(run(True)) diff --git a/python/frameworks/mcp/tests/test_r3_liveness.py b/python/frameworks/mcp/tests/test_r3_liveness.py new file mode 100644 index 000000000..f8ac3adaa --- /dev/null +++ b/python/frameworks/mcp/tests/test_r3_liveness.py @@ -0,0 +1,285 @@ +"""Lifecycle regressions for streams already handed to native MCP sessions.""" +import asyncio +import json +import sys +from pathlib import Path + +import anyio +from mcp import ClientSession, StdioServerParameters +import mcp.client.stdio as stdio +from opentelemetry import context, trace +from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags +from traceai_mcp import MCPInstrumentor, ContextSavingStreamWriter, ContextAttachingStreamReader, _StreamState +import traceai_mcp +from wrapt import wrap_function_wrapper + + +class Tap: + def __init__(self, original): + self.original = original + self.injects = self.extracts = 0 + def get_global_textmap(self): + original = self.original.get_global_textmap() + tap = self + class Injector: + def inject(self, *args, **kwargs): + tap.injects += 1 + return original.inject(*args, **kwargs) + return Injector() + def extract(self, *args, **kwargs): + self.extracts += 1 + return self.original.extract(*args, **kwargs) + + +def test_queue_transitions_preserve_items_and_context(): + async def run(): + state = _StreamState() + send, receive = anyio.create_memory_object_stream(4) + writer = ContextSavingStreamWriter(send, state) + reader = ContextAttachingStreamReader(receive, state) + span = NonRecordingSpan(SpanContext(42, 43, False, TraceFlags(1))) + token = context.attach(trace.set_span_in_context(span)) + try: + await writer.send('enabled-before-disable') + state.active = False + await writer.send('disabled-before-reinstall') + finally: + context.detach(token) + iterator = reader.__aiter__() + assert await anext(iterator) == 'enabled-before-disable' + assert not trace.get_current_span().get_span_context().is_valid + state.active = True + assert await anext(iterator) == 'disabled-before-reinstall' + assert not trace.get_current_span().get_span_context().is_valid + token = context.attach(trace.set_span_in_context(span)) + try: + await writer.send('enabled-after-reinstall') + finally: + context.detach(token) + assert await anext(iterator) == 'enabled-after-reinstall' + assert trace.get_current_span().get_span_context().trace_id == 42 + await iterator.aclose() + assert not trace.get_current_span().get_span_context().is_valid + await send.aclose(); await receive.aclose() + asyncio.run(run()) + + +def test_open_native_client_and_server_lifecycle(monkeypatch): + async def run(): + instrumentor = MCPInstrumentor() + tap = Tap(traceai_mcp.propagate) + monkeypatch.setattr(traceai_mcp, 'propagate', tap) + operations = [] + original_send = traceai_mcp.InstrumentedStreamWriter.send + async def observed_send(proxy, item): + message = getattr(item, 'message', None) + request = getattr(message, 'root', message) + before = tap.injects + active = proxy._self_state.active + result = await original_send(proxy, item) + if getattr(request, 'method', None) == 'tools/call': + operations.append((active, tap.injects - before)) + return result + monkeypatch.setattr(traceai_mcp.InstrumentedStreamWriter, 'send', observed_send) + calls = [] + original_factory = stdio.stdio_client + instrumentor.instrument(skip_dep_check=True) + def foreign(wrapped, instance, args, kwargs): + calls.append(1) + return wrapped(*args, **kwargs) + wrap_function_wrapper(stdio, 'stdio_client', foreign) + foreign_installed = stdio.stdio_client + params = StdioServerParameters(command=sys.executable, args=['-I', str(Path(__file__).with_name('local_server_r3.py'))]) + async def call(session, action, n): + token = context.attach(trace.set_span_in_context(NonRecordingSpan(SpanContext(n, n+100, False, TraceFlags(1))))) + try: + with anyio.fail_after(8): + result = await session.call_tool('control', {'action': action}) + return json.loads(result.content[0].text) + finally: + context.detach(token) + try: + with anyio.fail_after(30): + async with stdio.stdio_client(params) as (read, write): + async with ClientSession(read, write) as session: + await session.initialize() + a = await call(session, 'sample', 7) + assert operations[-1] == (True, 1) + instrumentor.uninstrument() + assert stdio.stdio_client is foreign_installed + start = tap.injects + b = await call(session, 'off', 8) + c = await call(session, 'sample', 9) + assert tap.injects == start + assert c['extracts'] == b['extracts'] + instrumentor.instrument(skip_dep_check=True) + d = await call(session, 'on', 10) + e = await call(session, 'sample', 11) + assert operations[-2:] == [(True, 1), (True, 1)] + assert e['extracts'] == d['extracts'] + 1 + instrumentor.uninstrument() + start = tap.injects + f = await call(session, 'off', 12) + g = await call(session, 'sample', 13) + assert tap.injects == start + assert g['extracts'] == f['extracts'] + assert [x['action'] for x in (a,b,c,d,e,f,g)] == ['sample','off','sample','on','sample','off','sample'] + from importlib.metadata import version + if version('mcp').startswith('1.'): + assert [x['trace_id'] for x in (a,c,e)] == [7, 0, 11] + assert stdio.stdio_client is foreign_installed and len(calls) == 1 + finally: + if instrumentor.is_instrumented_by_opentelemetry: + instrumentor.uninstrument() + stdio.stdio_client = original_factory + asyncio.run(run()) + + +def test_concurrent_open_sessions_with_inflight_response(): + from contextlib import AsyncExitStack + async def run(): + instrumentor = MCPInstrumentor() + instrumentor.instrument(skip_dep_check=True) + params = StdioServerParameters(command=sys.executable, args=['-I', str(Path(__file__).with_name('local_server_r3.py'))]) + async def call(session, action, n): + token = context.attach(trace.set_span_in_context(NonRecordingSpan(SpanContext(n, n+100, False, TraceFlags(1))))) + try: + with anyio.fail_after(8): + result = await session.call_tool('control', {'action': action}) + assert trace.get_current_span().get_span_context().trace_id == n + return json.loads(result.content[0].text) + finally: + context.detach(token) + try: + with anyio.fail_after(35): + async with AsyncExitStack() as stack: + sessions = [] + for _ in range(2): + reader, writer = await stack.enter_async_context(stdio.stdio_client(params)) + session = await stack.enter_async_context(ClientSession(reader, writer)) + await session.initialize() + sessions.append(session) + pending = asyncio.create_task(call(sessions[0], 'wait', 21)) + try: + while not (await call(sessions[0], 'status', 22))['started']: + await asyncio.sleep(.01) + await call(sessions[0], 'off', 23) + instrumentor.uninstrument() + disabled = await asyncio.gather(*(call(sessions[i % 2], 'sample', 30+i) for i in range(6))) + assert [x['action'] for x in disabled] == ['sample'] * 6 + instrumentor.instrument(skip_dep_check=True) + await call(sessions[0], 'on', 40) + enabled = await asyncio.gather(*(call(sessions[i % 2], 'sample', 50+i) for i in range(6))) + assert [x['trace_id'] for x in enabled] == list(range(50, 56)) + await call(sessions[0], 'release', 60) + answer = await pending + assert answer['action'] == 'wait' and answer['trace_id'] == 21 + finally: + if not pending.done(): + pending.cancel() + try: + await pending + except asyncio.CancelledError: + pass + finally: + if instrumentor.is_instrumented_by_opentelemetry: + instrumentor.uninstrument() + asyncio.run(run()) + + +def test_caller_metadata_preserved_and_disabled_message_untouched(): + from mcp.shared.message import SessionMessage + from mcp.types import JSONRPCMessage, JSONRPCRequest + from traceai_mcp import InstrumentedStreamWriter + async def run(): + state = _StreamState() + seen = [] + class Sink: + async def send(self, item): + seen.append(item) + return item + def item(): + request = JSONRPCRequest(jsonrpc='2.0', id=7, method='tools/call', params={ + 'name': 'example', '_meta': {'custom': {'keep': True}, 'traceparent': '00-00000000000000000000000000000001-0000000000000002-01'}}) + try: + message = JSONRPCMessage(root=request) + except TypeError: + message = request + return request, SessionMessage(message) + writer = InstrumentedStreamWriter(Sink(), state) + span = NonRecordingSpan(SpanContext(42, 43, False, TraceFlags(1))) + token = context.attach(trace.set_span_in_context(span)) + try: + request, message = item() + before = request.model_dump() + assert await writer.send(message) is message + assert request.model_dump() == before + state.active = False + request, message = item() + before = request.model_dump() + assert await writer.send(message) is message + assert request.model_dump() == before + assert seen[-1] is message + finally: + context.detach(token) + asyncio.run(run()) + + +def test_local_http_open_session_lifecycle(): + import socket + import uvicorn + from importlib.metadata import version + if int(version('mcp').split('.')[0]) >= 2: + from mcp.server.mcpserver import MCPServer as Server + else: + from mcp.server.fastmcp import FastMCP as Server + import mcp.client.streamable_http as transport + async def run(): + instrumentor = MCPInstrumentor() + instrumentor.instrument(skip_dep_check=True) + server = Server('local-http-r3') + @server.tool() + async def echo(value: str) -> str: + return json.dumps({'value': value, 'trace_id': trace.get_current_span().get_span_context().trace_id}) + sock = socket.socket() + sock.bind(('127.0.0.1', 0)) + sock.listen(128) + port = sock.getsockname()[1] + uv = uvicorn.Server(uvicorn.Config(server.streamable_http_app(), log_level='error', lifespan='on')) + server_task = asyncio.create_task(uv.serve(sockets=[sock])) + async def call(session, n): + token = context.attach(trace.set_span_in_context(NonRecordingSpan(SpanContext(n, n+100, False, TraceFlags(1))))) + try: + with anyio.fail_after(8): + result = await session.call_tool('echo', {'value': str(n)}) + return json.loads(result.content[0].text) + finally: + context.detach(token) + try: + with anyio.fail_after(30): + while not uv.started: + if server_task.done(): + await server_task + raise RuntimeError('HTTP server exited before startup') + await asyncio.sleep(.01) + factory = getattr(transport, 'streamable_http_client', None) or transport.streamablehttp_client + async with factory(f'http://127.0.0.1:{port}/mcp') as streams: + async with ClientSession(streams[0], streams[1]) as session: + await session.initialize() + a = await call(session, 71) + instrumentor.uninstrument() + b = await call(session, 72) + instrumentor.instrument(skip_dep_check=True) + c = await call(session, 73) + assert [x['value'] for x in (a,b,c)] == ['71','72','73'] + if version('mcp').startswith('1.'): + assert [x['trace_id'] for x in (a,b,c)] == [71, 0, 73] + finally: + if instrumentor.is_instrumented_by_opentelemetry: + instrumentor.uninstrument() + uv.should_exit = True + try: + await asyncio.wait_for(server_task, 8) + finally: + sock.close() + asyncio.run(run()) diff --git a/python/frameworks/mcp/tests/test_r4_reuse.py b/python/frameworks/mcp/tests/test_r4_reuse.py new file mode 100644 index 000000000..8972049ee --- /dev/null +++ b/python/frameworks/mcp/tests/test_r4_reuse.py @@ -0,0 +1,214 @@ +"""Caller-owned message and pending-import lifecycle regressions.""" +import asyncio +from copy import deepcopy +import json +from pathlib import Path +import subprocess +import sys +import textwrap + +import anyio +from mcp import StdioServerParameters +from mcp.shared.message import SessionMessage +from mcp.types import JSONRPCMessage, JSONRPCRequest, JSONRPCNotification, LATEST_PROTOCOL_VERSION +import mcp.client.stdio as stdio +from opentelemetry import context, trace +from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags +from traceai_mcp import MCPInstrumentor, InstrumentedStreamWriter, _StreamState + + +def envelope(request): + try: + return SessionMessage(JSONRPCMessage(root=request)) + except TypeError: + return SessionMessage(request) + + +def attach(n): + return context.attach(trace.set_span_in_context(NonRecordingSpan(SpanContext(n, n + 100, False, TraceFlags(1))))) + + +def request(n=17, params=None): + return envelope(JSONRPCRequest(jsonrpc='2.0', id=n, method='tools/call', params=params or {'name': 'echo', 'arguments': {'value': 'same'}})) + + +def test_copy_path_concurrent_and_caller_metadata(): + async def run(): + state = _StreamState() + seen = [] + sentinel = object() + class Sink: + async def send(self, item): + await asyncio.sleep(0) + seen.append(item) + return sentinel + writer = InstrumentedStreamWriter(Sink(), state) + msg = request() + original = deepcopy(msg) + req = getattr(msg.message, 'root', msg.message) + payload = req.params['arguments'] + async def send(n): + token = attach(n) + try: + assert await writer.send(msg) is sentinel + finally: + context.detach(token) + await asyncio.gather(send(401), send(402)) + assert msg == original + assert {getattr(x.message, 'root', x.message).params['_meta']['traceparent'].split('-')[1] for x in seen} == {f'{401:032x}', f'{402:032x}'} + for x in seen: + assert type(x) is type(msg) and type(x.message) is type(msg.message) + assert getattr(x.message, 'root', x.message).params['arguments'] is payload + assert x.metadata is msg.metadata + state.active = False + await send(403) + assert seen[-1] is msg and msg == original + state.active = True + explicit = request(params={'name': 'echo', 'arguments': payload, '_meta': {'traceparent': '00-00000000000000000000000000000001-0000000000000002-01', 'custom': payload}}) + snapshot = deepcopy(explicit) + token = attach(404) + try: + await writer.send(explicit) + finally: + context.detach(token) + assert explicit == snapshot + assert getattr(seen[-1].message, 'root', seen[-1].message).params['_meta']['traceparent'].split('-')[1] == f'{1:032x}' + asyncio.run(run()) + + +def test_native_stdio_reused_request_and_disable(): + async def run(): + inst = MCPInstrumentor() + inst.instrument(skip_dep_check=True) + server = str(Path(__file__).with_name('local_server_r2.py')) + params = StdioServerParameters(command=sys.executable, args=['-I', server, '--traced']) + try: + with anyio.fail_after(30): + async with stdio.stdio_client(params) as (reader, writer): + iterator = reader.__aiter__() + async def response(n): + while True: + item = await anext(iterator) + if isinstance(item, Exception): + raise item + m = getattr(item.message, 'root', item.message) + if getattr(m, 'id', None) == n: + return m + await writer.send(envelope(JSONRPCRequest(jsonrpc='2.0', id=1, method='initialize', params={'protocolVersion': LATEST_PROTOCOL_VERSION, 'capabilities': {}, 'clientInfo': {'name': 'reuse', 'version': '1'}}))) + assert hasattr(await response(1), 'result') + await writer.send(envelope(JSONRPCNotification(jsonrpc='2.0', method='notifications/initialized'))) + msg = request(); snapshot = deepcopy(msg) + for n in (401, 402, 403, 404): + if n == 403: + inst.uninstrument() + if n == 404: + inst.instrument(skip_dep_check=True) + token = attach(n) + try: + assert await writer.send(msg) is None + finally: + context.detach(token) + result = (await response(17)).result + data = result if isinstance(result, dict) else result.model_dump() + body = json.loads(data['content'][0]['text']) + assert body == {'value': 'same', 'trace_id': 0 if n == 403 else n} + assert msg == snapshot + await writer.aclose(); await iterator.aclose() + finally: + if inst.is_instrumented_by_opentelemetry: + inst.uninstrument() + asyncio.run(run()) + + +def test_pending_hooks_shared_instances_and_import_while_disabled(): + script = ''' +import sys +import wrapt.importer as hooks +from traceai_mcp import MCPInstrumentor +name = 'mcp.client.sse' +assert name not in sys.modules +one = MCPInstrumentor(); two = MCPInstrumentor() +assert one is two +for _ in range(100): + one.instrument(skip_dep_check=True); two.uninstrument() +assert len(hooks._post_import_hooks.get(name, [])) == 1 +import mcp.client.sse as module +original = module.sse_client +assert len(hooks._post_import_hooks.get(name, [])) == 0 +one.instrument(skip_dep_check=True) +assert module.sse_client is not original +two.uninstrument() +assert module.sse_client is original +one.instrument(skip_dep_check=True) +assert module.sse_client is not original +one.uninstrument() +assert module.sse_client is original +''' + subprocess.run([sys.executable, '-I', '-c', textwrap.dedent(script)], check=True, timeout=30) + + +def test_native_http_reused_request_and_disable(): + import socket + import mcp.client.streamable_http as transport + async def run(): + sock = socket.socket() + sock.bind(('127.0.0.1', 0)) + port = sock.getsockname()[1] + sock.close() + server = subprocess.Popen([sys.executable, '-I', str(Path(__file__).with_name('local_http_server_r4.py')), str(port)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + inst = MCPInstrumentor() + try: + with anyio.fail_after(30): + while True: + if server.poll() is not None: + raise RuntimeError('loopback server exited') + try: + reader, writer = await asyncio.open_connection('127.0.0.1', port) + writer.close() + await writer.wait_closed() + break + except OSError: + await asyncio.sleep(.05) + inst.instrument(skip_dep_check=True) + factory = getattr(transport, 'streamable_http_client', None) or transport.streamablehttp_client + async with factory(f'http://127.0.0.1:{port}/mcp') as streams: + reader, writer = streams[:2] + iterator = reader.__aiter__() + async def response(n): + while True: + item = await anext(iterator) + if isinstance(item, Exception): + raise item + m = getattr(item.message, 'root', item.message) + if getattr(m, 'id', None) == n: + return m + await writer.send(envelope(JSONRPCRequest(jsonrpc='2.0', id=1, method='initialize', params={'protocolVersion': LATEST_PROTOCOL_VERSION, 'capabilities': {}, 'clientInfo': {'name': 'reuse-http', 'version': '1'}}))) + assert hasattr(await response(1), 'result') + await writer.send(envelope(JSONRPCNotification(jsonrpc='2.0', method='notifications/initialized'))) + msg = request(); snapshot = deepcopy(msg) + for n in (401, 402, 403, 404): + if n == 403: + inst.uninstrument() + if n == 404: + inst.instrument(skip_dep_check=True) + token = attach(n) + try: + assert await writer.send(msg) is None + finally: + context.detach(token) + result = (await response(17)).result + data = result if isinstance(result, dict) else result.model_dump() + assert json.loads(data['content'][0]['text']) == {'value': 'same', 'trace_id': 0 if n == 403 else n} + assert msg == snapshot + await writer.aclose() + await iterator.aclose() + finally: + if inst.is_instrumented_by_opentelemetry: + inst.uninstrument() + server.terminate() + try: + await asyncio.wait_for(asyncio.to_thread(server.wait), 5) + except asyncio.TimeoutError: + server.kill() + await asyncio.to_thread(server.wait) + asyncio.run(run()) diff --git a/python/frameworks/mcp/traceai_mcp/__init__.py b/python/frameworks/mcp/traceai_mcp/__init__.py index 37b949b19..3b8fddfe0 100644 --- a/python/frameworks/mcp/traceai_mcp/__init__.py +++ b/python/frameworks/mcp/traceai_mcp/__init__.py @@ -1,10 +1,11 @@ from contextlib import asynccontextmanager +from copy import copy from dataclasses import dataclass from typing import Any, AsyncGenerator, Callable, Collection, Tuple, cast +from weakref import ref from opentelemetry import context, propagate from opentelemetry.instrumentation.instrumentor import BaseInstrumentor # type: ignore -from opentelemetry.instrumentation.utils import unwrap from traceai_mcp.package import _instruments from wrapt import ObjectProxy, register_post_import_hook, wrap_function_wrapper @@ -18,70 +19,76 @@ def instrumentation_dependencies(self) -> Collection[str]: return _instruments def _instrument(self, **kwargs: Any) -> None: - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.client.streamable_http", - "streamablehttp_client", - self._wrap_transport_with_callback, - ), - "mcp.client.streamable_http", - ) - - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.server.streamable_http", - "StreamableHTTPServerTransport.connect", - self._wrap_plain_transport, - ), - "mcp.server.streamable_http", - ) - - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.client.sse", "sse_client", self._wrap_plain_transport - ), - "mcp.client.sse", - ) - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.server.sse", - "SseServerTransport.connect_sse", - self._wrap_plain_transport, - ), - "mcp.server.sse", - ) - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.client.stdio", "stdio_client", self._wrap_plain_transport - ), - "mcp.client.stdio", - ) - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.server.stdio", "stdio_server", self._wrap_plain_transport - ), - "mcp.server.stdio", - ) - - # While we prefer to instrument the lowest level primitive, the transports above, it doesn't - # mean context will be propagated to handlers automatically. Notably, the MCP SDK passes - # server messages to a handler with a separate stream in between, losing context. We go - # ahead and instrument this second stream just to propagate context so transports can still - # be used independently while also supporting the major usage of the MCP SDK. Notably, this - # may be a reasonable generic instrumentation for anyio itself to allow its streams to - # propagate context broadly. - register_post_import_hook( - lambda _: wrap_function_wrapper( - "mcp.server.session", - "ServerSession.__init__", - self._base_session_init_wrapper, - ), - "mcp.server.session", - ) + # Hooks can remain pending after uninstrument(), so associate each one + # with this instrumentation generation and ignore stale callbacks. + generation = object() + # Existing sessions retain their stream proxies across installations. + # Share one switch across generations so reinstall reactivates them. + if not hasattr(self, "_stream_state"): + self._stream_state = _StreamState() + self._stream_state.active = True + self._hook_generation = generation + self._wrapped_targets = [] + + if not hasattr(self, "_pending_hooks"): + self._pending_hooks = set() + + def register(module_name: str, names: Tuple[str, ...], wrapper_name: str) -> None: + # wrapt offers no public hook removal API. Reuse a single pending + # hook per module across enable cycles and hold only a weak owner. + if module_name in self._pending_hooks: + return + self._pending_hooks.add(module_name) + owner_ref = ref(self) + + def on_import(module: Any) -> None: + instrumentor = owner_ref() + if instrumentor is None: + return + instrumentor._pending_hooks.discard(module_name) + current_generation = instrumentor._hook_generation + if current_generation is None: + return + wrapper = getattr(instrumentor, wrapper_name) + for name in names: + owner = module + parts = name.split(".") + for part in parts[:-1]: + owner = getattr(owner, part, None) + if owner is None: + break + if owner is None or parts[-1] not in vars(owner): + continue + attr = parts[-1] + original = vars(owner)[attr] + + # A foreign wrapper may retain ours after teardown. + def dispatch(wrapped: Callable[..., Any], instance: Any, args: Any, kwargs: Any) -> Any: + if instrumentor._hook_generation is not current_generation: + return wrapped(*args, **kwargs) + return wrapper(wrapped, instance, args, kwargs) + + wrap_function_wrapper(module, name, dispatch) + installed = vars(owner)[attr] + instrumentor._wrapped_targets.append((owner, attr, original, installed)) + register_post_import_hook(on_import, module_name) + + register("mcp.client.streamable_http", ("streamable_http_client", "streamablehttp_client"), "_wrap_transport_with_callback") + register("mcp.server.streamable_http", ("StreamableHTTPServerTransport.connect",), "_wrap_plain_transport") + register("mcp.client.sse", ("sse_client",), "_wrap_plain_transport") + register("mcp.server.sse", ("SseServerTransport.connect_sse",), "_wrap_plain_transport") + register("mcp.client.stdio", ("stdio_client",), "_wrap_plain_transport") + register("mcp.server.stdio", ("stdio_server",), "_wrap_plain_transport") + register("mcp.server.session", ("ServerSession.__init__",), "_base_session_init_wrapper") def _uninstrument(self, **kwargs: Any) -> None: - unwrap("mcp.client.stdio", "stdio_client") - unwrap("mcp.server.stdio", "stdio_server") + self._hook_generation = None + self._stream_state.active = False + for owner, attr, original, installed in reversed(self._wrapped_targets): + # Do not erase wrappers installed by another instrumentor later. + if vars(owner).get(attr) is installed: + setattr(owner, attr, original) + self._wrapped_targets = [] @asynccontextmanager async def _wrap_transport_with_callback( @@ -89,16 +96,20 @@ async def _wrap_transport_with_callback( ) -> AsyncGenerator[ Tuple["InstrumentedStreamReader", "InstrumentedStreamWriter", Any], None ]: - async with wrapped(*args, **kwargs) as ( - read_stream, - write_stream, - get_session_id_callback, - ): - yield ( - InstrumentedStreamReader(read_stream), - InstrumentedStreamWriter(write_stream), - get_session_id_callback, - ) + async with wrapped(*args, **kwargs) as streams: + if len(streams) == 3: + read_stream, write_stream, get_session_id_callback = streams + yield ( + InstrumentedStreamReader(read_stream, self._stream_state), + InstrumentedStreamWriter(write_stream, self._stream_state), + get_session_id_callback, + ) + else: + read_stream, write_stream = streams + yield ( + InstrumentedStreamReader(read_stream, self._stream_state), + InstrumentedStreamWriter(write_stream, self._stream_state), + ) @asynccontextmanager async def _wrap_plain_transport( @@ -107,8 +118,8 @@ async def _wrap_plain_transport( Tuple["InstrumentedStreamReader", "InstrumentedStreamWriter"], None ]: async with wrapped(*args, **kwargs) as (read_stream, write_stream): - yield InstrumentedStreamReader(read_stream), InstrumentedStreamWriter( - write_stream + yield InstrumentedStreamReader(read_stream, self._stream_state), InstrumentedStreamWriter( + write_stream, self._stream_state ) def _base_session_init_wrapper( @@ -121,16 +132,26 @@ def _base_session_init_wrapper( setattr( instance, "_incoming_message_stream_reader", - ContextAttachingStreamReader(reader), + ContextAttachingStreamReader(reader, self._stream_state), ) setattr( instance, "_incoming_message_stream_writer", - ContextSavingStreamWriter(writer), + ContextSavingStreamWriter(writer, self._stream_state), ) -class InstrumentedStreamReader(ObjectProxy): # type: ignore +class _StreamState: + active = True + + +class _SwitchableProxy(ObjectProxy): # type: ignore + def __init__(self, wrapped: Any, state: Any = None) -> None: + super().__init__(wrapped) + self._self_state = state if state is not None else _StreamState() + + +class InstrumentedStreamReader(_SwitchableProxy): # ObjectProxy missing context manager - https://github.com/GrahamDumpleton/wrapt/issues/73 async def __aenter__(self) -> Any: return await self.__wrapped__.__aenter__() @@ -143,8 +164,15 @@ async def __aiter__(self) -> AsyncGenerator[Any, None]: from mcp.types import JSONRPCRequest async for item in self.__wrapped__: + # SDK receive streams carry transport exceptions as values. + if not self._self_state.active or isinstance(item, Exception): + yield item + continue session_message = cast(SessionMessage, item) - request = session_message.message.root + message = session_message.message + # MCP 1.x uses a JSONRPCMessage root model; 2.x stores the + # concrete JSONRPC variant directly. + request = getattr(message, "root", message) if not isinstance(request, JSONRPCRequest): yield item @@ -163,7 +191,7 @@ async def __aiter__(self) -> AsyncGenerator[Any, None]: yield item -class InstrumentedStreamWriter(ObjectProxy): # type: ignore +class InstrumentedStreamWriter(_SwitchableProxy): # ObjectProxy missing context manager - https://github.com/GrahamDumpleton/wrapt/issues/73 async def __aenter__(self) -> Any: return await self.__wrapped__.__aenter__() @@ -175,16 +203,35 @@ async def send(self, item: Any) -> Any: from mcp.shared.message import SessionMessage from mcp.types import JSONRPCRequest + if not self._self_state.active or isinstance(item, Exception): + return await self.__wrapped__.send(item) session_message = cast(SessionMessage, item) - request = session_message.message.root + message = session_message.message + request = getattr(message, "root", message) if not isinstance(request, JSONRPCRequest): return await self.__wrapped__.send(item) - meta = None - if not request.params: - request.params = {} - meta = request.params.setdefault("_meta", {}) - propagate.get_global_textmap().inject(meta) - return await self.__wrapped__.send(item) + carrier: dict = {} + propagate.get_global_textmap().inject(carrier) + if not carrier: + return await self.__wrapped__.send(item) + # Copy only the envelope and the metadata path: arbitrary request + # payloads and transport metadata retain their native identity. + params = dict(request.params or {}) + original_meta = params.get("_meta") + meta = {} if original_meta is None else dict(original_meta) + if "_meta" in params and all(key in meta for key in carrier): + return await self.__wrapped__.send(item) + for key, value in carrier.items(): + meta.setdefault(key, value) + params["_meta"] = meta + request_copy = request.model_copy(update={"params": params}) + if message is request: + message_copy = request_copy + else: + message_copy = message.model_copy(update={"root": request_copy}) + session_copy = copy(session_message) + session_copy.message = message_copy + return await self.__wrapped__.send(session_copy) @dataclass(slots=True, frozen=True) @@ -193,7 +240,7 @@ class ItemWithContext: ctx: context.Context -class ContextSavingStreamWriter(ObjectProxy): # type: ignore +class ContextSavingStreamWriter(_SwitchableProxy): async def __aenter__(self) -> Any: return await self.__wrapped__.__aenter__() @@ -201,11 +248,13 @@ async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: return await self.__wrapped__.__aexit__(exc_type, exc_value, traceback) async def send(self, item: Any) -> Any: + if not self._self_state.active: + return await self.__wrapped__.send(item) ctx = context.get_current() return await self.__wrapped__.send(ItemWithContext(item, ctx)) -class ContextAttachingStreamReader(ObjectProxy): # type: ignore +class ContextAttachingStreamReader(_SwitchableProxy): async def __aenter__(self) -> Any: return await self.__wrapped__.__aenter__() @@ -214,7 +263,15 @@ async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: async def __aiter__(self) -> AsyncGenerator[Any, None]: async for item in self.__wrapped__: - item_with_context = cast(ItemWithContext, item) + # Items can cross a lifecycle transition while queued. Always + # unwrap our envelope, but attach only while currently enabled. + if not isinstance(item, ItemWithContext): + yield item + continue + if not self._self_state.active: + yield item.item + continue + item_with_context = item restore = context.attach(item_with_context.ctx) try: yield item_with_context.item diff --git a/python/frameworks/mcp/traceai_mcp/package.py b/python/frameworks/mcp/traceai_mcp/package.py index 8da00be0c..776712fc2 100644 --- a/python/frameworks/mcp/traceai_mcp/package.py +++ b/python/frameworks/mcp/traceai_mcp/package.py @@ -1 +1 @@ -_instruments = ("mcp >= 0.1.0",) +_instruments = ("mcp >= 1.8.1",) diff --git a/python/tests/test_framework_mcp.py b/python/tests/test_framework_mcp.py index 3872dddd4..19c9daf09 100644 --- a/python/tests/test_framework_mcp.py +++ b/python/tests/test_framework_mcp.py @@ -33,15 +33,15 @@ def tracer_provider(): def mock_mcp_modules(): """Mock MCP modules and classes.""" mock_modules = {} - + # Mock SessionMessage and JSONRPCRequest mock_session_message = MagicMock() mock_jsonrpc_request = MagicMock() mock_jsonrpc_request.params = {"test": "value"} - + mock_modules["session_message"] = mock_session_message mock_modules["jsonrpc_request"] = mock_jsonrpc_request - + return mock_modules @@ -63,31 +63,38 @@ def test_instrumentation_dependencies(self): """Test instrumentor dependencies are properly declared.""" instrumentor = MCPInstrumentor() dependencies = instrumentor.instrumentation_dependencies() - + + from importlib.metadata import requires + from packaging.requirements import Requirement + assert isinstance(dependencies, tuple) - assert "mcp >= 0.1.0" in dependencies - assert len(dependencies) >= 2 + mcp_deps = [Requirement(dep) for dep in dependencies if Requirement(dep).name == "mcp"] + metadata_deps = [Requirement(dep) for dep in requires("traceAI-mcp") if Requirement(dep).name == "mcp"] + assert len(mcp_deps) == len(metadata_deps) == 1 + assert mcp_deps[0].specifier == metadata_deps[0].specifier + assert "1.8.0" not in mcp_deps[0].specifier + assert "1.8.1" in mcp_deps[0].specifier def test_instrument_registers_post_import_hooks(self): """Test that instrumentation registers all necessary post-import hooks.""" instrumentor = MCPInstrumentor() - - with patch("traceai_mcp.register_post_import_hook") as mock_register: + + with patch.object(instrumentor, "_pending_hooks", set(), create=True), patch("traceai_mcp.register_post_import_hook") as mock_register: instrumentor._instrument() - + # Verify all expected post-import hooks are registered expected_modules = [ "mcp.client.streamable_http", - "mcp.server.streamable_http", + "mcp.server.streamable_http", "mcp.client.sse", "mcp.server.sse", "mcp.client.stdio", "mcp.server.stdio", "mcp.server.session" ] - + assert mock_register.call_count == len(expected_modules) - + # Check that each expected module was registered called_modules = [call.args[1] for call in mock_register.call_args_list] for module in expected_modules: @@ -95,107 +102,108 @@ def test_instrument_registers_post_import_hooks(self): def test_uninstrument_unwraps_functions(self): """Test that uninstrumentation properly unwraps wrapped functions.""" + import mcp.client.stdio as client + import mcp.server.stdio as server + instrumentor = MCPInstrumentor() - - with patch("traceai_mcp.unwrap") as mock_unwrap: + originals = (client.stdio_client, server.stdio_server) + instrumentor._instrument() + try: + assert client.stdio_client is not originals[0] + assert server.stdio_server is not originals[1] + finally: instrumentor._uninstrument() - - # Verify specific functions are unwrapped - expected_calls = [ - call("mcp.client.stdio", "stdio_client"), - call("mcp.server.stdio", "stdio_server"), - ] - - mock_unwrap.assert_has_calls(expected_calls, any_order=True) + assert client.stdio_client is originals[0] + assert server.stdio_server is originals[1] def test_wrap_transport_with_callback(self): """Test _wrap_transport_with_callback async context manager.""" instrumentor = MCPInstrumentor() - + async def test_wrapper(): mock_read_stream = AsyncMock() mock_write_stream = AsyncMock() mock_callback = MagicMock() - + # Create a proper async context manager class class MockContextManager: async def __aenter__(self): return (mock_read_stream, mock_write_stream, mock_callback) - + async def __aexit__(self, exc_type, exc_val, exc_tb): return None - + # Create a mock wrapped function that returns the context manager def mock_wrapped(*args, **kwargs): return MockContextManager() - + async with instrumentor._wrap_transport_with_callback( mock_wrapped, None, (), {} ) as (reader, writer, callback): assert isinstance(reader, InstrumentedStreamReader) assert isinstance(writer, InstrumentedStreamWriter) assert callback == mock_callback - + # Verify the streams are properly wrapped with instrumented versions assert hasattr(reader, '_ObjectProxy__wrapped') assert hasattr(writer, '_ObjectProxy__wrapped') - + # Run the async test asyncio.run(test_wrapper()) def test_wrap_plain_transport(self): """Test _wrap_plain_transport async context manager.""" instrumentor = MCPInstrumentor() - + async def test_wrapper(): mock_read_stream = AsyncMock() mock_write_stream = AsyncMock() - + # Create a proper async context manager class class MockContextManager: async def __aenter__(self): return (mock_read_stream, mock_write_stream) - + async def __aexit__(self, exc_type, exc_val, exc_tb): return None - + # Create a mock wrapped function that returns the context manager def mock_wrapped(*args, **kwargs): return MockContextManager() - + async with instrumentor._wrap_plain_transport( mock_wrapped, None, (), {} ) as (reader, writer): assert isinstance(reader, InstrumentedStreamReader) assert isinstance(writer, InstrumentedStreamWriter) - + # Verify the streams are properly wrapped with instrumented versions assert hasattr(reader, '_ObjectProxy__wrapped') assert hasattr(writer, '_ObjectProxy__wrapped') - + # Run the async test asyncio.run(test_wrapper()) def test_base_session_init_wrapper(self): """Test _base_session_init_wrapper modifies session streams.""" instrumentor = MCPInstrumentor() - + # Mock the session instance mock_instance = MagicMock() mock_reader = MagicMock() mock_writer = MagicMock() mock_instance._incoming_message_stream_reader = mock_reader mock_instance._incoming_message_stream_writer = mock_writer - + # Mock the wrapped function mock_wrapped = MagicMock() - + # Call the wrapper instrumentor._base_session_init_wrapper(mock_wrapped, mock_instance, (), {}) - + # Verify the wrapped function was called mock_wrapped.assert_called_once_with() - + # Verify the streams were replaced with context-aware versions assert isinstance( mock_instance._incoming_message_stream_reader, @@ -209,21 +217,21 @@ def test_base_session_init_wrapper(self): def test_base_session_init_wrapper_missing_streams(self): """Test _base_session_init_wrapper when streams are missing.""" instrumentor = MCPInstrumentor() - + # Mock the session instance without streams mock_instance = MagicMock() mock_instance._incoming_message_stream_reader = None mock_instance._incoming_message_stream_writer = None - + # Mock the wrapped function mock_wrapped = MagicMock() - + # Call the wrapper - should not raise errors instrumentor._base_session_init_wrapper(mock_wrapped, mock_instance, (), {}) - + # Verify the wrapped function was called mock_wrapped.assert_called_once_with() - + # Verify streams remain None assert mock_instance._incoming_message_stream_reader is None assert mock_instance._incoming_message_stream_writer is None @@ -235,39 +243,39 @@ class TestInstrumentedStreamReader: def test_context_manager_support(self, mock_stream): """Test async context manager support.""" reader = InstrumentedStreamReader(mock_stream) - + async def test_context(): async with reader as stream: assert stream == mock_stream - + mock_stream.__aenter__.assert_called_once() mock_stream.__aexit__.assert_called_once() - + asyncio.run(test_context()) def test_async_iteration_without_jsonrpc(self, mock_stream): """Test async iteration with non-JSONRPCRequest messages.""" reader = InstrumentedStreamReader(mock_stream) - + # Mock message that's not a JSONRPCRequest mock_message = MagicMock() mock_message.message.root = MagicMock() mock_message.message.root.__class__.__name__ = "SomeOtherMessage" - + # Create an async iterator manually async def async_iter(): for item in [mock_message]: yield item - + # Mock the __aiter__ method directly mock_stream.__aiter__ = lambda self: async_iter() - + async def test_iteration(): items = [] async for item in reader: items.append(item) return items - + items = asyncio.run(test_iteration()) assert len(items) == 1 assert items[0] == mock_message @@ -279,14 +287,14 @@ class TestInstrumentedStreamWriter: def test_context_manager_support(self, mock_stream): """Test async context manager support.""" writer = InstrumentedStreamWriter(mock_stream) - + async def test_context(): async with writer as stream: assert stream == mock_stream - + mock_stream.__aenter__.assert_called_once() mock_stream.__aexit__.assert_called_once() - + asyncio.run(test_context()) @@ -296,39 +304,39 @@ class TestContextSavingStreamWriter: def test_context_manager_support(self, mock_stream): """Test async context manager support.""" writer = ContextSavingStreamWriter(mock_stream) - + async def test_context(): async with writer as stream: assert stream == mock_stream - + mock_stream.__aenter__.assert_called_once() mock_stream.__aexit__.assert_called_once() - + asyncio.run(test_context()) def test_send_saves_context(self, mock_stream): """Test that send saves current context with item.""" writer = ContextSavingStreamWriter(mock_stream) - + mock_item = MagicMock() - + async def test_send(): with patch("opentelemetry.context.get_current") as mock_get_context: mock_context = MagicMock() mock_get_context.return_value = mock_context - + await writer.send(mock_item) - + # Verify context was captured and sent with item mock_get_context.assert_called_once() - + # Check that send was called with ItemWithContext args, kwargs = mock_stream.send.call_args sent_item = args[0] assert isinstance(sent_item, ItemWithContext) assert sent_item.item == mock_item assert sent_item.ctx == mock_context - + asyncio.run(test_send()) @@ -338,14 +346,14 @@ class TestContextAttachingStreamReader: def test_context_manager_support(self, mock_stream): """Test async context manager support.""" reader = ContextAttachingStreamReader(mock_stream) - + async def test_context(): async with reader as stream: assert stream == mock_stream - + mock_stream.__aenter__.assert_called_once() mock_stream.__aexit__.assert_called_once() - + asyncio.run(test_context()) @@ -356,9 +364,9 @@ def test_item_with_context_creation(self): """Test ItemWithContext can be created and holds data.""" mock_item = MagicMock() mock_context = MagicMock() - + item_with_context = ItemWithContext(item=mock_item, ctx=mock_context) - + assert item_with_context.item == mock_item assert item_with_context.ctx == mock_context @@ -366,13 +374,13 @@ def test_item_with_context_immutable(self): """Test ItemWithContext is frozen (immutable).""" mock_item = MagicMock() mock_context = MagicMock() - + item_with_context = ItemWithContext(item=mock_item, ctx=mock_context) - + # Should not be able to modify frozen dataclass with pytest.raises(AttributeError): item_with_context.item = MagicMock() - + with pytest.raises(AttributeError): item_with_context.ctx = MagicMock() @@ -383,7 +391,7 @@ class TestErrorHandling: def test_instrumentation_with_missing_dependencies(self): """Test instrumentation behavior with missing dependencies.""" instrumentor = MCPInstrumentor() - + # Should not raise errors even if some components are missing try: deps = instrumentor.instrumentation_dependencies() @@ -398,33 +406,90 @@ class TestIntegrationScenarios: def test_full_instrumentation_lifecycle(self): """Test complete MCP instrumentation lifecycle.""" + import mcp.client.stdio as client + import mcp.server.stdio as server + instrumentor = MCPInstrumentor() - - with patch("traceai_mcp.register_post_import_hook") as mock_register: - with patch("traceai_mcp.unwrap") as mock_unwrap: - # Test instrumentation - instrumentor._instrument() - assert mock_register.call_count >= 7 # All transport hooks - - # Test uninstrumentation - instrumentor._uninstrument() - assert mock_unwrap.call_count >= 2 # Stdio client/server unwrapped + originals = (client.stdio_client, server.stdio_server) + for _ in range(2): + instrumentor._instrument() + assert client.stdio_client is not originals[0] + assert server.stdio_server is not originals[1] + instrumentor._uninstrument() + assert client.stdio_client is originals[0] + assert server.stdio_server is originals[1] def test_multiple_transport_support(self): """Test that multiple transport types are supported.""" instrumentor = MCPInstrumentor() - + # Test that all expected transports have wrappers transport_wrappers = { "streamable_http": instrumentor._wrap_transport_with_callback, "sse": instrumentor._wrap_plain_transport, "stdio": instrumentor._wrap_plain_transport, } - + for transport_name, wrapper in transport_wrappers.items(): assert callable(wrapper) assert hasattr(wrapper, "__call__") if __name__ == "__main__": - pytest.main([__file__, "-v"]) \ No newline at end of file + pytest.main([__file__, "-v"]) + +class TestMCPSdkV2Compat: + """Regression: mcp>=2.x renamed `streamablehttp_client` to + `streamable_http_client` and the client factory yields a 2-tuple + (no session-id callback). The instrumentor must handle both.""" + + def test_wrap_transport_with_callback_two_tuple(self): + """v2 client factory yields (read, write) — wrapper must not unpack 3.""" + instrumentor = MCPInstrumentor() + + async def test_wrapper(): + mock_read_stream = AsyncMock() + mock_write_stream = AsyncMock() + + class MockContextManager: + async def __aenter__(self): + return (mock_read_stream, mock_write_stream) + + async def __aexit__(self, exc_type, exc_val, exc_tb): + return None + + def mock_wrapped(*args, **kwargs): + return MockContextManager() + + async with instrumentor._wrap_transport_with_callback( + mock_wrapped, None, (), {} + ) as (reader, writer): + assert isinstance(reader, InstrumentedStreamReader) + assert isinstance(writer, InstrumentedStreamWriter) + + asyncio.run(test_wrapper()) + + def test_streamable_http_hook_wraps_v2_name(self): + """When only `streamable_http_client` exists (mcp>=2), the hook must + wrap that name — not the removed v1 `streamablehttp_client`.""" + instrumentor = MCPInstrumentor() + + captured = {} + + def capture_hook(fn, module_name): + captured[module_name] = fn + + fake_module = MagicMock() + fake_module.streamable_http_client = MagicMock() + del fake_module.streamablehttp_client # v2 has no legacy name + + with patch.object(instrumentor, "_pending_hooks", set(), create=True), patch("traceai_mcp.register_post_import_hook", capture_hook), patch( + "traceai_mcp.wrap_function_wrapper" + ) as mock_wrap: + instrumentor._instrument() + hook = captured["mcp.client.streamable_http"] + hook(fake_module) + + args, _kwargs = mock_wrap.call_args + assert args[0] is fake_module + assert args[1] == "streamable_http_client" From c05c72729374febc52530843b298d8b726863f2c Mon Sep 17 00:00:00 2001 From: Nikhil Pareek Date: Fri, 30 Oct 2026 21:17:41 -0700 Subject: [PATCH 2/2] fix(mcp): deduplicate delegated transport stream proxies Reuse same-owner reader and writer proxies when legacy HTTP aliases delegate. Cover both entry points, tuple arities, propagation counts, teardown, and foreign lifecycle ownership. Co-Authored-By: Claude Code --- python/frameworks/mcp/CHANGELOG.md | 2 +- .../mcp/tests/test_delegating_alias.py | 127 ++++++++++++++++++ python/frameworks/mcp/traceai_mcp/__init__.py | 20 ++- 3 files changed, 142 insertions(+), 7 deletions(-) create mode 100644 python/frameworks/mcp/tests/test_delegating_alias.py diff --git a/python/frameworks/mcp/CHANGELOG.md b/python/frameworks/mcp/CHANGELOG.md index d24ce7f13..fb06f9ce2 100644 --- a/python/frameworks/mcp/CHANGELOG.md +++ b/python/frameworks/mcp/CHANGELOG.md @@ -1,6 +1,6 @@ ## [0.1.3] - 2026-10-31 ### Fixed -- Support both streamable HTTP client names and the MCP SDK's two- and three-item transport tuples. +- Support both streamable HTTP client names and the MCP SDK's two- and three-item transport tuples; avoid duplicate propagation when legacy aliases delegate to the new entry point. - Disable propagation on existing streams during teardown, restore owned hooks without replacing other libraries' wrappers, and reactivate existing instrumented streams after reinstall. - Propagate context without mutating caller-owned messages or metadata, including null metadata; preserve original messages when there is no context to inject. - Keep queued server messages and native transport errors intact across instrumentation transitions. diff --git a/python/frameworks/mcp/tests/test_delegating_alias.py b/python/frameworks/mcp/tests/test_delegating_alias.py new file mode 100644 index 000000000..81b33dfbe --- /dev/null +++ b/python/frameworks/mcp/tests/test_delegating_alias.py @@ -0,0 +1,127 @@ +"""Transport aliases must share one propagation layer when they delegate.""" +import asyncio +from contextlib import asynccontextmanager +from types import ModuleType +from unittest.mock import patch + +import pytest +from mcp.shared.message import SessionMessage +from mcp.types import JSONRPCMessage, JSONRPCRequest +from opentelemetry import propagate, trace +from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags + +from traceai_mcp import ( + InstrumentedStreamReader, + InstrumentedStreamWriter, + MCPInstrumentor, +) + + +@pytest.mark.parametrize("arity", [2, 3]) +@pytest.mark.parametrize("entrypoint", ["streamable_http_client", "streamablehttp_client"]) +def test_delegating_alias_propagates_once(arity, entrypoint): + module = ModuleType("delegating_alias_fixture") + sent = [] + callback = lambda: "session-id" + + class Reader: + def __aiter__(self): + async def receive(): + yield sent[-1] + return receive() + + class Writer: + async def send(self, item): + sent.append(item) + + reader, writer = Reader(), Writer() + inner_streams = [] + exits = [] + + @asynccontextmanager + async def transport(): + try: + streams = (reader, writer) + yield streams if arity == 2 else (*streams, callback) + finally: + exits.append("transport") + + @asynccontextmanager + async def legacy_alias(): + async with module.streamable_http_client() as streams: + inner_streams.append(streams) + yield streams + + module.streamable_http_client = transport + module.streamablehttp_client = legacy_alias + instrumentor = MCPInstrumentor() + hooks = {} + + async def run(): + async with getattr(module, entrypoint)() as streams: + assert len(streams) == arity + if arity == 3: + assert streams[2] is callback + assert isinstance(streams[0], InstrumentedStreamReader) + assert isinstance(streams[1], InstrumentedStreamWriter) + assert streams[0].__wrapped__ is reader + assert streams[1].__wrapped__ is writer + if inner_streams: + assert streams[0] is inner_streams[0][0] + assert streams[1] is inner_streams[0][1] + request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping") + try: + message = JSONRPCMessage(root=request) + except TypeError: # MCP 2.x exposes a union type alias instead. + message = request + item = SessionMessage(message) + span = NonRecordingSpan(SpanContext(31, 32, False, TraceFlags(1))) + propagator = propagate.get_global_textmap() + with patch.object(propagator, "inject", wraps=propagator.inject) as inject: + with trace.use_span(span): + await streams[1].send(item) + inject.assert_called_once() + assert request.params is None + with patch("traceai_mcp.propagate.extract", wraps=propagate.extract) as extract: + iterator = streams[0].__aiter__() + try: + received = await iterator.__anext__() + assert received is sent[-1] + assert trace.get_current_span().get_span_context().trace_id == 31 + extract.assert_called_once() + finally: + await iterator.aclose() + assert not trace.get_current_span().get_span_context().is_valid + instrumentor._uninstrument() + await streams[1].send(item) + assert sent[-1] is item + + with patch.object(instrumentor, "_pending_hooks", set(), create=True), patch( + "traceai_mcp.register_post_import_hook", + side_effect=lambda fn, name: hooks.setdefault(name, fn), + ): + instrumentor._instrument() + hooks["mcp.client.streamable_http"](module) + try: + asyncio.run(run()) + finally: + instrumentor._uninstrument() + assert exits == ["transport"] + assert module.streamable_http_client is transport + assert module.streamablehttp_client is legacy_alias + + +def test_stream_deduplication_preserves_foreign_lifecycle_state(): + instrumentor = MCPInstrumentor() + own_state, foreign_state = object(), object() + with patch.object(instrumentor, "_stream_state", own_state, create=True): + for proxy_type in (InstrumentedStreamReader, InstrumentedStreamWriter): + native = object() + owned = proxy_type(native, own_state) + assert instrumentor._wrap_stream(owned, proxy_type) is owned + foreign = proxy_type(native, foreign_state) + wrapped = instrumentor._wrap_stream(foreign, proxy_type) + assert wrapped is not foreign + assert wrapped.__wrapped__ is foreign + assert wrapped._self_state is own_state + assert foreign._self_state is foreign_state diff --git a/python/frameworks/mcp/traceai_mcp/__init__.py b/python/frameworks/mcp/traceai_mcp/__init__.py index 3b8fddfe0..09bac6031 100644 --- a/python/frameworks/mcp/traceai_mcp/__init__.py +++ b/python/frameworks/mcp/traceai_mcp/__init__.py @@ -90,6 +90,13 @@ def _uninstrument(self, **kwargs: Any) -> None: setattr(owner, attr, original) self._wrapped_targets = [] + def _wrap_stream(self, stream: Any, proxy_type: type["_SwitchableProxy"]) -> Any: + # Legacy transport aliases may delegate to another wrapped entry point. + # Reuse only our own proxies; other owners keep their lifecycle state. + if isinstance(stream, proxy_type) and stream._self_state is self._stream_state: + return stream + return proxy_type(stream, self._stream_state) + @asynccontextmanager async def _wrap_transport_with_callback( self, wrapped: Callable[..., Any], instance: Any, args: Any, kwargs: Any @@ -100,15 +107,15 @@ async def _wrap_transport_with_callback( if len(streams) == 3: read_stream, write_stream, get_session_id_callback = streams yield ( - InstrumentedStreamReader(read_stream, self._stream_state), - InstrumentedStreamWriter(write_stream, self._stream_state), + self._wrap_stream(read_stream, InstrumentedStreamReader), + self._wrap_stream(write_stream, InstrumentedStreamWriter), get_session_id_callback, ) else: read_stream, write_stream = streams yield ( - InstrumentedStreamReader(read_stream, self._stream_state), - InstrumentedStreamWriter(write_stream, self._stream_state), + self._wrap_stream(read_stream, InstrumentedStreamReader), + self._wrap_stream(write_stream, InstrumentedStreamWriter), ) @asynccontextmanager @@ -118,8 +125,9 @@ async def _wrap_plain_transport( Tuple["InstrumentedStreamReader", "InstrumentedStreamWriter"], None ]: async with wrapped(*args, **kwargs) as (read_stream, write_stream): - yield InstrumentedStreamReader(read_stream, self._stream_state), InstrumentedStreamWriter( - write_stream, self._stream_state + yield ( + self._wrap_stream(read_stream, InstrumentedStreamReader), + self._wrap_stream(write_stream, InstrumentedStreamWriter), ) def _base_session_init_wrapper(