Home > MSDN > Documentation > Azure > Functions > Monitoring

Monitoring Azure Functions

Azure Functions provides robust monitoring capabilities to help you understand the health, performance, and behavior of your serverless applications. This guide covers the key tools and techniques for monitoring your functions, including Application Insights, logging, and alerts.

Key Monitoring Pillars

Application Insights

Leverage Application Insights for deep telemetry, performance analysis, error tracking, and end-to-end transaction tracing.

Azure Monitor Logs

Utilize Kusto Query Language (KQL) to query logs for detailed insights into function executions, triggers, and dependencies.

Alerts

Set up alerts based on metrics and logs to proactively notify you of issues like high error rates or long execution times.

Getting Started with Application Insights

Application Insights is the primary monitoring service for Azure Functions. It automatically collects a wealth of data about your function app's operations.

Key Telemetry Data:

Requests: Incoming requests to your HTTP-triggered functions.
Dependencies: Outgoing calls made by your functions to other services (databases, APIs, etc.).
Exceptions: Errors thrown during function execution.
Traces: Custom logs generated using `console.log`, `ILogger`, or similar logging mechanisms.
Performance Counters: System-level metrics like CPU usage and memory consumption.

To integrate Application Insights:

When creating a new Function App, select Application Insights as the monitoring service.
For existing Function Apps, configure the APPINSIGHTS_INSTRUMENTATIONKEY or APPLICATIONINSIGHTS_CONNECTION_STRING application setting.

Viewing Telemetry:

Navigate to your Function App in the Azure portal, then select "Application Insights" from the left-hand menu. You can explore:

Overview: A summary of key metrics like requests, failures, and performance.
Failures: Detailed information about exceptions and failed requests.
Performance: Analyze response times and identify bottlenecks.
Live Metrics: Real-time monitoring of your application's activity.
Search: Find specific requests, traces, or exceptions.

Logging with Azure Monitor Logs

Azure Functions integrates with Azure Monitor Logs, allowing you to query rich log data using Kusto Query Language (KQL).

Log Categories:

Function execution logs: Details about function invocations, triggers, and results.
Host logs: Information about the Function Host process.
Application logs: Custom logs emitted by your function code.

Example KQL Queries:

                
                // Find all function executions that failed in the last hour
                traces
                | where severityLevel >= 3 // Error or Critical
                | where timestamp > ago(1h)
                | project timestamp, message, operation_Name, invocationId
                
            

                
                // Get average execution time for a specific function
                requests
                | where name == "MyHttpTriggerFunction"
                | summarize avg(duration) by bin(timestamp, 5m)
                | render timechart
                
            

Access Logs by navigating to your Function App -> "Logs" under the "Monitoring" section in the Azure portal.

Configuring Alerts

Proactive alerting helps you respond quickly to issues. You can create alerts based on metrics or log queries.

Common Alert Scenarios:

High number of function execution errors.
Increased function execution duration.
Application Insights availability drops below a threshold.
Specific error messages appear in logs.

To set up alerts:

Navigate to "Alerts" in the Azure portal.
Click "+ Create" > "Alert rule".
Define the scope (your Function App).
Configure the condition (e.g., Metric: Function Execution Count, Threshold: Greater than 1000 in 5 minutes).
Choose an action group to specify how to be notified (e.g., email, SMS, webhook).

Best Practices for Monitoring

Implement structured logging: Use `ILogger` or equivalent for consistent log formatting.
Add correlation IDs: Ensure logs from a single request can be traced across different functions or services.
Monitor dependencies: Track the performance and success rate of calls to external resources.
Regularly review alerts: Tune alert thresholds to reduce noise and ensure critical issues are flagged.
Utilize Live Metrics: Keep an eye on your application in real-time, especially during deployments or high-traffic periods.

Microsoft Docs