Use OpenTelemetry with Azure Functions

OpenTelemetry currently isn't supported for C# in-process apps.

Examples in this article assume your app is using IHostApplicationBuilder, which is available in version 2.x and later version of Microsoft.Azure.Functions.Worker. For more information, see Version 2.x in the C# isolated worker model guide.

1. Run these commands to install the required assemblies in your app:

   • Application Insights
   • OTLP Exporter

   dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry --version  1.1.0-preview6
   dotnet add package OpenTelemetry.Extensions.Hosting 
   dotnet add package Azure.Monitor.OpenTelemetry.Exporter  
   

2. In your Program.cs project file, add this using statement:

   • Application Insights
   • OTLP Exporter

   using Azure.Monitor.OpenTelemetry.Exporter; 
   

3. The way that you configure OpenTelemetry depends if your project startup uses IHostBuilder or IHostApplicationBuilder, which was introduced in v2.x of the .NET isolated worker model extension.

   • IHostApplicationBuilder
   • IHostBuilder

   In program.cs, add this line of code after ConfigureFunctionsWebApplication:

   builder.Services.AddOpenTelemetry()
       .UseFunctionsWorkerDefaults()
       .UseAzureMonitorExporter();
   

   You can export to both OpenTelemetry endpoints from the same app.

1. Add the required libraries to your app. The way you add libraries depends on whether you deploy using Maven or Kotlin and if you want to also send data to Application Insights.

   • Maven
   • Kotlin

   <dependency>
     <groupId>com.microsoft.azure.functions</groupId>
     <artifactId>azure-functions-java-opentelemetry</artifactId>
     <version>1.0.0</version>
   </dependency>
   <dependency>
     <groupId>com.azure</groupId>
     <artifactId>azure-monitor-opentelemetry-autoconfigure</artifactId>
     <version>1.2.0</version>
   </dependency>
   

2. You can optionally add this code to create custom spans:

   import com.microsoft.azure.functions.opentelemetry.FunctionsOpenTelemetry;
   import io.opentelemetry.api.trace.Span;
   import io.opentelemetry.api.trace.SpanKind;
   import io.opentelemetry.context.Scope;
   
   Span span = FunctionsOpenTelemetry.startSpan(
           "com.contoso.PaymentFunction",  // tracer name
           "validateCharge",               // span name
           null,                           // parent = current context
           SpanKind.INTERNAL);
   
   try (Scope ignored = span.makeCurrent()) {
       // business logic here
   } finally {
       span.end();
   }
   

1. Install these npm packages in your project:

   • Application Insights
   • OTLP Exporter

   npm install @opentelemetry/api 
   npm install @opentelemetry/auto-instrumentations-node 
   npm install @azure/monitor-opentelemetry-exporter 
   npm install @azure/functions-opentelemetry-instrumentation
   

2. Create a code file in your project, copy and paste the following code in this new file, and save the file as src/index.js:

   • Application Insights
   • OTLP Exporter

   const { AzureFunctionsInstrumentation } = require('@azure/functions-opentelemetry-instrumentation');
   const { AzureMonitorLogExporter, AzureMonitorTraceExporter } = require('@azure/monitor-opentelemetry-exporter');
   const { getNodeAutoInstrumentations, getResourceDetectors } = require('@opentelemetry/auto-instrumentations-node');
   const { registerInstrumentations } = require('@opentelemetry/instrumentation');
   const { detectResourcesSync } = require('@opentelemetry/resources');
   const { LoggerProvider, SimpleLogRecordProcessor } = require('@opentelemetry/sdk-logs');
   const { NodeTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-node');
   
   const resource = detectResourcesSync({ detectors: getResourceDetectors() });
   
   const tracerProvider = new NodeTracerProvider({ resource });
   tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new AzureMonitorTraceExporter()));
   tracerProvider.register();
   
   const loggerProvider = new LoggerProvider({ resource });
   loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new AzureMonitorLogExporter()));
   
   registerInstrumentations({
       tracerProvider,
       loggerProvider,
       instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
   });
   

3. Update the main field in your package.json file to include this new src/index.js file, which might look like this:

   "main": "src/{index.js,functions/*.js}"
   

2. Create a code file in your project, copy and paste the following code in this new file, and save the file as src/index.ts:

   • Application Insights
   • OTLP Exporter

   import { AzureFunctionsInstrumentation } from '@azure/functions-opentelemetry-instrumentation';
   import { AzureMonitorLogExporter, AzureMonitorTraceExporter } from '@azure/monitor-opentelemetry-exporter';
   import { getNodeAutoInstrumentations, getResourceDetectors } from '@opentelemetry/auto-instrumentations-node';
   import { registerInstrumentations } from '@opentelemetry/instrumentation';
   import { detectResourcesSync } from '@opentelemetry/resources';
   import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
   import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
   
   const resource = detectResourcesSync({ detectors: getResourceDetectors() });
   
   const tracerProvider = new NodeTracerProvider({ resource });
   tracerProvider.addSpanProcessor(new SimpleSpanProcessor(new AzureMonitorTraceExporter()));
   tracerProvider.register();
   
   const loggerProvider = new LoggerProvider({ resource });
   loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new AzureMonitorLogExporter()));
   
   registerInstrumentations({
       tracerProvider,
       loggerProvider,
       instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
   });
   

3. Update the main field in your package.json file to include the output of this new src/index.ts file, which might look like this:

   "main": "dist/src/{index.js,functions/*.js}"
   

These instructions only apply for an OTLP exporter:

1. Add an application setting named OTEL_FUNCTIONS_WORKER_ENABLED with value of True.

2. Create an app-level Modules folder in the root of your app and run the following command:

   Save-Module -Name AzureFunctions.PowerShell.OpenTelemetry.SDK
   

   This installs the required AzureFunctions.PowerShell.OpenTelemetry.SDK module directly in your app. You can't use the requirements.psd1 file to automatically install this dependency because managed dependencies isn't currently supported in the Flex Consumption plan preview.

3. Add this code to your profile.ps1 file:

   Import-Module AzureFunctions.PowerShell.OpenTelemetry.SDK -Force -ErrorAction Stop 
   Initialize-FunctionsOpenTelemetry 
   

1. Make sure these libraries are in your requirements.txt file, whether from uncommenting or adding yourself:

   • Application Insights
   • OTLP Exporter

   azure-monitor-opentelemetry
   

2. Add this code to your function_app.py main entry point file:

   • Application Insights
   • OTLP Exporter

   If you already added PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY=true in your application settings, you can skip this step. To manually enable Application Insights collection without automatic instrumentation, add this code to your app:

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

3. Review Azure monitor Distro usage documentation for options on how to further configure the SDK.

• Custom spans automatically include all resource attributes and use the exporters configured in your app.

• When your app runs outside Azure, including during local development, the resource detector sets the service.name attribute to java-function-app by default.

• Use these Java Virtual Machine (JVM) flags to silence telemetry when running locally during unit tests:

  • -Dotel.traces.exporter=none
  • -Dotel.metrics.exporter=none
  • -Dotel.logs.exporter=none

• You aren't required to manually register middleware; the Java worker autodiscovers OpenTelemetryInvocationMiddleware.