Logging in Azure Functions

Effective logging is crucial for monitoring the health, performance, and behavior of your Azure Functions. This reference provides detailed information on how to implement and utilize logging within your serverless applications.

The ILogger Object

Azure Functions provides an ILogger interface for structured logging. This object is automatically injected into your function when you define it as a parameter. It offers various methods for logging messages at different severity levels.

Logging Levels

The ILogger object supports the following standard logging levels:

  • Trace: Verbose logging, typically used for detailed debugging.
  • Debug: Information useful for debugging, but less verbose than Trace.
  • Information: General operational messages.
  • Warning: Indicates a potential issue or an unexpected situation.
  • Error: Indicates a failure that prevented the function from completing its operation.
  • Critical: Indicates a severe error that caused the application to stop or crash.

Common Logging Methods

Here are some of the most commonly used methods on the ILogger object:


// C# Example
using Microsoft.Extensions.Logging;

public static class MyFunction
{
    [FunctionName("MyFunctionName")]
    public static void Run([TimerTrigger("0 */5 * * * *")]TimerInfo myTimer, ILogger log)
    {
        log.LogInformation("C# timer trigger function executed at: {Now}", DateTime.Now);
        log.LogDebug("This is a debug message.");
        log.LogWarning("This is a warning message.");
        log.LogError("This is an error message.");
        log.LogCritical("This is a critical error message.");
        log.LogTrace("This is a trace message.");
    }
                

// JavaScript Example
module.exports = async function (context, myTimer) {
    context.log('JavaScript timer trigger function executed at: ', new Date());
    context.log.verbose('Verbose log message.');
    context.log.debug('Debug log message.');
    context.log.info('Info log message.');
    context.log.warn('Warn log message.');
    context.log.error('Error log message.');
    context.log.critical('Critical log message.');
};

Structured Logging

Azure Functions encourages structured logging, which involves logging data in a key-value format. This makes it easier to query and analyze logs in services like Application Insights.

You can achieve structured logging by using named parameters in your log messages:


log.LogInformation("User {UserId} logged in from IP {IpAddress}", userId, ipAddress);

This will log two properties, UserId and IpAddress, alongside the message, making it searchable by these keys.

Integration with Application Insights

Azure Functions automatically integrates with Application Insights, a powerful Application Performance Management (APM) service. When you enable Application Insights for your function app, all your logs, traces, exceptions, and performance metrics are sent to Application Insights for analysis and visualization.

Tip

Ensure your host.json file is configured correctly to send logs to Application Insights. The default configuration usually handles this.


{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  }
}

Custom Logging Scenarios

Logging Exceptions

It's vital to log any exceptions that occur in your functions. You can use the LogError method with an exception object.


try
{
    // Some operation that might throw an exception
    throw new InvalidOperationException("Something went wrong.");
}
catch (Exception ex)
{
    log.LogError(ex, "An error occurred during the process.");
}

Logging Performance Metrics

While Application Insights captures many performance metrics automatically, you can also log custom performance indicators.


var stopwatch = Stopwatch.StartNew();
// ... perform operation ...
stopwatch.Stop();
log.LogInformation("Operation {OperationName} took {Duration}ms", "DataProcessing", stopwatch.ElapsedMilliseconds);

Logging Configuration (host.json)

The host.json file allows you to configure logging behavior, including sampling rates and log levels for different categories.


{
  "version": "2.0",
  "logging": {
    "logLevel": {
      "default": "Information",
      "Host.Reactor": "Trace",
      "Function.MyFunctionName": "Debug"
    },
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  }
}

In this example:

  • default: Sets the default log level for all categories to Information.
  • Host.Reactor: Sets the log level for the host reactor to Trace.
  • Function.MyFunctionName: Sets the log level for a specific function named MyFunctionName to Debug.

Best Practices for Logging

  • Be Descriptive: Log messages should be clear and concise, providing enough context to understand what happened.
  • Use Structured Logging: Leverage key-value pairs for easier analysis.
  • Log at Appropriate Levels: Use Error and Critical for actual failures, Warning for potential issues, and Information for general flow. Use Debug and Trace sparingly for debugging.
  • Avoid Sensitive Data: Do not log personally identifiable information (PII) or sensitive credentials unless absolutely necessary and properly secured.
  • Monitor Logs Regularly: Use Application Insights to monitor your logs for errors and performance bottlenecks.
  • Context is Key: Include relevant IDs (e.g., correlation IDs, request IDs, user IDs) in your log messages to track requests across multiple function invocations or services.

Further Reading