test: ServerRunner coverage to 100% — otel span assertions + connected_runner harness

- Add opentelemetry-sdk as a dev dep and a tests/server/conftest.py 'spans'
  fixture (TracerProvider + InMemorySpanExporter) so otel_middleware's span
  contract is observable.
- Replace the otel pass-through test with four span-asserting tests (name +
  target, _meta traceparent → parent, MCPError → ERROR status without
  traceback, unexpected exception → ERROR status + exception event). These
  surfaced that start_as_current_span's default set_status_on_exception /
  record_exception was overwriting the middleware's explicit set_status and
  attaching tracebacks to protocol-level MCPErrors — now disabled and handled
  explicitly.
- Add handler-return contract tests (None → {}, unsupported → INTERNAL_ERROR).
- Introduce connected_runner async-contextmanager test harness and retrofit all
  tests through runner.run(); drop two tests made redundant by that. Harness
  closes dispatchers gracefully and re-raises body exceptions outside the task
  group so failures aren't ExceptionGroup-wrapped (and to avoid a coverage.py
  trace-loss false-negative on cancel-during-aexit).
- Remove the unused Server.connection_lifespan placeholder; it lands with its
  consumer.

Author: maxisbey

pyproject.toml

@@ -73,6 +73,7 @@ dev = [
     "pillow>=12.0",
     "strict-no-cover",
     "logfire>=3.0.0",
+    "opentelemetry-sdk>=1.39.1",
 ]
 docs = [
     "mkdocs>=1.6.1",

src/mcp/server/lowlevel/server.py

@@ -259,11 +259,6 @@ def get_notification_handler(self, method: str) -> Callable[..., Awaitable[Any]]
         """Return the handler for a notification method, or ``None``."""
         return self._notification_handlers.get(method)
 
-    @property
-    def connection_lifespan(self) -> None:
-        """Per-connection lifespan. ``None`` until the registry refactor adds it."""
-        return None
-
     # TODO: Rethink capabilities API. Currently capabilities are derived from registered
     # handlers but require NotificationOptions to be passed externally for list_changed
     # flags, and experimental_capabilities as a separate dict. Consider deriving capabilities

src/mcp/server/runner.py

@@ -145,13 +145,21 @@ async def wrapped(
             case _:
                 parent = None
         span_name = f"MCP handle {method}{f' {target}' if target else ''}"
-        with otel_span(span_name, kind=SpanKind.SERVER, attributes={"mcp.method.name": method}, context=parent) as span:
+        with otel_span(
+            span_name,
+            kind=SpanKind.SERVER,
+            attributes={"mcp.method.name": method},
+            context=parent,
+            record_exception=False,
+            set_status_on_exception=False,
+        ) as span:
             try:
                 return await next_on_request(dctx, method, params)
             except MCPError as e:
                 span.set_status(StatusCode.ERROR, e.error.message)
                 raise
             except Exception as e:
+                span.record_exception(e)
                 span.set_status(StatusCode.ERROR, str(e))
                 raise
 

src/mcp/shared/_otel.py

@@ -20,9 +20,18 @@ def otel_span(
     kind: SpanKind,
     attributes: dict[str, Any] | None = None,
     context: Context | None = None,
+    record_exception: bool = True,
+    set_status_on_exception: bool = True,
 ) -> Iterator[Any]:
     """Create an OTel span."""
-    with _tracer.start_as_current_span(name, kind=kind, attributes=attributes, context=context) as span:
+    with _tracer.start_as_current_span(
+        name,
+        kind=kind,
+        attributes=attributes,
+        context=context,
+        record_exception=record_exception,
+        set_status_on_exception=set_status_on_exception,
+    ) as span:
         yield span
 
 

tests/server/conftest.py

@@ -0,0 +1,34 @@
+"""Shared fixtures for server-side tests."""
+
+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
+
+_span_exporter = InMemorySpanExporter()
+
+
+@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.
+    """
+    provider = TracerProvider()
+    provider.add_span_processor(SimpleSpanProcessor(_span_exporter))
+    trace.set_tracer_provider(provider)
+    return provider
+
+
+@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()