Verwenden von OpenTelemetry mit Azure Functions

• OpenTelemetry wird derzeit für C#-In-Process-Apps nicht unterstützt.

Beispiele in diesem Artikel gehen davon aus, dass Ihre App IHostApplicationBuilder verwendet, das in Version 2.x und höher in Microsoft.Azure verfügbar ist. Functions.Worker. Weitere Informationen finden Sie unter Version 2.x im C#-Handbuch für isolierte Arbeitsmodelle.

1. Führen Sie die folgenden Befehle aus, um die erforderlichen Assemblys in Ihrer App zu installieren:

   • Anwendungsanalysen
   • OTLP-Exporter

   Hinweis

   Ab Version 3.0 nutzt das Microsoft.ApplicationInsights.WorkerService-Paket Azure Monitor Exporter. Sie können dieses Paket verwenden, um das vorhandene Anwendungseinblick-Konfigurationsverhalten bei der internen Verwendung der Azure Monitor-Pipeline zu verwalten, einschließlich des OpenTelemetry-Exporters. Sie können das Microsoft.ApplicationInsights.WorkerService-Paket (v3.0 oder höher) anstelle des Azure.Monitor.OpenTelemetry.Exporter-Pakets verwenden, das im folgenden Beispiel gezeigt wird.

   dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry
   dotnet add package OpenTelemetry.Extensions.Hosting 
   dotnet add package Azure.Monitor.OpenTelemetry.Exporter  
   

2. Fügen Sie in Ihrer Program.cs-Projektdatei diese using-Anweisung hinzu:

   • Anwendungsanalysen
   • OTLP-Exporter

   using Azure.Monitor.OpenTelemetry.Exporter; 
   

3. Konfigurieren Sie OpenTelemetry, je nachdem, ob Ihr Projektstart IHostBuilder oder IHostApplicationBuilder verwendet. Letzteres wurde in v2.x der .NET Erweiterung des isolierten Arbeitsmodells eingeführt.

   • IHostApplicationBuilder
   • IHostBuilder

   Fügen Sie in program.cs diese Codezeile nach ConfigureFunctionsWebApplication hinzu:

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

   Sie können beide OpenTelemetry-Endpunkte aus derselben App exportieren.

1. Fügen Sie Ihrer App die erforderlichen Bibliotheken hinzu. Die Art und Weise, wie Sie Bibliotheken hinzufügen, hängt davon ab, ob Sie Maven oder Kotlin verwenden und ob Sie auch Daten an Application Insights senden möchten.

   • 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. (Optional) Fügen Sie diesen Code hinzu, um benutzerdefinierte Bereiche zu erstellen:

   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. Installieren Sie diese npm-Pakete in Ihrem Projekt:

   • Anwendungsanalysen
   • 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. Erstellen Sie eine Codedatei in Ihrem Projekt, kopieren Sie den folgenden Code, fügen Sie ihn in diese neue Datei ein, und speichern Sie die Datei unter src/index.js:

   • Anwendungsanalysen
   • 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. Aktualisieren Sie das main Feld in Ihrer package.json-Datei, um die neue src/index.js Datei einzuschließen. Beispiel:

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

2. Erstellen Sie eine Codedatei in Ihrem Projekt, kopieren Sie den folgenden Code, fügen Sie ihn in diese neue Datei ein, und speichern Sie die Datei unter src/index.ts:

   • Anwendungsanalysen
   • 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. Aktualisieren Sie das Feld main in Ihrer package.json-Datei, um die Ausgabe dieser neuen src/index.ts-Datei einzuschließen, die wie folgt aussehen kann:

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

Diese Anweisungen gelten nur für einen OTLP-Exporter:

1. Fügen Sie eine Anwendungseinstellung mit dem Namen OTEL_FUNCTIONS_WORKER_ENABLED mit einem Wert von True hinzu.

2. Erstellen Sie einen App-Ebene Modules Ordner im Stammverzeichnis Ihrer App, und führen Sie den folgenden Befehl aus:

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

   Mit diesem Befehl wird das erforderliche AzureFunctions.PowerShell.OpenTelemetry.SDK Modul direkt in Ihrer App installiert. Sie können die Datei requirements.psd1 nicht verwenden, um diese Abhängigkeit automatisch zu installieren, da verwaltete Abhängigkeiten derzeit in der Vorschau des Flex-Verbrauchsplans nicht unterstützt werden.

3. Fügen Sie diesen Code zur Datei „profile.ps1“ hinzu:

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

1. Stellen Sie sicher, dass sich diese Bibliotheken in Ihrer requirements.txt-Datei befinden, ganz gleich, ob Sie die Kommentare aufheben oder sich selbst hinzufügen:

   • Anwendungsanalysen
   • OTLP-Exporter

   azure-monitor-opentelemetry
   

2. Fügen Sie diesen Code zu Ihrer function_app.py Haupteinstiegspunktdatei hinzu:

   • Anwendungsanalysen
   • OTLP-Exporter

   Wenn Sie ihrer Anwendungseinstellungen bereits PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY=true hinzugefügt haben, können Sie diesen Schritt überspringen. Um die Application Insights-Auflistung ohne automatische Instrumentierung manuell zu aktivieren, fügen Sie Ihrer App diesen Code hinzu:

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

3. Lesen Sie die Dokumentation zu Azure Monitor Distro-Nutzung, um sich über Optionen zur weiteren Konfiguration des SDK zu informieren.

• Benutzerdefinierte Spans enthalten automatisch alle Ressourcenattribute und verwenden die in Ihrer App konfigurierten Exporter.

• Wenn Ihre App außerhalb Azure ausgeführt wird, einschließlich während der lokalen Entwicklung, legt der Ressourcendetektor standardmäßig das Attribut service.name auf java-function-app fest.

• Verwenden Sie diese Java Virtual Machine (JVM)-Flags, um Telemetrie zu unterdrücken, wenn sie während Unit-Tests lokal ausgeführt werden.

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

• Sie müssen Middleware nicht manuell registrieren; der Java Worker erkennt OpenTelemetryInvocationMiddleware automatisch.