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,11 @@ module app 'core/host/container-app-upsert.bicep' = {
         name: 'AZURE_COSMOSDB_CONTAINER'
         value: cosmosDbContainer
       }
+      // We typically store sensitive values in secrets, but App Insights connection strings are not considered highly sensitive
+      {
+        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,6 @@ 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
+
+// We typically do not output sensitive values, but App Insights connection strings are not considered highly sensitive
+output APPLICATIONINSIGHTS_CONNECTION_STRING string = useMonitoring ? applicationInsights.outputs.connectionString : ''

infra/write_env.ps1

@@ -11,4 +11,5 @@ Add-Content -Path $ENV_FILE_PATH -Value "AZURE_TENANT_ID=$(azd env get-value AZU
 Add-Content -Path $ENV_FILE_PATH -Value "AZURE_COSMOSDB_ACCOUNT=$(azd env get-value AZURE_COSMOSDB_ACCOUNT)"
 Add-Content -Path $ENV_FILE_PATH -Value "AZURE_COSMOSDB_DATABASE=$(azd env get-value AZURE_COSMOSDB_DATABASE)"
 Add-Content -Path $ENV_FILE_PATH -Value "AZURE_COSMOSDB_CONTAINER=$(azd env get-value AZURE_COSMOSDB_CONTAINER)"
+Add-Content -Path $ENV_FILE_PATH -Value "APPLICATIONINSIGHTS_CONNECTION_STRING=$(azd env get-value APPLICATIONINSIGHTS_CONNECTION_STRING)"
 Add-Content -Path $ENV_FILE_PATH -Value "API_HOST=azure"

infra/write_env.sh

@@ -15,4 +15,5 @@ echo "AZURE_TENANT_ID=$(azd env get-value AZURE_TENANT_ID)" >> "$ENV_FILE_PATH"
 echo "AZURE_COSMOSDB_ACCOUNT=$(azd env get-value AZURE_COSMOSDB_ACCOUNT)" >> "$ENV_FILE_PATH"
 echo "AZURE_COSMOSDB_DATABASE=$(azd env get-value AZURE_COSMOSDB_DATABASE)" >> "$ENV_FILE_PATH"
 echo "AZURE_COSMOSDB_CONTAINER=$(azd env get-value AZURE_COSMOSDB_CONTAINER)" >> "$ENV_FILE_PATH"
-echo "API_HOST=azure" >> "$ENV_FILE_PATH"
+echo "APPLICATIONINSIGHTS_CONNECTION_STRING=$(azd env get-value APPLICATIONINSIGHTS_CONNECTION_STRING)" >> "$ENV_FILE_PATH"
+echo "API_HOST=azure" >> "$ENV_FILE_PATH"

pyproject.toml

@@ -16,6 +16,10 @@ dependencies = [
     "azure-ai-agents>=1.1.0",
     "agent-framework>=1.0.0b251016",
     "azure-cosmos>=4.9.0",
+    "azure-monitor-opentelemetry>=1.6.4",
+    "opentelemetry-instrumentation-starlette>=0.49b0",
+    "logfire>=4.15.1",
+    "azure-core-tracing-opentelemetry>=1.0.0b12"
 ]
 
 [dependency-groups]

servers/deployed_mcp.py

@@ -1,25 +1,49 @@
+"""Run with: cd servers && uvicorn deployed_mcp:app --host 0.0.0.0 --port 8000"""
+
 import logging
 import os
 import uuid
 from datetime import date
 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.instrumentation.starlette import StarletteInstrumentor
+
+try:
+    from opentelemetry_middleware import OpenTelemetryMiddleware
+except ImportError:
+    from servers.opentelemetry_middleware import OpenTelemetryMiddleware
+
+RUNNING_IN_PRODUCTION = os.getenv("RUNNING_IN_PRODUCTION", "false").lower() == "true"
 
-load_dotenv(override=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, either via Azure Monitor or Logfire
+# We don't support both at the same time due to potential conflicts with tracer providers
+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"  # Configure Azure SDK to use OpenTelemetry tracing
+    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 +61,7 @@
 logger.info(f"Connected to Cosmos DB: {AZURE_COSMOSDB_ACCOUNT}")
 
 mcp = FastMCP("Expenses Tracker")
+mcp.add_middleware(OpenTelemetryMiddleware("ExpensesMCP"))
 
 
 class PaymentMethod(Enum):
@@ -152,7 +177,4 @@ def analyze_spending_prompt(
 
 # ASGI application for uvicorn
 app = mcp.http_app()
-
-if __name__ == "__main__":
-    logger.info("MCP Expenses server starting (HTTP mode on port 8000)")
-    mcp.run(transport="http", host="0.0.0.0", port=8000)
+StarletteInstrumentor.instrument_app(app)

servers/opentelemetry_middleware.py

@@ -0,0 +1,85 @@
+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,
+                # If arguments are sensitive, consider omitting or sanitizing them
+                # If arguments are long/nested, consider adding a size or depth limit
+                "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