Monitoring Azure Functions

What the Functions runtime collects automatically

The Azure Functions runtime has a built-in Application Insights integration. When you configure the connection string, it automatically collects:

• Function invocations — Every execution: start time, end time, duration, success/failure status, trigger type
• Exceptions — Unhandled exceptions from your function code, including stack traces
• Dependencies — Outbound calls your function makes: HTTP requests, SQL queries, blob storage operations, queue messages sent
• Host metrics — Memory usage, process-level performance counters

All of this happens without you writing any monitoring code in your function. Your function code focuses entirely on its business logic.

Configuring monitoring for Azure Functions

# Set Application Insights connection string on a Function App
az functionapp config appsettings set \
  --resource-group myRG \
  --name myfunctionapp \
  --settings APPLICATIONINSIGHTS_CONNECTION_STRING="<connection-string>"

# Verify Application Insights is configured
az functionapp config appsettings list \
  --resource-group myRG \
  --name myfunctionapp \
  --query "[?name=='APPLICATIONINSIGHTS_CONNECTION_STRING']" \
  --output table

# Create a Function App with Application Insights enabled from the start
az functionapp create \
  --resource-group myRG \
  --name myfunctionapp \
  --storage-account mystorageaccount \
  --runtime dotnet-isolated \
  --runtime-version 8 \
  --functions-version 4 \
  --os-type linux \
  --consumption-plan-location eastus \
  --app-insights myapp-insights

Controlling telemetry volume with host.json

High-frequency functions (processing thousands of queue messages per minute) can generate enormous Application Insights telemetry volumes. Configure sampling in host.json to keep costs manageable while retaining full fidelity for errors and exceptions.

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "maxTelemetryItemsPerSecond": 20,
        "excludedTypes": "Exception",
        "includedTypes": "Request;Dependency"
      },
      "enableLiveDiagnosticsChannel": true
    },
    "logLevel": {
      "default": "Warning",
      "Function": "Information",
      "Host.Aggregator": "Trace",
      "Host.Results": "Error"
    }
  }
}

Key settings explained:

• maxTelemetryItemsPerSecond — Target throughput for sampling. Adaptive sampling adjusts the rate to hit this target.
• excludedTypes — Types that are never sampled out. Setting Exception here means every exception is always captured.
• logLevel — Controls which log messages are sent to Application Insights. Setting most categories to Warning reduces trace volume significantly.

Essential KQL queries for Azure Functions

These queries cover the most common monitoring needs for serverless workloads.

// Function invocation success rate over time
AppRequests
| where TimeGenerated > ago(24h)
| where AppRoleName == "myfunctionapp"
| summarize
    Total = count(),
    Successes = countif(Success == true),
    Failures = countif(Success == false)
    by FunctionName = Name, bin(TimeGenerated, 1h)
| extend SuccessRate = round(100.0 * Successes / Total, 1)
| order by TimeGenerated desc, FunctionName asc

// Find functions with the highest failure rate
AppRequests
| where TimeGenerated > ago(7d)
| where AppRoleName == "myfunctionapp"
| summarize
    Total = count(),
    Failures = countif(Success == false)
    by FunctionName = Name
| extend FailureRate = round(100.0 * Failures / Total, 2)
| where Total > 10  // Ignore rarely-run functions
| order by FailureRate desc

// Average and P95 function execution duration
AppRequests
| where TimeGenerated > ago(24h)
| where AppRoleName == "myfunctionapp"
| where Success == true
| summarize
    AvgDuration = avg(DurationMs),
    P95Duration = percentile(DurationMs, 95),
    Invocations = count()
    by FunctionName = Name
| order by P95Duration desc

// Function exceptions with context
AppExceptions
| where TimeGenerated > ago(24h)
| where AppRoleName == "myfunctionapp"
| project TimeGenerated,
    FunctionName = operation_Name,
    ExceptionType,
    OuterMessage,
    InnermostMessage,
    OperationId = operation_Id
| order by TimeGenerated desc
| limit 50

Adding custom telemetry to function code

The automatic telemetry tells you that a function ran and how long it took. Custom telemetry tells you what it accomplished — how many records it processed, how many were skipped, what business decisions it made.

# In your function code (C# example using ILogger for structured logging):
# The Functions runtime routes ILogger calls to Application Insights automatically.

# Log at different levels with structured properties:
# _logger.LogInformation("Processed {RecordCount} records from {QueueName}",
#     processedCount, queueName);
#
# _logger.LogWarning("Skipped {RecordCount} records due to validation errors",
#     skippedCount);
#
# _logger.LogError(ex, "Failed to process record {RecordId} after {RetryCount} retries",
#     recordId, retryCount);

# For custom metrics, inject TelemetryClient:
# _telemetryClient.TrackMetric("RecordsProcessed", processedCount,
#     new Dictionary<string, string> {
#         { "FunctionName", context.FunctionName },
#         { "QueueName", queueName }
#     });
#
# _telemetryClient.TrackEvent("BatchCompleted",
#     new Dictionary<string, string> {
#         { "BatchId", batchId },
#         { "QueueName", queueName }
#     },
#     new Dictionary<string, double> {
#         { "RecordsProcessed", processedCount },
#         { "DurationMs", sw.ElapsedMilliseconds }
#     });

Monitoring Durable Functions

Durable Functions (orchestrations, activities, entities) add workflow-level monitoring on top of regular function monitoring. Each orchestration instance gets an instance ID that you can use to track the workflow’s progress.

# Query the Durable Task Framework status via the management API
curl -X GET \
  "https://myfunctionapp.azurewebsites.net/runtime/webhooks/durabletask/instances?code=<host-key>&top=50&createdTimeFrom=$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%MZ)" \
  -H "Content-Type: application/json"

# Check the status of a specific orchestration instance
curl -X GET \
  "https://myfunctionapp.azurewebsites.net/runtime/webhooks/durabletask/instances/<instanceId>?code=<host-key>" \
  -H "Content-Type: application/json"

// Track Durable Functions orchestration health in KQL
AppTraces
| where TimeGenerated > ago(24h)
| where AppRoleName == "myfunctionapp"
| where Message contains "orchestration"
| extend
    InstanceId = tostring(customDimensions["prop__instanceId"]),
    Status = tostring(customDimensions["prop__status"])
| summarize LastStatus = arg_max(TimeGenerated, Status) by InstanceId
| summarize StatusCount = count() by Status