Använda OpenTelemetry med Azure Functions

Viktigt!

OpenTelemetry-stöd för Azure Functions är för närvarande i förhandsversion och din app måste finnas i en Flex Consumption-plan för att använda OpenTelemetry.

Den här artikeln visar hur du konfigurerar funktionsappen för att exportera logg- och spårningsdata i ett OpenTelemetry-format. Azure Functions genererar telemetridata om dina funktionskörningar från både Functions-värdprocessen och den språkspecifika arbetsprocess där funktionskoden körs. Som standard skickas dessa telemetridata till Application Insights med hjälp av Application Insights SDK. Du kan dock välja att exportera dessa data med hjälp av OpenTelemetry-semantik. Du kan fortfarande använda ett OpenTelemetry-format för att skicka dina data till Application Insights, men du kan nu även exportera samma data till andra OpenTelemetry-kompatibla slutpunkter.

Dricks

Eftersom den här artikeln riktar sig till valfritt utvecklingsspråk bör du komma ihåg att välja rätt språk överst i artikeln.

För närvarande finns det inget klientoptimerad OpenTelemetry-stöd för Java-appar.

OpenTelemetry stöds för närvarande inte för processbaserade C#-appar.

Du kan få dessa fördelar genom att aktivera OpenTelemetry i funktionsappen:

• Korrelation mellan spårningar och loggar som genereras både på värden och i programkoden.
• Konsekvent, standardbaserad generering av exportbara telemetridata.
• Integrerar med andra leverantörer som kan använda OpenTeleletry-kompatibla data.

OpenTelemetry är aktiverat på funktionsappsnivå, både i värdkonfigurationen (host.json) och i kodprojektet. Functions ger också en klientoptimerad upplevelse för att exportera OpenTelemetry-data från din funktionskod som körs i en språkspecifik arbetsprocess.

1. Aktivera OpenTelemetry i Functions-värden

När du aktiverar OpenTelemetry-utdata i funktionsappens host.json fil exporterar värden OpenTelemetry-utdata oavsett vilken språkstack som används av din app.

Om du vill aktivera OpenTelemetry-utdata från Functions-värden uppdaterar du filen host.json i kodprojektet för att lägga till ett "telemetryMode": "openTelemetry" element i rotsamlingen. Med OpenTelemetry aktiverat kan din host.json-fil se ut så här:

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

2. Konfigurera programinställningar

När OpenTelemetry är aktiverat i filen host.json bestäms slutpunkterna som data skickas till baserat på vilka Programinställningar som stöds av OpenTelemetry i appens miljövariabler.

Skapa specifika programinställningar i funktionsappen baserat på utdatamålet OpenTelemetry. När anslutningsinställningar anges för både Application Insights och en exportör av OpenTelemetry Protocol (OTLP) skickas OpenTelemetry-data till båda slutpunkterna.

Application Insights

APPLICATIONINSIGHTS_CONNECTION_STRING: anslutningssträng för en Application Insights-arbetsyta. När den här inställningen finns skickas OpenTelemetry-data till den arbetsytan. Den här inställningen är samma som används för att ansluta till Application Insights utan OpenTelemetry aktiverat. Om din app inte redan har den här inställningen kan du behöva aktivera Application Insights-integrering.

OTLP-exportör

OTEL_EXPORTER_OTLP_ENDPOINT: en SLUTpunkts-URL för OTLP-exportören.

OTEL_EXPORTER_OTLP_HEADERS: (Valfritt) lista över rubriker som ska tillämpas på alla utgående data. Detta används av många slutpunkter för att skicka en API-nyckel.

Om slutpunkten kräver att du anger andra miljövariabler måste du även lägga till dem i programinställningarna. Mer information finns i dokumentationen för KONFIGURATION av OTLP-exporterare.

Du bör ta bort inställningen APPLICATIONINSIGHTS_CONNECTION_STRING , såvida du inte också vill att OpenTelemetry-utdata från värden ska skickas till Application Insights.

3. Aktivera OpenTelemetry i din app

Med Functions-värden konfigurerad för att använda OpenTelemetry bör du även uppdatera programkoden för att mata ut OpenTelemetry-data. Genom att aktivera OpenTelemetry i både värden och programkoden kan du bättre korrelation mellan spårningar och loggar som genereras både av Functions-värdprocessen och från språkarbetareprocessen.

Hur du instrumentera ditt program för att använda OpenTelemetry beror på målslutpunkten för OpenTelemetry:

1. Kör dessa kommandon för att installera de nödvändiga sammansättningarna i din app:

   Application Insights

   dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry --version 1.0.0-preview1 
   dotnet add package OpenTelemetry.Extensions.Hosting 
   dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore  
   

   OTLP-exportör

   dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry --version 1.0.0-preview1 
   dotnet add package OpenTelemetry.Extensions.Hosting 
   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol   
   

2. Lägg till den här using instruktionen i din Program.cs projektfil:

   Application Insights

   using Azure.Monitor.OpenTelemetry.AspNetCore; 
   

   OTLP-exportör

   using OpenTelemetry; 
   

3. Lägg till den här tjänstkonfigurationen i ombudet ConfigureServices :

   Application Insights

   services.AddOpenTelemetry()
   .UseFunctionsWorkerDefaults()
   .UseAzureMonitor();
   

   OTLP-exportör

   services.AddOpenTelemetry()
   .UseFunctionsWorkerDefaults()
   .UseOtlpExporter();
   

   Om du vill exportera till båda OpenTelemetry-slutpunkterna anropar du både UseAzureMonitor och UseOtlpExporter.

Java Worker-optimeringar är ännu inte tillgängliga för OpenTelemetry, så det finns inget att konfigurera i Java-koden.

1. Installera dessa npm-paket i projektet:

   Application Insights

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

   OTLP-exportör

   npm install @opentelemetry/api 
   npm install @opentelemetry/auto-instrumentations-node 
   npm install @opentelemetry/exporter-logs-otlp-http 
   npm install @azure/functions-opentelemetry-instrumentation
   

1. Skapa en kodfil i projektet, kopiera och klistra in följande kod i den nya filen och spara filen som src/index.js:

   Application Insights

   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()],
   });
   

   OTLP-exportör

   const { AzureFunctionsInstrumentation } = require('@azure/functions-opentelemetry-instrumentation');
   const { getNodeAutoInstrumentations, getResourceDetectors } = require('@opentelemetry/auto-instrumentations-node');
   const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http');
   const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
   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 OTLPTraceExporter()));
   tracerProvider.register();
   
   const loggerProvider = new LoggerProvider({ resource });
   loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new OTLPLogExporter()));
   
   registerInstrumentations({
       tracerProvider,
       loggerProvider,
       instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
   });
   

2. Uppdatera fältet main i din package.json-fil så att den innehåller den här nya src/index.js filen, vilket kan se ut så här:

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

1. Skapa en kodfil i projektet, kopiera och klistra in följande kod i den nya filen och spara filen som src/index.ts:

   Application Insights

   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()],
   });
   

   OTLP-exportör

   import { AzureFunctionsInstrumentation } from '@azure/functions-opentelemetry-instrumentation';
   import { getNodeAutoInstrumentations, getResourceDetectors } from '@opentelemetry/auto-instrumentations-node';
   import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
   import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
   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 OTLPTraceExporter()));
   tracerProvider.register();
   
   const loggerProvider = new LoggerProvider({ resource });
   loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(new OTLPLogExporter()));
   
   registerInstrumentations({
       tracerProvider,
       loggerProvider,
       instrumentations: [getNodeAutoInstrumentations(), new AzureFunctionsInstrumentation()],
   });
   

2. Uppdatera fältet main i package.json-filen så att det innehåller utdata från den nya src/index.ts filen, vilket kan se ut så här:

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

Viktigt!

OpenTelemetry-utdata till Application Insights från språkarbetaren stöds för närvarande inte för PowerShell-appar. Du kanske i stället vill använda en SLUTpunkt för OTLP-exportören. När värden har konfigurerats för OpenTelemetry-utdata till Application Insights vidarebefordras loggarna som genereras av PowerShell-arbetsprocessen fortfarande, men distribuerad spårning stöds inte just nu.

Dessa instruktioner gäller endast för en OTLP-exportör:

1. Lägg till en programinställning med namnet OTEL_FUNCTIONS_WORKER_ENABLED med värdet True.

2. Skapa en mapp på appnivå Modules i appens rot och kör följande kommando:

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

   Detta installerar den nödvändiga AzureFunctions.PowerShell.OpenTelemetry.SDK modulen direkt i din app. Du kan inte använda requirements.psd1 filen för att installera det här beroendet automatiskt eftersom hanterade beroenden för närvarande inte stöds i förhandsversionen av Flex Consumption-planen .

3. Lägg till den här koden i filen profile.ps1:

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

1. Lägg till den här posten i requirements.txt filen:

   Application Insights

   azure.monitor.opentelemetry
   

   OTLP-exportör

   opentelemetry-api
   opentelemetry-sdk
   opentelemetry-exporter-otlp
   opentelemetry-instrumentation-logging
   

2. Lägg till den här koden i huvudinmatningspunktens function_app.py fil:

   Application Insights

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

   OTLP-exportör

   Spårningar, mått och loggar som exporteras med OpenTelemetry måste konfigureras manuellt. Mer information finns i Instrumentation för Python.

   Det här är en enkel implementering för att exportera loggar:

   logging.basicConfig(level=logging.DEBUG)
   
   from opentelemetry import _logs
   from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
   from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
   from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
   
   # Initialize logging and an exporter that can send data to an OTLP endpoint by attaching OTLP handler to root logger
   # SELECT * FROM Log WHERE instrumentation.provider='opentelemetry'
   _logs.set_logger_provider(
       LoggerProvider(resource=Resource.create(OTEL_RESOURCE_ATTRIBUTES))
   )
   logging.getLogger().addHandler(
       LoggingHandler(
           logger_provider=_logs.get_logger_provider().add_log_record_processor(
               BatchLogRecordProcessor(OTLPLogExporter())
           )
       )
   )
   
   

   Granska OpenTelemetry Logging SDK för att lära dig hur du använder OpenTelemetry-komponenter för att samla in loggar.

Överväganden för OpenTelemetry

När du exporterar dina data med OpenTelemetry bör du tänka på dessa aktuella överväganden.

• När värden har konfigurerats för att använda OpenTelemetry exporteras endast loggar och spårningar. Värdmått exporteras för närvarande inte.

• Du kan för närvarande inte köra ditt appprojekt lokalt med Core Tools när du har OpenTelemetry aktiverat på värden. För närvarande måste du distribuera koden till Azure för att verifiera dina OpenTelemetry-relaterade uppdateringar.

• För närvarande stöds endast HTTP-utlösare och Azure SDK-baserade utlösare med OpenTelemetry-utdata.

Relaterat innehåll

Övervaka En Flex-förbrukningsplan för Azure Functions