fix check failures

Author: lukeina2z

instrumentation-genai/opentelemetry-instrumentation-mcp/examples/simple-client-server/client/main.py

@@ -2,6 +2,7 @@
 
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
+from pydantic import AnyUrl
 
 from opentelemetry import trace
 
@@ -38,7 +39,7 @@ async def run():
 
                 # Read a resource
                 print("READING RESOURCE")
-                _ = await session.read_resource("greeting://hello")
+                _ = await session.read_resource(AnyUrl("greeting://hello"))
 
                 # Call pingweb tool
                 print("CALL PINGWEB TOOL")

instrumentation-genai/opentelemetry-instrumentation-mcp/examples/simple-client-server/server/mcp_simple_tool/__main__.py

@@ -2,4 +2,4 @@
 
 from .server import main
 
-sys.exit(main())  # type: ignore[call-arg]
+sys.exit(main())

instrumentation-genai/opentelemetry-instrumentation-mcp/examples/simple-client-server/server/mcp_simple_tool/server.py

@@ -13,26 +13,26 @@ def call_http() -> str:
 mcp = FastMCP("PythonMcpDemoFoo")
 
 
-@mcp.tool()
+@mcp.tool()  # type: ignore[misc]
 def add(a: int, b: int) -> int:
     """Add two numbers"""
     return a + b
 
 
-@mcp.tool()
+@mcp.tool()  # type: ignore[misc]
 def subtract(a: int, b: int) -> int:
     """Subtract two numbers"""
     return a - b
 
 
-@mcp.tool()
+@mcp.tool()  # type: ignore[misc]
 def pingweb() -> str:
     """Ping a web URL and return status"""
     return call_http()
 
 
 # Add a dynamic greeting resource
-@mcp.resource("greeting://{name}")
+@mcp.resource("greeting://{name}")  # type: ignore[misc]
 def get_greeting(name: str) -> str:
     """Get a personalized greeting"""
     return f"Hello, {name}!"

instrumentation-genai/opentelemetry-instrumentation-mcp/src/opentelemetry/instrumentation/mcp/instrumentation.py

@@ -18,7 +18,7 @@
 import logging
 from typing import Any, Callable, Collection, Coroutine, Dict, Optional, Tuple
 
-from wrapt import register_post_import_hook
+from wrapt import register_post_import_hook  # type: ignore[import-untyped]
 
 from opentelemetry import trace
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
@@ -108,23 +108,25 @@ def _uninstrument(self, **kwargs: Any) -> None:
         unwrap(self._SERVER_MODULE, "Server._handle_notification")
 
     @staticmethod
-    def _register_hook(module: str, target: str, wrapper: Callable) -> None:
+    def _register_hook(
+        module: str, target: str, wrapper: Callable[..., Any]
+    ) -> None:
         """Register a post-import hook for wrapping a function."""
         # pylint: disable=import-outside-toplevel
-        from wrapt import wrap_function_wrapper
+        from wrapt import wrap_function_wrapper  # type: ignore[import-untyped]
 
-        register_post_import_hook(
-            lambda _: wrap_function_wrapper(module, target, wrapper),
-            module,
-        )
+        def hook(_module: Any) -> None:
+            wrap_function_wrapper(module, target, wrapper)
+
+        register_post_import_hook(hook, module)
 
     def _wrap_session_send(
         self,
-        wrapped: Callable,
+        wrapped: Callable[..., Coroutine[Any, Any, Any]],
         instance: Any,
         args: Tuple[Any, ...],
         kwargs: Dict[str, Any],
-    ) -> Coroutine:
+    ) -> Coroutine[Any, Any, Any]:
         """
         Wrap BaseSession.send_request and send_notification methods.
 
@@ -174,7 +176,7 @@ async def async_wrapper() -> Any:
             ) as span:
                 # Inject trace context
                 ctx = trace.set_span_in_context(span)
-                carrier = {}
+                carrier: Dict[str, Any] = {}
                 self.propagators.inject(carrier=carrier, context=ctx)
                 message_json["params"]["_meta"].update(carrier)
 
@@ -201,7 +203,7 @@ async def async_wrapper() -> Any:
 
     async def _wrap_server_handle_request(
         self,
-        wrapped: Callable,
+        wrapped: Callable[..., Coroutine[Any, Any, Any]],
         instance: Any,
         args: Tuple[Any, ...],
         kwargs: Dict[str, Any],
@@ -223,7 +225,7 @@ async def _wrap_server_handle_request(
 
     async def _wrap_server_handle_notification(
         self,
-        wrapped: Callable,
+        wrapped: Callable[..., Coroutine[Any, Any, Any]],
         instance: Any,
         args: Tuple[Any, ...],
         kwargs: Dict[str, Any],
@@ -245,7 +247,7 @@ async def _wrap_server_handle_notification(
 
     async def _wrap_server_message_handler(
         self,
-        wrapped: Callable,
+        wrapped: Callable[..., Coroutine[Any, Any, Any]],
         instance: Any,
         args: Tuple[Any, ...],
         kwargs: Dict[str, Any],

instrumentation-genai/opentelemetry-instrumentation-mcp/src/opentelemetry/instrumentation/mcp/py.typed

@@ -24,14 +24,14 @@
 class TestMcpInstrumentorInit(unittest.TestCase):
     """Test McpInstrumentor initialization."""
 
-    def test_init_default(self):
+    def test_init_default(self) -> None:
         """Test default initialization."""
         instrumentor = McpInstrumentor()
         self.assertIsNotNone(instrumentor)
         self.assertIsNotNone(instrumentor.tracer)
         self.assertIsNotNone(instrumentor.propagators)
 
-    def test_init_with_tracer_provider(self):
+    def test_init_with_tracer_provider(self) -> None:
         """Test initialization with custom tracer provider."""
         mock_provider = MagicMock(spec=TracerProvider)
         mock_tracer = MagicMock()
@@ -42,7 +42,7 @@ def test_init_with_tracer_provider(self):
             instrumentor = McpInstrumentor(tracer_provider=mock_provider)
             self.assertIsNotNone(instrumentor.tracer)
 
-    def test_init_with_propagators(self):
+    def test_init_with_propagators(self) -> None:
         """Test initialization with custom propagators."""
         mock_propagators = MagicMock()
         instrumentor = McpInstrumentor(propagators=mock_propagators)
@@ -52,7 +52,7 @@ def test_init_with_propagators(self):
 class TestMcpInstrumentorDependencies(unittest.TestCase):
     """Test instrumentation dependencies."""
 
-    def test_instrumentation_dependencies(self):
+    def test_instrumentation_dependencies(self) -> None:
         """Test that instrumentation_dependencies returns correct packages."""
         instrumentor = McpInstrumentor()
         deps = instrumentor.instrumentation_dependencies()
@@ -70,15 +70,17 @@ def setUp(self):
     @patch(
         "opentelemetry.instrumentation.mcp.instrumentation.register_post_import_hook"
     )
-    def test_instrument_registers_hooks(self, mock_register):
+    def test_instrument_registers_hooks(self, mock_register: MagicMock):
         """Test that _instrument registers all required hooks."""
         self.instrumentor._instrument()
         self.assertEqual(mock_register.call_count, 4)
 
     @patch(
         "opentelemetry.instrumentation.mcp.instrumentation.register_post_import_hook"
     )
-    def test_instrument_registers_session_hooks(self, mock_register):
+    def test_instrument_registers_session_hooks(
+        self, mock_register: MagicMock
+    ):
         """Test that _instrument registers session hooks."""
         self.instrumentor._instrument()
         # Verify mcp.shared.session is registered (appears twice for send_request and send_notification)
@@ -92,7 +94,7 @@ def test_instrument_registers_session_hooks(self, mock_register):
     @patch(
         "opentelemetry.instrumentation.mcp.instrumentation.register_post_import_hook"
     )
-    def test_instrument_registers_server_hooks(self, mock_register):
+    def test_instrument_registers_server_hooks(self, mock_register: MagicMock):
         """Test that _instrument registers server hooks."""
         self.instrumentor._instrument()
         # Verify mcp.server.lowlevel.server is registered (appears twice for _handle_request and _handle_notification)
@@ -111,37 +113,41 @@ def setUp(self):
         self.instrumentor = McpInstrumentor()
 
     @patch("opentelemetry.instrumentation.mcp.instrumentation.unwrap")
-    def test_uninstrument_unwraps_all(self, mock_unwrap):
+    def test_uninstrument_unwraps_all(self, mock_unwrap: MagicMock):
         """Test that _uninstrument unwraps all hooks."""
         self.instrumentor._uninstrument()
         self.assertEqual(mock_unwrap.call_count, 4)
 
     @patch("opentelemetry.instrumentation.mcp.instrumentation.unwrap")
-    def test_uninstrument_unwraps_send_request(self, mock_unwrap):
+    def test_uninstrument_unwraps_send_request(self, mock_unwrap: MagicMock):
         """Test that _uninstrument unwraps send_request."""
         self.instrumentor._uninstrument()
         mock_unwrap.assert_any_call(
             "mcp.shared.session", "BaseSession.send_request"
         )
 
     @patch("opentelemetry.instrumentation.mcp.instrumentation.unwrap")
-    def test_uninstrument_unwraps_send_notification(self, mock_unwrap):
+    def test_uninstrument_unwraps_send_notification(
+        self, mock_unwrap: MagicMock
+    ):
         """Test that _uninstrument unwraps send_notification."""
         self.instrumentor._uninstrument()
         mock_unwrap.assert_any_call(
             "mcp.shared.session", "BaseSession.send_notification"
         )
 
     @patch("opentelemetry.instrumentation.mcp.instrumentation.unwrap")
-    def test_uninstrument_unwraps_handle_request(self, mock_unwrap):
+    def test_uninstrument_unwraps_handle_request(self, mock_unwrap: MagicMock):
         """Test that _uninstrument unwraps handle_request."""
         self.instrumentor._uninstrument()
         mock_unwrap.assert_any_call(
             "mcp.server.lowlevel.server", "Server._handle_request"
         )
 
     @patch("opentelemetry.instrumentation.mcp.instrumentation.unwrap")
-    def test_uninstrument_unwraps_handle_notification(self, mock_unwrap):
+    def test_uninstrument_unwraps_handle_notification(
+        self, mock_unwrap: MagicMock
+    ):
         """Test that _uninstrument unwraps handle_notification."""
         self.instrumentor._uninstrument()
         mock_unwrap.assert_any_call(
@@ -152,33 +158,33 @@ def test_uninstrument_unwraps_handle_notification(self, mock_unwrap):
 class TestMcpInstrumentorSerialize(unittest.TestCase):
     """Test serialize static method."""
 
-    def test_serialize_simple_dict(self):
+    def test_serialize_simple_dict(self) -> None:
         """Test serializing a simple dictionary."""
         result = McpInstrumentor.serialize({"key": "value"})
         self.assertEqual(result, '{"key": "value"}')
 
-    def test_serialize_nested_dict(self):
+    def test_serialize_nested_dict(self) -> None:
         """Test serializing a nested dictionary."""
         result = McpInstrumentor.serialize({"outer": {"inner": "value"}})
         self.assertEqual(result, '{"outer": {"inner": "value"}}')
 
-    def test_serialize_with_numbers(self):
+    def test_serialize_with_numbers(self) -> None:
         """Test serializing dictionary with numbers."""
         result = McpInstrumentor.serialize({"int": 42, "float": 3.14})
         self.assertIn('"int": 42', result)
         self.assertIn('"float": 3.14', result)
 
-    def test_serialize_with_list(self):
+    def test_serialize_with_list(self) -> None:
         """Test serializing dictionary with list."""
         result = McpInstrumentor.serialize({"list": [1, 2, 3]})
         self.assertEqual(result, '{"list": [1, 2, 3]}')
 
-    def test_serialize_empty_dict(self):
+    def test_serialize_empty_dict(self) -> None:
         """Test serializing empty dictionary."""
         result = McpInstrumentor.serialize({})
         self.assertEqual(result, "{}")
 
-    def test_serialize_non_serializable(self):
+    def test_serialize_non_serializable(self) -> None:
         """Test serializing non-serializable object returns empty string."""
 
         class NonSerializable:
@@ -187,12 +193,12 @@ class NonSerializable:
         result = McpInstrumentor.serialize({"obj": NonSerializable()})
         self.assertEqual(result, "")
 
-    def test_serialize_with_none(self):
+    def test_serialize_with_none(self) -> None:
         """Test serializing dictionary with None value."""
         result = McpInstrumentor.serialize({"key": None})
         self.assertEqual(result, '{"key": null}')
 
-    def test_serialize_with_boolean(self):
+    def test_serialize_with_boolean(self) -> None:
         """Test serializing dictionary with boolean values."""
         result = McpInstrumentor.serialize({"true": True, "false": False})
         self.assertIn('"true": true', result)