test: converge span capture on capfire to fix xdist order-dependence

The previous tests/server/conftest.py called trace.set_tracer_provider()
directly, which is set-once per process and raced against logfire's capfire
fixture (tests/shared/test_otel.py) under xdist — whichever ran first in a
worker won, the other's tests broke.

Converge on capfire as the single span-capture owner since logfire.configure()
already handles repeat calls by swapping span processors instead of re-setting
the provider:

- tests/conftest.py: set LOGFIRE_DISTRIBUTED_TRACING=true so propagation tests
  don't trip logfire's 'found propagated trace context' RuntimeWarning.
- tests/server/conftest.py: SpanCapture adapter over capfire.exporter — filters
  to the mcp-python-sdk instrumentation scope and excludes logfire's
  pending_span markers, so tests assert on raw ReadableSpan without importing
  logfire types.
- tests/shared/test_otel.py: drop the now-unneeded filterwarnings decorator.

Author: maxisbey

tests/conftest.py

@@ -1,5 +1,16 @@
+import os
+
 import pytest
 
+# OpenTelemetry's `set_tracer_provider` is set-once per process, so the suite
+# uses a single span-capture mechanism: logfire's `capfire` fixture (its
+# `configure()` swaps span processors on repeat calls rather than re-setting
+# the provider). Logfire's default `distributed_tracing=None` emits a
+# RuntimeWarning + diagnostic span when incoming W3C trace context is
+# extracted; several tests exercise that propagation deliberately, so opt in
+# suite-wide. Set before logfire is imported anywhere.
+os.environ.setdefault("LOGFIRE_DISTRIBUTED_TRACING", "true")
+
 
 @pytest.fixture
 def anyio_backend():

tests/server/conftest.py

@@ -3,32 +3,43 @@
 from collections.abc import Iterator
 
 import pytest
-from opentelemetry import trace
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from logfire.testing import CaptureLogfire, TestExporter
+from opentelemetry.sdk.trace import ReadableSpan
 
-_span_exporter = InMemorySpanExporter()
 
+class SpanCapture:
+    """Thin adapter over logfire's `TestExporter` for asserting on MCP spans.
 
-@pytest.fixture(scope="session")
-def _tracer_provider() -> TracerProvider:
-    """Install a real OTel SDK tracer provider once per test session.
-
-    The runtime dependency is ``opentelemetry-api`` only, which yields no-op
-    ``NonRecordingSpan`` objects. Tests that need to assert on emitted spans
-    request the `spans` fixture, which depends on this one to make the global
-    tracer record into an in-memory exporter.
+    `finished()` returns the raw `ReadableSpan` objects emitted by the
+    ``mcp-python-sdk`` instrumentation scope, filtered to exclude logfire's
+    synthetic ``pending_span`` markers, so tests can assert directly on
+    `.name`, `.kind`, `.status`, `.attributes`, `.parent`, `.events`.
     """
-    provider = TracerProvider()
-    provider.add_span_processor(SimpleSpanProcessor(_span_exporter))
-    trace.set_tracer_provider(provider)
-    return provider
+
+    def __init__(self, exporter: TestExporter) -> None:
+        self._exporter = exporter
+
+    def clear(self) -> None:
+        self._exporter.clear()
+
+    def finished(self) -> list[ReadableSpan]:
+        return [
+            s
+            for s in self._exporter.exported_spans
+            if s.instrumentation_scope is not None
+            and s.instrumentation_scope.name == "mcp-python-sdk"
+            and not (s.attributes and s.attributes.get("logfire.span_type") == "pending_span")
+        ]
 
 
 @pytest.fixture
-def spans(_tracer_provider: TracerProvider) -> Iterator[InMemorySpanExporter]:
-    """In-memory OTel span exporter, cleared before and after each test."""
-    _span_exporter.clear()
-    yield _span_exporter
-    _span_exporter.clear()
+def spans(capfire: CaptureLogfire) -> Iterator[SpanCapture]:
+    """In-memory MCP span capture, cleared before and after each test.
+
+    Backed by the project-level `capfire` override (see ``tests/conftest.py``)
+    so there is a single global tracer provider for the suite.
+    """
+    capture = SpanCapture(capfire.exporter)
+    capture.clear()
+    yield capture
+    capture.clear()

tests/server/test_runner.py

@@ -13,7 +13,6 @@
 import anyio
 import anyio.lowlevel
 import pytest
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
 from opentelemetry.trace import SpanKind, StatusCode
 
 from mcp.server.connection import Connection
@@ -36,6 +35,7 @@
 )
 
 from ..shared.test_dispatcher import Recorder, echo_handlers
+from .conftest import SpanCapture
 
 
 def _initialize_params() -> dict[str, Any]:
@@ -276,7 +276,7 @@ async def test_runner_stateless_skips_init_gate(server: SrvT):
 
 
 @pytest.mark.anyio
-async def test_otel_middleware_emits_server_span_with_method_and_target(server: SrvT, spans: InMemorySpanExporter):
+async def test_otel_middleware_emits_server_span_with_method_and_target(server: SrvT, spans: SpanCapture):
     async def call_tool(ctx: Any, params: Any) -> dict[str, Any]:
         return {"content": [], "isError": False}
 
@@ -285,7 +285,7 @@ async def call_tool(ctx: Any, params: Any) -> dict[str, Any]:
         spans.clear()
         result = await client.send_raw_request("tools/call", {"name": "mytool", "arguments": {}})
     assert result == {"content": [], "isError": False}
-    [span] = spans.get_finished_spans()
+    [span] = spans.finished()
     assert span.name == "MCP handle tools/call mytool"
     assert span.kind == SpanKind.SERVER
     assert span.attributes is not None
@@ -294,35 +294,35 @@ async def call_tool(ctx: Any, params: Any) -> dict[str, Any]:
 
 
 @pytest.mark.anyio
-async def test_otel_middleware_extracts_parent_context_from_meta(server: SrvT, spans: InMemorySpanExporter):
+async def test_otel_middleware_extracts_parent_context_from_meta(server: SrvT, spans: SpanCapture):
     parent_span_id = "b7ad6b7169203331"
     traceparent = f"00-0af7651916cd43dd8448eb211c80319c-{parent_span_id}-01"
     async with connected_runner(server, dispatch_middleware=[otel_middleware]) as (client, _):
         spans.clear()
         await client.send_raw_request("tools/list", {"_meta": {"traceparent": traceparent}})
-    [span] = spans.get_finished_spans()
+    [span] = spans.finished()
     assert span.parent is not None
     assert format(span.parent.span_id, "016x") == parent_span_id
     assert span.context is not None
     assert format(span.context.trace_id, "032x") == "0af7651916cd43dd8448eb211c80319c"
 
 
 @pytest.mark.anyio
-async def test_otel_middleware_records_error_status_on_mcp_error(server: SrvT, spans: InMemorySpanExporter):
+async def test_otel_middleware_records_error_status_on_mcp_error(server: SrvT, spans: SpanCapture):
     async with connected_runner(server, dispatch_middleware=[otel_middleware]) as (client, _):
         spans.clear()
         with pytest.raises(MCPError) as exc:
             await client.send_raw_request("nonexistent/method", None)
         assert exc.value.error.code == METHOD_NOT_FOUND
-    [span] = spans.get_finished_spans()
+    [span] = spans.finished()
     assert span.status.status_code == StatusCode.ERROR
     assert span.status.description == "Method not found: nonexistent/method"
     # MCPError is a protocol-level response, not a crash — no traceback event.
     assert not [e for e in span.events if e.name == "exception"]
 
 
 @pytest.mark.anyio
-async def test_otel_middleware_records_error_status_on_handler_exception(server: SrvT, spans: InMemorySpanExporter):
+async def test_otel_middleware_records_error_status_on_handler_exception(server: SrvT, spans: SpanCapture):
     async def failing(ctx: Any, params: Any) -> Any:
         raise ValueError("handler blew up")
 
@@ -332,7 +332,7 @@ async def failing(ctx: Any, params: Any) -> Any:
         with pytest.raises(MCPError) as exc:
             await client.send_raw_request("tools/list", None)
         assert exc.value.error.code == INTERNAL_ERROR
-    [span] = spans.get_finished_spans()
+    [span] = spans.finished()
     assert span.status.status_code == StatusCode.ERROR
     assert span.status.description == "handler blew up"
     [event] = [e for e in span.events if e.name == "exception"]

tests/shared/test_otel.py

@@ -10,9 +10,6 @@
 pytestmark = pytest.mark.anyio
 
 
-# Logfire warns about propagated trace context by default (distributed_tracing=None).
-# This is expected here since we're testing cross-boundary context propagation.
-@pytest.mark.filterwarnings("ignore::RuntimeWarning")
 async def test_client_and_server_spans(capfire: CaptureLogfire):
     """Verify that calling a tool produces client and server spans with correct attributes."""
     server = MCPServer("test")