Fix ObservabilityHostingManager.configure to accept MiddlewareSet instead of ChannelAdapter

ChannelAdapter is an ABC (CloudAdapter extends ChannelServiceAdapter extends
ChannelAdapter). The adapter HAS-A MiddlewareSet (composition) — it is not one.
The configure() method only needs the middleware registration object, so accept
MiddlewareSet directly. Users pass adapter.middleware_set.

Rename parameter from 'adapter' to 'middleware_set' for clarity.

Co-authored-by: nikhilNava <211831449+nikhilNava@users.noreply.github.com>

Author: Copilot

libraries/microsoft-agents-a365-observability-hosting/microsoft_agents_a365/observability/hosting/middleware/observability_hosting_manager.py

@@ -33,7 +33,7 @@ class ObservabilityHostingManager:
     Example:
         .. code-block:: python
 
-            ObservabilityHostingManager.configure(adapter, ObservabilityHostingOptions(
+            ObservabilityHostingManager.configure(adapter.middleware_set, ObservabilityHostingOptions(
                 enable_output_logging=True,
             ))
     """
@@ -46,25 +46,26 @@ def __init__(self) -> None:
     @classmethod
     def configure(
         cls,
-        adapter: MiddlewareSet,
+        middleware_set: MiddlewareSet,
         options: ObservabilityHostingOptions,
     ) -> ObservabilityHostingManager:
-        """Configure the singleton instance and register middleware on the adapter.
+        """Configure the singleton instance and register middleware.
 
         Subsequent calls after the first are no-ops and return the existing instance.
 
         Args:
-            adapter: The middleware set to register middleware on.
+            middleware_set: The middleware set to register middleware on
+                (e.g., ``adapter.middleware_set``).
             options: Configuration options controlling which middleware to enable.
 
         Returns:
             The singleton :class:`ObservabilityHostingManager` instance.
 
         Raises:
-            TypeError: If *adapter* or *options* is ``None``.
+            TypeError: If *middleware_set* or *options* is ``None``.
         """
-        if adapter is None:
-            raise TypeError("adapter must not be None")
+        if middleware_set is None:
+            raise TypeError("middleware_set must not be None")
         if options is None:
             raise TypeError("options must not be None")
 
@@ -78,11 +79,11 @@ def configure(
         instance = cls()
 
         if options.enable_baggage:
-            adapter.use(BaggageMiddleware())
+            middleware_set.use(BaggageMiddleware())
             logger.info("[ObservabilityHostingManager] BaggageMiddleware registered.")
 
         if options.enable_output_logging:
-            adapter.use(OutputLoggingMiddleware())
+            middleware_set.use(OutputLoggingMiddleware())
             logger.info("[ObservabilityHostingManager] OutputLoggingMiddleware registered.")
 
         logger.info(

tests/observability/hosting/middleware/test_observability_hosting_manager.py

@@ -26,71 +26,71 @@ def _reset_singleton():
 
 def test_configure_returns_instance():
     """configure() should return an ObservabilityHostingManager instance."""
-    adapter = MagicMock()
-    instance = ObservabilityHostingManager.configure(adapter, ObservabilityHostingOptions())
+    middleware_set = MagicMock()
+    instance = ObservabilityHostingManager.configure(middleware_set, ObservabilityHostingOptions())
     assert isinstance(instance, ObservabilityHostingManager)
 
 
 def test_configure_is_singleton():
     """Subsequent configure() calls should return the same instance."""
-    adapter = MagicMock()
+    middleware_set = MagicMock()
     options = ObservabilityHostingOptions()
-    first = ObservabilityHostingManager.configure(adapter, options)
-    second = ObservabilityHostingManager.configure(adapter, options)
+    first = ObservabilityHostingManager.configure(middleware_set, options)
+    second = ObservabilityHostingManager.configure(middleware_set, options)
     assert first is second
 
 
 def test_configure_registers_baggage_middleware_by_default():
     """By default, BaggageMiddleware should be registered."""
-    adapter = MagicMock()
-    ObservabilityHostingManager.configure(adapter, ObservabilityHostingOptions())
+    middleware_set = MagicMock()
+    ObservabilityHostingManager.configure(middleware_set, ObservabilityHostingOptions())
 
-    # The adapter.use should have been called once (only BaggageMiddleware by default)
-    assert adapter.use.call_count == 1
-    registered = adapter.use.call_args_list[0][0][0]
+    # The middleware_set.use should have been called once (only BaggageMiddleware by default)
+    assert middleware_set.use.call_count == 1
+    registered = middleware_set.use.call_args_list[0][0][0]
     assert isinstance(registered, BaggageMiddleware)
 
 
 def test_configure_registers_both_middlewares():
     """When output logging is enabled, both middlewares should be registered."""
-    adapter = MagicMock()
+    middleware_set = MagicMock()
     options = ObservabilityHostingOptions(enable_baggage=True, enable_output_logging=True)
-    ObservabilityHostingManager.configure(adapter, options)
+    ObservabilityHostingManager.configure(middleware_set, options)
 
-    assert adapter.use.call_count == 2
-    registered_types = [c[0][0] for c in adapter.use.call_args_list]
+    assert middleware_set.use.call_count == 2
+    registered_types = [c[0][0] for c in middleware_set.use.call_args_list]
     assert isinstance(registered_types[0], BaggageMiddleware)
     assert isinstance(registered_types[1], OutputLoggingMiddleware)
 
 
 def test_configure_disables_baggage():
     """When baggage is disabled, only output logging should be registered (if enabled)."""
-    adapter = MagicMock()
+    middleware_set = MagicMock()
     options = ObservabilityHostingOptions(enable_baggage=False, enable_output_logging=True)
-    ObservabilityHostingManager.configure(adapter, options)
+    ObservabilityHostingManager.configure(middleware_set, options)
 
-    assert adapter.use.call_count == 1
-    registered = adapter.use.call_args_list[0][0][0]
+    assert middleware_set.use.call_count == 1
+    registered = middleware_set.use.call_args_list[0][0][0]
     assert isinstance(registered, OutputLoggingMiddleware)
 
 
 def test_configure_disables_all():
     """When both are disabled, no middleware should be registered."""
-    adapter = MagicMock()
+    middleware_set = MagicMock()
     options = ObservabilityHostingOptions(enable_baggage=False, enable_output_logging=False)
-    ObservabilityHostingManager.configure(adapter, options)
+    ObservabilityHostingManager.configure(middleware_set, options)
 
-    adapter.use.assert_not_called()
+    middleware_set.use.assert_not_called()
 
 
-def test_configure_raises_on_none_adapter():
-    """configure() should raise TypeError when adapter is None."""
-    with pytest.raises(TypeError, match="adapter must not be None"):
+def test_configure_raises_on_none_middleware_set():
+    """configure() should raise TypeError when middleware_set is None."""
+    with pytest.raises(TypeError, match="middleware_set must not be None"):
         ObservabilityHostingManager.configure(None, ObservabilityHostingOptions())
 
 
 def test_configure_raises_on_none_options():
     """configure() should raise TypeError when options is None."""
-    adapter = MagicMock()
+    middleware_set = MagicMock()
     with pytest.raises(TypeError, match="options must not be None"):
-        ObservabilityHostingManager.configure(adapter, None)
+        ObservabilityHostingManager.configure(middleware_set, None)