microsoft-agents-hosting-core 0.9.0.dev6__tar.gz → 0.9.0.dev8__tar.gz

{microsoft_agents_hosting_core-0.9.0.dev6 → microsoft_agents_hosting_core-0.9.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microsoft-agents-hosting-core
-Version: 0.9.0.dev6
+Version: 0.9.0.dev8
 Summary: Core library for Microsoft Agents
 Author: Microsoft Corporation
 License-Expression: MIT
@@ -15,11 +15,13 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: microsoft-agents-activity==0.9.0.dev6
+Requires-Dist: microsoft-agents-activity==0.9.0.dev8
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: isodate>=0.6.1
 Requires-Dist: azure-core>=1.30.0
 Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: opentelemetry-api>=1.27.0
+Requires-Dist: opentelemetry-sdk>=1.27.0
 Dynamic: license-file
 Dynamic: requires-dist
 

microsoft_agents_hosting_core-0.9.0.dev8/VERSION.txt

@@ -0,0 +1 @@
+0.9.0.dev8

{microsoft_agents_hosting_core-0.9.0.dev6 → microsoft_agents_hosting_core-0.9.0.dev8}/microsoft_agents/hosting/core/app/agent_application.py

@@ -30,7 +30,8 @@ from microsoft_agents.activity import (
     InvokeResponse,
 )
 
-from ..turn_context import TurnContext
+from microsoft_agents.hosting.core.turn_context import TurnContext
+
 from ..agent import Agent
 from ..authorization import Connections
 from .app_error import ApplicationError
@@ -40,6 +41,7 @@ from .state import TurnState
 from ..channel_service_adapter import ChannelServiceAdapter
 from .oauth import Authorization
 from .typing_indicator import TypingIndicator
+from .telemetry import spans
 
 from ._type_defs import RouteHandler, RouteSelector
 from ._routes import _RouteList, _Route, RouteRank, _agentic_selector
@@ -669,50 +671,51 @@ class AgentApplication(Agent, Generic[StateT]):
     async def _on_turn(self, context: TurnContext):
         typing = None
         try:
-            if context.activity.type != ActivityTypes.typing:
-                if self._options.start_typing_timer:
-                    typing = TypingIndicator(context)
-                    typing.start()
+            with spans.AppOnTurn(context) as on_turn_span:
+                if context.activity.type != ActivityTypes.typing:
+                    if self._options.start_typing_timer:
+                        typing = TypingIndicator(context)
+                        typing.start()
 
-            self._remove_mentions(context)
+                self._remove_mentions(context)
 
-            logger.debug("Initializing turn state")
-            turn_state = await self._initialize_state(context)
-            if (
-                context.activity.type == ActivityTypes.message
-                or context.activity.type == ActivityTypes.invoke
-            ):
+                logger.debug("Initializing turn state")
+                turn_state = await self._initialize_state(context)
+                if (
+                    context.activity.type == ActivityTypes.message
+                    or context.activity.type == ActivityTypes.invoke
+                ):
 
-                (
-                    auth_intercepts,
-                    continuation_activity,
-                ) = await self._auth._on_turn_auth_intercept(context, turn_state)
-                if auth_intercepts:
-                    if continuation_activity:
-                        new_context = copy(context)
-                        new_context.activity = continuation_activity
-                        logger.info(
-                            "Resending continuation activity %s",
-                            continuation_activity.text,
-                        )
-                        await self.on_turn(new_context)
-                        await turn_state.save(context)
-                    return
+                    (
+                        auth_intercepts,
+                        continuation_activity,
+                    ) = await self._auth._on_turn_auth_intercept(context, turn_state)
+                    if auth_intercepts:
+                        if continuation_activity:
+                            new_context = copy(context)
+                            new_context.activity = continuation_activity
+                            logger.info(
+                                "Resending continuation activity %s",
+                                continuation_activity.text,
+                            )
+                            await self.on_turn(new_context)
+                            await turn_state.save(context)
+                        return
 
-            logger.debug("Running before turn middleware")
-            if not await self._run_before_turn_middleware(context, turn_state):
-                return
+                logger.debug("Running before turn middleware")
+                if not await self._run_before_turn_middleware(context, turn_state):
+                    return
 
-            logger.debug("Running file downloads")
-            await self._handle_file_downloads(context, turn_state)
+                logger.debug("Running file downloads")
+                await self._handle_file_downloads(context, turn_state)
 
-            logger.debug("Running activity handlers")
-            await self._on_activity(context, turn_state)
+                logger.debug("Running activity handlers")
+                await self._on_activity(context, turn_state, on_turn_span)
 
-            logger.debug("Running after turn middleware")
-            if await self._run_after_turn_middleware(context, turn_state):
-                await turn_state.save(context)
-            return
+                logger.debug("Running after turn middleware")
+                if await self._run_after_turn_middleware(context, turn_state):
+                    await turn_state.save(context)
+                return
         except ApplicationError as err:
             logger.error(
                 f"An application error occurred in the AgentApplication: {err}",
@@ -777,23 +780,28 @@ class AgentApplication(Agent, Generic[StateT]):
         return turn_state
 
     async def _run_before_turn_middleware(self, context: TurnContext, state: StateT):
-        for before_turn in self._internal_before_turn:
-            is_ok = await before_turn(context, state)
-            if not is_ok:
-                await state.save(context)
-                return False
-        return True
+        with spans.AppBeforeTurn():
+            for before_turn in self._internal_before_turn:
+                is_ok = await before_turn(context, state)
+                if not is_ok:
+                    await state.save(context)
+                    return False
+            return True
 
     async def _handle_file_downloads(self, context: TurnContext, state: StateT):
-        if self._options.file_downloaders and len(self._options.file_downloaders) > 0:
-            input_files = state.temp.input_files if state.temp.input_files else []
-            for file_downloader in self._options.file_downloaders:
-                logger.info(
-                    f"Using file downloader: {file_downloader.__class__.__name__}"
-                )
-                files = await file_downloader.download_files(context)
-                input_files.extend(files)
-            state.temp.input_files = input_files
+        with spans.AppDownloadFiles(context):
+            if (
+                self._options.file_downloaders
+                and len(self._options.file_downloaders) > 0
+            ):
+                input_files = state.temp.input_files if state.temp.input_files else []
+                for file_downloader in self._options.file_downloaders:
+                    logger.info(
+                        f"Using file downloader: {file_downloader.__class__.__name__}"
+                    )
+                    files = await file_downloader.download_files(context)
+                    input_files.extend(files)
+                state.temp.input_files = input_files
 
     def _contains_non_text_attachments(self, context: TurnContext):
         non_text_attachments = filter(
@@ -803,18 +811,31 @@ class AgentApplication(Agent, Generic[StateT]):
         return len(list(non_text_attachments)) > 0
 
     async def _run_after_turn_middleware(self, context: TurnContext, state: StateT):
-        for after_turn in self._internal_after_turn:
-            is_ok = await after_turn(context, state)
-            if not is_ok:
-                await state.save(context)
-                return False
-        return True
+        with spans.AppAfterTurn():
+            for after_turn in self._internal_after_turn:
+                is_ok = await after_turn(context, state)
+                if not is_ok:
+                    await state.save(context)
+                    return False
+            return True
+
+    async def _on_activity(
+        self,
+        context: TurnContext,
+        state: StateT,
+        on_turn_span: spans.AppOnTurn | None = None,
+    ):
+
+        route_matched: bool = False
+        route_authorized: bool = False
 
-    async def _on_activity(self, context: TurnContext, state: StateT):
         for route in self._route_list:
             if route.selector(context):
+                route_matched = True
                 if not route.auth_handlers:
-                    await route.handler(context, state)
+                    route_authorized = True
+                    with spans.AppRouteHandler(route.is_invoke, route.is_agentic):
+                        await route.handler(context, state)
                 else:
                     sign_in_complete = True
                     for auth_handler_id in route.auth_handlers:
@@ -827,11 +848,19 @@ class AgentApplication(Agent, Generic[StateT]):
                             break
 
                     if sign_in_complete:
-                        await route.handler(context, state)
-                return
-        logger.warning(
-            f"No route found for activity type: {context.activity.type} with text: {context.activity.text}"
-        )
+                        route_authorized = True
+                        with spans.AppRouteHandler(route.is_invoke, route.is_agentic):
+                            await route.handler(context, state)
+                break
+
+        if not route_matched:
+            logger.warning(
+                f"No route found for activity type: {context.activity.type} with text: {context.activity.text}"
+            )
+        if on_turn_span is not None:
+            on_turn_span.share(
+                route_authorized=route_authorized, route_matched=route_matched
+            )
 
     async def _start_long_running_call(
         self, context: TurnContext, func: Callable[[TurnContext], Awaitable]

{microsoft_agents_hosting_core-0.9.0.dev6 → microsoft_agents_hosting_core-0.9.0.dev8}/microsoft_agents/hosting/core/app/oauth/_handlers/_user_authorization.py

@@ -29,6 +29,7 @@ from microsoft_agents.hosting.core._oauth import (
 )
 from .._sign_in_response import _SignInResponse
 from ._authorization_handler import _AuthorizationHandler
+from ..telemetry import spans
 
 logger = logging.getLogger(__name__)
 
@@ -119,21 +120,26 @@ class _UserAuthorization(_AuthorizationHandler):
         connection_name = exchange_connection or self._handler.obo_connection_name
         exchange_scopes = exchange_scopes or self._handler.scopes
 
-        if not connection_name or not exchange_scopes:
-            return input_token_response
+        with spans.AzureBotToken(
+            auth_handler_id=self._id,
+            connection_name=connection_name,
+            scopes=exchange_scopes,
+        ):
+            if not connection_name or not exchange_scopes:
+                return input_token_response
 
-        if not input_token_response.is_exchangeable():
-            return input_token_response
+            if not input_token_response.is_exchangeable():
+                return input_token_response
 
-        token_provider = self._connection_manager.get_connection(connection_name)
-        if not token_provider:
-            raise ValueError(f"Connection '{connection_name}' not found")
+            token_provider = self._connection_manager.get_connection(connection_name)
+            if not token_provider:
+                raise ValueError(f"Connection '{connection_name}' not found")
 
-        token = await token_provider.acquire_token_on_behalf_of(
-            scopes=exchange_scopes,
-            user_assertion=input_token_response.token,
-        )
-        return TokenResponse(token=token) if token else TokenResponse()
+            token = await token_provider.acquire_token_on_behalf_of(
+                scopes=exchange_scopes,
+                user_assertion=input_token_response.token,
+            )
+            return TokenResponse(token=token) if token else TokenResponse()
 
     async def _sign_out(
         self,
@@ -147,10 +153,11 @@ class _UserAuthorization(_AuthorizationHandler):
         :param auth_handler_id: Optional ID of the auth handler to use for sign out. If None,
             signs out from all the handlers.
         """
-        flow, flow_storage_client = await self._load_flow(context)
-        logger.info("Signing out from handler: %s", self._id)
-        await flow.sign_out()
-        await flow_storage_client.delete(self._id)
+        with spans.AzureBotSignOut(auth_handler_id=self._id):
+            flow, flow_storage_client = await self._load_flow(context)
+            logger.info("Signing out from handler: %s", self._id)
+            await flow.sign_out()
+            await flow_storage_client.delete(self._id)
 
     async def _handle_flow_response(
         self, context: TurnContext, flow_response: _FlowResponse
@@ -212,31 +219,40 @@ class _UserAuthorization(_AuthorizationHandler):
         :return: The _SignInResponse containing the token response and flow state tag.
         :rtype: _SignInResponse
         """
-        flow, flow_storage_client = await self._load_flow(context)
-        flow_response: _FlowResponse = await flow.begin_or_continue_flow(
-            context.activity
-        )
-
-        logger.info("Saving OAuth flow state to storage")
-        await flow_storage_client.write(flow_response.flow_state)
-        await self._handle_flow_response(context, flow_response)
-
-        if flow_response.token_response:
-            # attempt exchange if needed
-            # if not needed, returns the same token
-            token_response = await self._handle_obo(
-                context,
-                flow_response.token_response,
-                exchange_connection,
-                exchange_scopes,
+        with spans.AzureBotSignIn(
+            auth_handler_id=self._id,
+            connection_name=exchange_connection,
+            scopes=exchange_scopes,
+        ):
+            flow, flow_storage_client = await self._load_flow(context)
+            flow_response: _FlowResponse = await flow.begin_or_continue_flow(
+                context.activity
             )
 
-            return _SignInResponse(
-                token_response=token_response,
-                tag=_FlowStateTag.COMPLETE if token_response else _FlowStateTag.FAILURE,
-            )
+            logger.info("Saving OAuth flow state to storage")
+            await flow_storage_client.write(flow_response.flow_state)
+            await self._handle_flow_response(context, flow_response)
+
+            if flow_response.token_response:
+                # attempt exchange if needed
+                # if not needed, returns the same token
+                token_response = await self._handle_obo(
+                    context,
+                    flow_response.token_response,
+                    exchange_connection,
+                    exchange_scopes,
+                )
+
+                return _SignInResponse(
+                    token_response=token_response,
+                    tag=(
+                        _FlowStateTag.COMPLETE
+                        if token_response
+                        else _FlowStateTag.FAILURE
+                    ),
+                )
 
-        return _SignInResponse(tag=flow_response.flow_state.tag)
+            return _SignInResponse(tag=flow_response.flow_state.tag)
 
     async def get_refreshed_token(
         self,

{microsoft_agents_hosting_core-0.9.0.dev6 → microsoft_agents_hosting_core-0.9.0.dev8}/microsoft_agents/hosting/core/app/oauth/_handlers/agentic_user_authorization.py

@@ -16,6 +16,7 @@ from ._authorization_handler import _AuthorizationHandler
 from ....storage import Storage
 from ....authorization import Connections
 from ..auth_handler import AuthHandler
+from ..telemetry import spans
 
 logger = logging.getLogger(__name__)
 
@@ -179,9 +180,14 @@ class AgenticUserAuthorization(_AuthorizationHandler):
         :param exchange_scopes: Optional list of scopes to request during token exchange. If None, default scopes will be used.
         :type exchange_scopes: Optional[list[str]], Optional
         """
-        if not exchange_scopes:
-            exchange_scopes = self._handler.scopes or []
-        return await self.get_agentic_user_token(context, exchange_scopes)
+        with spans.AgenticToken(
+            auth_handler_id=self._id,
+            connection_name=exchange_connection,
+            scopes=exchange_scopes,
+        ):
+            if not exchange_scopes:
+                exchange_scopes = self._handler.scopes or []
+            return await self.get_agentic_user_token(context, exchange_scopes)
 
     async def sign_out(
         self, context: TurnContext, auth_handler_id: Optional[str] = None

microsoft_agents_hosting_core-0.9.0.dev8/microsoft_agents/hosting/core/app/oauth/telemetry/constants.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+AGENTIC_TOKEN = "agents.authorization.agentic_token"
+AZURE_BOT_TOKEN = "agents.authorization.azure_bot_token"
+AZURE_BOT_SIGN_OUT = "agents.authorization.azure_bot_sign_out"
+AZURE_BOT_SIGN_IN = "agents.authorization.azure_bot_sign_in"

microsoft_agents_hosting_core-0.9.0.dev8/microsoft_agents/hosting/core/app/oauth/telemetry/spans.py

@@ -0,0 +1,113 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from opentelemetry.trace import Span
+
+from microsoft_agents.hosting.core.telemetry import (
+    attributes,
+    AttributeMap,
+    SimpleSpanWrapper,
+    format_scopes,
+)
+from . import constants
+
+
+class _AuthorizationSpanWrapper(SimpleSpanWrapper):
+    """Base SpanWrapper for spans related to authorization operations.
+
+    This is meant to be a base class for spans related to authorization operations,
+    and can be used to share common functionality and attributes
+    """
+
+    def __init__(
+        self,
+        span_name: str,
+        auth_handler_id: str,
+        connection_name: str | None = None,
+        scopes: list[str] | None = None,
+    ):
+        """Initializes the _StorageSpanWrapper span."""
+        super().__init__(span_name)
+        self._auth_handler_id = auth_handler_id
+        self._connection_name = connection_name
+        self._scopes = scopes
+
+    def _callback(self, span: Span, duration: float, error: Exception | None) -> None:
+        """Callback function that is called when the span ends."""
+
+    def _get_attributes(self) -> dict[str, str]:
+        """Gets the attributes to be added to the span."""
+        attr_dict = {
+            attributes.AUTH_HANDLER_ID: self._auth_handler_id,
+            attributes.CONNECTION_NAME: self._connection_name or attributes.UNKNOWN,
+        }
+        if self._scopes is not None:
+            attr_dict[attributes.AUTH_SCOPES] = format_scopes(self._scopes)
+        return attr_dict
+
+
+class AgenticToken(_AuthorizationSpanWrapper):
+    """Span wrapper for agentic token operations."""
+
+    def __init__(
+        self,
+        auth_handler_id: str,
+        connection_name: str | None,
+        scopes: list[str] | None,
+    ):
+        """Initializes the AgenticToken span."""
+        super().__init__(
+            constants.AGENTIC_TOKEN,
+            auth_handler_id,
+            connection_name,
+            scopes,
+        )
+
+
+class AzureBotToken(_AuthorizationSpanWrapper):
+    """Span wrapper for azure bot token operations."""
+
+    def __init__(
+        self,
+        auth_handler_id: str,
+        connection_name: str | None,
+        scopes: list[str] | None,
+    ):
+        """Initializes the AzureBotToken span."""
+        super().__init__(
+            constants.AZURE_BOT_TOKEN,
+            auth_handler_id,
+            connection_name,
+            scopes,
+        )
+
+
+class AzureBotSignIn(_AuthorizationSpanWrapper):
+    """Span wrapper for azure bot sign in operations."""
+
+    def __init__(
+        self,
+        auth_handler_id: str,
+        connection_name: str | None,
+        scopes: list[str] | None,
+    ):
+        """Initializes the AzureBotSignIn span."""
+        super().__init__(
+            constants.AZURE_BOT_SIGN_IN,
+            auth_handler_id,
+            connection_name,
+            scopes,
+        )
+
+
+class AzureBotSignOut(_AuthorizationSpanWrapper):
+    """Span wrapper for azure bot sign out operations."""
+
+    def __init__(self, auth_handler_id: str):
+        """Initializes the AzureBotSignOut span."""
+        super().__init__(
+            constants.AZURE_BOT_SIGN_OUT,
+            auth_handler_id,
+        )

microsoft_agents_hosting_core-0.9.0.dev8/microsoft_agents/hosting/core/app/telemetry/constants.py

@@ -0,0 +1,12 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+SPAN_ON_TURN = "agents.app.run"
+SPAN_ROUTE_HANDLER = "agents.app.route_handler"
+SPAN_BEFORE_TURN = "agents.app.before_turn"
+SPAN_AFTER_TURN = "agents.app.after_turn"
+SPAN_DOWNLOAD_FILES = "agents.app.download_files"
+
+METRIC_TURN_COUNT = "agents.turn.count"
+METRIC_TURN_ERROR_COUNT = "agents.turn.error.count"
+METRIC_TURN_DURATION = "agents.turn.duration"

microsoft_agents_hosting_core-0.9.0.dev8/microsoft_agents/hosting/core/app/telemetry/metrics.py

@@ -0,0 +1,23 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from microsoft_agents.hosting.core.telemetry import agents_telemetry
+from . import constants
+
+turn_count = agents_telemetry.meter.create_counter(
+    constants.METRIC_TURN_COUNT,
+    "turn",
+    description="Total number of turns processed by the agent",
+)
+
+turn_error_count = agents_telemetry.meter.create_counter(
+    constants.METRIC_TURN_ERROR_COUNT,
+    "turn",
+    description="Number of turns that resulted in an error",
+)
+
+turn_duration = agents_telemetry.meter.create_histogram(
+    constants.METRIC_TURN_DURATION,
+    "ms",
+    description="Duration of agent turns in milliseconds",
+)