Add app insights and Logfire instrumentation

infra/aca.bicep

@@ -12,6 +12,7 @@ param openAiEndpoint string
 param cosmosDbAccount string
 param cosmosDbDatabase string
 param cosmosDbContainer string
+param applicationInsightsConnectionString string = ''
 
 resource acaIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: identityName
@@ -58,6 +59,10 @@ module app 'core/host/container-app-upsert.bicep' = {
         name: 'AZURE_COSMOSDB_CONTAINER'
         value: cosmosDbContainer
       }
+      {
+        name: 'APPLICATIONINSIGHTS_CONNECTION_STRING'
+        value: applicationInsightsConnectionString
+      }
     ]
     targetPort: 8000
   }

infra/main.bicep

@@ -155,6 +155,20 @@ module logAnalyticsWorkspace 'br/public:avm/res/operational-insights/workspace:0
   }
 }
 
+// Application Insights for telemetry
+module applicationInsights 'br/public:avm/res/insights/component:0.4.2' = if (useMonitoring) {
+  name: 'applicationinsights'
+  scope: resourceGroup
+  params: {
+    name: '${prefix}-appinsights'
+    location: location
+    tags: tags
+    workspaceResourceId: logAnalyticsWorkspace.?outputs.resourceId
+    kind: 'web'
+    applicationType: 'web'
+  }
+}
+
 // https://learn.microsoft.com/en-us/azure/container-apps/firewall-integration?tabs=consumption-only
 module containerAppsNSG 'br/public:avm/res/network/network-security-group:0.5.1' = if (useVnet) {
   name: 'containerAppsNSG'
@@ -669,6 +683,7 @@ module aca 'aca.bicep' = {
     cosmosDbAccount: cosmosDb.outputs.name
     cosmosDbDatabase: cosmosDbDatabaseName
     cosmosDbContainer: cosmosDbContainerName
+    applicationInsightsConnectionString: useMonitoring ? applicationInsights.outputs.connectionString : ''
     exists: acaExists
   }
 }
@@ -738,3 +753,5 @@ output AZURE_COSMOSDB_ACCOUNT string = cosmosDb.outputs.name
 output AZURE_COSMOSDB_ENDPOINT string = cosmosDb.outputs.endpoint
 output AZURE_COSMOSDB_DATABASE string = cosmosDbDatabaseName
 output AZURE_COSMOSDB_CONTAINER string = cosmosDbContainerName
+
+output APPLICATIONINSIGHTS_CONNECTION_STRING string = useMonitoring ? applicationInsights.outputs.connectionString : ''

pyproject.toml

@@ -16,6 +16,9 @@ dependencies = [
     "azure-ai-agents>=1.1.0",
     "agent-framework>=1.0.0b251016",
     "azure-cosmos>=4.9.0",
+    "azure-monitor-opentelemetry>=1.6.4",
+    "logfire>=3.11.0",
+    "azure-core-tracing-opentelemetry>=1.0.0b12"
 ]
 
 [dependency-groups]

servers/deployed_mcp.py

@@ -5,21 +5,37 @@
 from enum import Enum
 from typing import Annotated
 
+import logfire
+from azure.core.settings import settings
 from azure.cosmos.aio import CosmosClient
 from azure.identity.aio import DefaultAzureCredential, ManagedIdentityCredential
+from azure.monitor.opentelemetry import configure_azure_monitor
 from dotenv import load_dotenv
 from fastmcp import FastMCP
+from opentelemetry_middleware import OpenTelemetryMiddleware
 
-load_dotenv(override=True)
+RUNNING_IN_PRODUCTION = os.getenv("RUNNING_IN_PRODUCTION", "false").lower() == "true"
+
+if not RUNNING_IN_PRODUCTION:
+    load_dotenv(override=True)
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s")
+logging.basicConfig(level=logging.WARNING, format="%(asctime)s - %(message)s")
 logger = logging.getLogger("ExpensesMCP")
+logger.setLevel(logging.INFO)
+
+# Configure OpenTelemetry tracing
+if os.getenv("APPLICATIONINSIGHTS_CONNECTION_STRING"):
+    logger.info("Setting up Azure Monitor instrumentation")
+    configure_azure_monitor()
+elif os.getenv("LOGFIRE_PROJECT_NAME"):
+    logger.info("Setting up Logfire instrumentation")
+    settings.tracing_implementation = "opentelemetry"  # Send Azure Monitor traces via OpenTelemetry
+    logfire.configure(service_name="expenses-mcp", send_to_logfire=True)
 
 # Cosmos DB configuration from environment variables
 AZURE_COSMOSDB_ACCOUNT = os.environ["AZURE_COSMOSDB_ACCOUNT"]
 AZURE_COSMOSDB_DATABASE = os.environ["AZURE_COSMOSDB_DATABASE"]
 AZURE_COSMOSDB_CONTAINER = os.environ["AZURE_COSMOSDB_CONTAINER"]
-RUNNING_IN_PRODUCTION = os.getenv("RUNNING_IN_PRODUCTION", "false").lower() == "true"
 AZURE_CLIENT_ID = os.getenv("AZURE_CLIENT_ID", "")
 
 # Configure Cosmos DB client and container
@@ -37,6 +53,7 @@
 logger.info(f"Connected to Cosmos DB: {AZURE_COSMOSDB_ACCOUNT}")
 
 mcp = FastMCP("Expenses Tracker")
+mcp.add_middleware(OpenTelemetryMiddleware("ExpensesMCP"))
 
 
 class PaymentMethod(Enum):

servers/opentelemetry_middleware.py

@@ -0,0 +1,83 @@
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+
+
+class OpenTelemetryMiddleware(Middleware):
+    """Middleware that creates OpenTelemetry spans for MCP operations."""
+
+    def __init__(self, tracer_name: str):
+        self.tracer = trace.get_tracer(tracer_name)
+
+    async def on_call_tool(self, context: MiddlewareContext, call_next):
+        """Create a span for each tool call with detailed attributes."""
+        tool_name = context.message.name
+
+        with self.tracer.start_as_current_span(
+            f"tool.{tool_name}",
+            attributes={
+                "mcp.method": context.method,
+                "mcp.source": context.source,
+                "mcp.tool.name": tool_name,
+                "mcp.tool.arguments": str(context.message.arguments),
+            },
+        ) as span:
+            try:
+                result = await call_next(context)
+                span.set_attribute("mcp.tool.success", True)
+                span.set_status(Status(StatusCode.OK))
+                return result
+            except Exception as e:
+                span.set_attribute("mcp.tool.success", False)
+                span.set_attribute("mcp.tool.error", str(e))
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                raise
+
+    async def on_read_resource(self, context: MiddlewareContext, call_next):
+        """Create a span for each resource read."""
+        resource_uri = str(getattr(context.message, "uri", "unknown"))
+
+        with self.tracer.start_as_current_span(
+            f"resource.{resource_uri}",
+            attributes={
+                "mcp.method": context.method,
+                "mcp.source": context.source,
+                "mcp.resource.uri": resource_uri,
+            },
+        ) as span:
+            try:
+                result = await call_next(context)
+                span.set_attribute("mcp.resource.success", True)
+                span.set_status(Status(StatusCode.OK))
+                return result
+            except Exception as e:
+                span.set_attribute("mcp.resource.success", False)
+                span.set_attribute("mcp.resource.error", str(e))
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                raise
+
+    async def on_get_prompt(self, context: MiddlewareContext, call_next):
+        """Create a span for each prompt retrieval."""
+        prompt_name = getattr(context.message, "name", "unknown")
+
+        with self.tracer.start_as_current_span(
+            f"prompt.{prompt_name}",
+            attributes={
+                "mcp.method": context.method,
+                "mcp.source": context.source,
+                "mcp.prompt.name": prompt_name,
+            },
+        ) as span:
+            try:
+                result = await call_next(context)
+                span.set_attribute("mcp.prompt.success", True)
+                span.set_status(Status(StatusCode.OK))
+                return result
+            except Exception as e:
+                span.set_attribute("mcp.prompt.success", False)
+                span.set_attribute("mcp.prompt.error", str(e))
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                raise