_index.md

title

Install Serverless Monitoring for Azure Functions

further_reading

link tag text /serverless/guide/disable_serverless Documentation Disable Serverless Monitoring link tag text /opentelemetry/setup/otlp_ingest/serverless/?tab=azure#azure-functions Documentation Send Azure Functions traces to Datadog with OTLP link tag text http://datadoghq.com/blog/azure-well-architected-serverless-applications-best-practices/ Blog Build secure and scalable Azure serverless applications with the Well-Architected Framework link tag text https://www.datadoghq.com/blog/monitor-azure-functions-hosting-plans/ Blog Monitor Azure Functions across every hosting plan with Datadog

Overview

This page explains how to collect traces, trace metrics, runtime metrics, enhanced metrics, and custom metrics from your Azure Functions. Enhanced metrics are distinguished with the azure.functions.enhanced.* namespace. To collect additional metrics, install the Datadog Azure integration.

Here is the list of supported runtimes, operating systems (OS) and hosting plans for Azure Functions monitoring:

• Runtimes: .NET, Node.js, Python, Java
• Operating Systems (OS): Windows, Linux
• Hosting Plans: Dedicated (App Service) Plan, Premium Plan, Consumption Plan, Flex Consumption Plan

The recommended installation method depends on your Azure Function’s configuration:

• For .NET Windows Azure Functions running on Dedicated/App Service or Premium plans: use the Datadog .NET APM Extension.
• For Azure Function Apps running on Container Apps: use Datadog Serverless-Init.
• For all other configurations (including different runtimes, operating systems, or hosting plans): Follow the instructions below to install the Serverless Compatibility Layer.

Setup

If you haven't already, install the Datadog-Azure integration to collect metrics and logs. Then instrument your application with the following steps:

{{< programming-lang-wrapper langs="nodejs,python,java,dotnet" >}} {{< programming-lang lang="nodejs" >}}

1. Install dependencies. Run the following commands:

   npm install @datadog/serverless-compat
   npm install dd-trace

   Datadog recommends pinning the package versions and regularly upgrading to the latest versions of both @datadog/serverless-compat and dd-trace to ensure you have access to enhancements and bug fixes.

2. Start the Datadog Serverless Compatibility Layer and initialize the Datadog Node.js SDK.

   Use the --require option to load and initialize the Serverless Compatibility Layer and the Datadog Node.js SDK in one step. Node options in Azure Functions can be configured with the environment variable languageWorkers__node__arguments.

   languageWorkers__node__arguments='--require @datadog/serverless-compat/init --require dd-trace/init'
   

3. Configure the Datadog Node.js SDK

   Configuring the Node.js SDK

{{< /programming-lang >}} {{< programming-lang lang="python" >}}

1. Install dependencies. Run the following commands:

   pip install datadog-serverless-compat
   pip install ddtrace

   Datadog recommends using the latest versions of both datadog-serverless-compat and ddtrace to ensure you have access to enhancements and bug fixes.

2. Start the Datadog Serverless Compatibility Layer and initialize the Datadog Python SDK. Add the following lines to your main application entry point file:

   from datadog_serverless_compat import start
   start()
   
   import ddtrace.auto # noqa: E402, F401

3. Configure the Datadog Python SDK

   Configuring the Python SDK

{{< /programming-lang >}} {{< programming-lang lang="java" >}}

1. Install dependencies. Download the Datadog JARs and deploy them with your function:

   wget -O dd-java-agent.jar 'https://dtdg.co/latest-java-tracer'
   wget -O dd-serverless-compat-java-agent.jar 'https://dtdg.co/latest-serverless-compat-java-agent'

   See Datadog's Maven Repository for any specific version of the Datadog Serverless Compatibility Layer.

   Datadog recommends regularly upgrading to the latest versions of both dd-serverless-compat-java-agent and dd-java-agent to ensure you have access to enhancements and bug fixes.

2. Start the Datadog Serverless Compatibility Layer and initialize the Datadog Java SDK. Add the following -javaagent arguments to the JVM options.:

   -javaagent:/path/to/dd-serverless-compat-java-agent.jar -javaagent:/path/to/dd-java-agent.jar

   Note: the environment variable to set JVM options depends on the hosting plan (example, Consumption, Elastic Premium, Dedicated). See Azure Functions Java developer guide for more details on the appropriate environment variable for your hosting plan.

3. Configure the Datadog Java SDK

   Configuring the Java SDK

{{< /programming-lang >}} {{< programming-lang lang="dotnet" >}}

1. Install dependencies. Run the following commands:

   dotnet package add Datadog.AzureFunctions

   Datadog recommends regularly upgrading to the latest version of Datadog.AzureFunctions to ensure you have access to enhancements and bug fixes.

2. Start the Datadog Serverless Compatibility Layer.

   If your Azure Function app uses the Isolated Worker model, add the following lines to your main application entry point file:

   Datadog.Serverless.CompatibilityLayer.Start();

   If your Azure Function app uses the legacy in-process model, add a NuGet package reference to Microsoft.Azure.Functions.Extensions:

   dotnet package add Microsoft.Azure.Functions.Extensions

   And add the following .cs file to your application:

   using Datadog.Serverless;
   using Microsoft.Azure.Functions.Extensions.DependencyInjection;
   
   [assembly: FunctionsStartup(typeof(MyFunctionApp.Startup))]
   
   namespace MyFunctionApp
   {
      public class Startup : FunctionsStartup
      {
         public override void Configure(IFunctionsHostBuilder builder)
         {
               Datadog.Serverless.CompatibilityLayer.Start();
         }
      }
   }

3. Configure Automatic Instrumentation

   If your Azure Function app runs on Windows, add the following environment variables to your Function app:

   CORECLR_ENABLE_PROFILING=1
   
   CORECLR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8}
   
   CORECLR_PROFILER_PATH_64=
   C:\home\site\wwwroot\datadog\win-x64\Datadog.Trace.ClrProfiler.Native.dll
   
   CORECLR_PROFILER_PATH_32=
   C:\home\site\wwwroot\datadog\win-x86\Datadog.Trace.ClrProfiler.Native.dll
   
   DD_DOTNET_TRACER_HOME=C:\home\site\wwwroot\datadog
   
   

   If your Azure Function app runs on Linux, add the following environment variables to your Function app:

   CORECLR_ENABLE_PROFILING=1
   
   CORECLR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8}
   
   CORECLR_PROFILER_PATH=
      /home/site/wwwroot/datadog/linux-x64/Datadog.Trace.ClrProfiler.Native.so
   
   DD_DOTNET_TRACER_HOME=/home/site/wwwroot/datadog
   
   

4. Configure the Datadog .NET SDK

   • Configuring the Datadog .NET Core SDK
   • Configuring the Datadog .NET Framework SDK

{{< /programming-lang >}} {{< /programming-lang-wrapper >}}

5. Deploy your function.

6. Configure Datadog intake. Add the following environment variables to your function's application settings:

   Name	Value
   DD_API_KEY	Your Datadog API key.
   DD_SITE	Your Datadog site. For example, {{< region-param key=dd_site code="true" >}}.
   DD_AZURE_RESOURCE_GROUP	Your Azure resource group. Only required for Azure Functions on the Flex Consumption plan.

   {{% svl-tracing-env %}}

7. Configure Unified Service Tagging. You can collect metrics from your Azure Functions by installing the Datadog Azure integration. To correlate these metrics with your traces, first set the env, service, and version tags on your resource in Azure. Then, configure the following environment variables.

   Name	Value
   DD_ENV	How you want to tag your env for Unified Service Tagging. For example, prod.
   DD_SERVICE	How you want to tag your service for Unified Service Tagging.
   DD_VERSION	How you want to tag your version for Unified Service Tagging.

What's next?

• You can view your Azure Functions traces in {{< ui >}}Trace Explorer{{< /ui >}}. Search for the service name you set in the DD_SERVICE environment variable to see your traces.
• You can use the {{< ui >}}Serverless{{< /ui >}} > {{< ui >}}Azure Functions{{< /ui >}} page to see your traces enriched with telemetry collected by the Datadog Azure integration.

Profiling

Datadog's Continuous Profiler is available in preview for Python and Node.js on Azure Functions.

To enable the Continuous Profiler, set the environment variable DD_PROFILING_ENABLED=true.

Troubleshooting

Enable debug logs

You can collect debug logs for troubleshooting. To configure debug logs, use the following environment variables:

DD_TRACE_DEBUG : Enables (true) or disables (false) debug logging for the Datadog SDK. Defaults to false.

Values: true, false

DD_LOG_LEVEL : Sets logging level for the Datadog Serverless Compatibility Layer. Defaults to info.

Values: trace, debug, info, warn, error, critical, off

Further reading

{{< partial name="whats-next/whats-next.html" >}}