Verwenden von OpenTelemetry mit Azure Functions

In diesem Artikel erfahren Sie, wie Sie Ihre Funktions-App so konfigurieren, dass Protokoll- und Ablaufverfolgungsdaten in einem OpenTelemetry-Format exportiert werden. Azure Functions generiert Telemetriedaten zu Ihren Funktionsausführungen sowohl aus dem Functions-Hostprozess als auch aus dem sprachspezifischen Arbeitsprozess, in dem Ihr Funktionscode ausgeführt wird. Standardmäßig werden diese Telemetriedaten mithilfe des Application Insights SDK an Application Insights gesendet. Sie können diese Daten jedoch mithilfe der OpenTelemetry-Semantik exportieren. Sie können zwar weiterhin ein OpenTelemetry-Format verwenden, um Ihre Daten an Application Insights zu senden, aber Sie können jetzt auch dieselben Daten in einen anderen mit OpenTelemetry kompatiblen Endpunkt exportieren.

Sie können diese Vorteile erhalten, indem Sie OpenTelemetry in Ihrer Funktions-App aktivieren:

• Korreliert Daten über Ablaufverfolgungen und Protokolle hinweg, die sowohl auf dem Host als auch im Anwendungscode generiert werden.
• Ermöglicht eine konsistente, standardsbasierte Generierung von exportierbaren Telemetriedaten.
• Integriert sich in andere Anbieter, die mit OpenTelemetry kompatible Daten nutzen können.

Beachten Sie bei der Verwendung dieses Artikels die folgenden Überlegungen:

• Probieren Sie das Lernprogramm "OpenTelemetry" aus, das Ihnen helfen soll, schnell mit OpenTelemetry und Azure Functions zu beginnen. In diesem Artikel wird die Azure Developer CLI (azd) verwendet, um eine Funktions-App zu erstellen und bereitzustellen, die die OpenTelemetry-Integration für verteiltes Tracing verwendet.

• Da sich dieser Artikel auf ihre Entwicklungssprache bezieht, denken Sie daran, am Anfang des Artikels die richtige Sprache auszuwählen.

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

• OpenTelemetry ist auf Funktions-App-Ebene aktiviert, sowohl in der Hostkonfiguration (host.json) als auch im Codeprojekt. Funktionen bieten auch eine clientoptimierte Oberfläche zum Exportieren von OpenTelemetry-Daten aus Ihrem Funktionscode, der in einem sprachspezifischen Arbeitsprozess ausgeführt wird.

Aktivieren von OpenTelemetry im Functions-Host

Wenn Sie die OpenTelemetry-Ausgabe in der Datei der Funktions-App host.json aktivieren, exportiert Ihr Host die OpenTelemetry-Ausgabe unabhängig vom von Ihrer App verwendeten Sprachstapel.

Um die OpenTelemetry-Ausgabe vom Funktionshost zu aktivieren, aktualisieren Sie die host.json Datei in Ihrem Codeprojekt, um der Stammauflistung ein "telemetryMode": "OpenTelemetry"-Element hinzuzufügen. Wenn OpenTelemetry aktiviert ist, sieht ihre host.json Datei möglicherweise wie folgt aus:

{
    "version": "2.0",
    "telemetryMode": "OpenTelemetry",
    ...
}

Konfigurieren von Anwendungseinstellungen

Wenn Sie OpenTelemetry in der host.json Datei aktivieren, bestimmen die Umgebungsvariablen der App die Endpunkte zum Senden von Daten, basierend auf denen openTelemetry-unterstützte Anwendungseinstellungen verfügbar sind.

Erstellen Sie bestimmte Anwendungseinstellungen in Ihrer Funktions-App basierend auf dem OpenTelemetry-Ausgabeziel. Wenn Sie Verbindungseinstellungen für Application Insights und einen OTLP-Exporter (OpenTelemetry-Protokoll) bereitstellen, werden OpenTelemetry-Daten an beide Endpunkte gesendet.

Application Insights

APPLICATIONINSIGHTS_CONNECTION_STRING: Die Verbindungszeichenfolge für einen Application Insights-Arbeitsbereich. Wenn diese Einstellung vorhanden ist, werden OpenTelemetry-Daten an diesen Arbeitsbereich gesendet. Verwenden Sie dieselbe Einstellung, um eine Verbindung mit Application Insights herzustellen, ohne Dass OpenTelemetry aktiviert ist. Wenn Ihre App noch nicht über diese Einstellung verfügt, müssen Sie möglicherweise die Application Insights-Integration aktivieren.

JAVA_APPLICATIONINSIGHTS_ENABLE_TELEMETRY: Wird auf true festgelegt, damit der Funktionshost das direkte Streamen von OpenTelemetry-Protokollen durch den Java-Arbeitsprozess ermöglicht, wodurch doppelte Einträge auf Hostebene verhindert werden.

PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY: Wird auf true festgelegt, damit der Functions-Host dem Python-Arbeitsprozess das direkte Streamen von OpenTelemetry-Protokollen ermöglicht, wodurch doppelte Einträge auf Hostebene verhindert werden.

OTLP-Exporter

Azure Functions unterstützt das Exportieren von OpenTelemetry-Daten in einen OTLP-kompatiblen Endpunkt. Die spezifischen Umgebungsvariablen, die Sie konfigurieren müssen, sind von Ihrem ausgewählten Observability-Anbieter (z. B. Datadog, New Relic, Grafana oder anderen) abhängig.

Die meisten Anbieter erfordern:

OTEL_EXPORTER_OTLP_ENDPOINT: die OTLP-Endpunkt-URL, die von Ihrem Observability-Anbieter bereitgestellt wird.

Viele Anbieter erfordern außerdem Folgendes:

OTEL_EXPORTER_OTLP_HEADERS: Header für Authentifizierungsdaten wie API-Schlüssel.

PYTHON_ENABLE_OPENTELEMETRY: Wird auf true festgelegt, damit der Functions-Host dem Python-Arbeitsprozess das direkte Streamen von OpenTelemetry-Protokollen ermöglicht, wodurch doppelte Einträge auf Hostebene verhindert werden.

Azure Functions unterstützt alle Umgebungsvariablen, die in der OpenTelemetry SDK-Konfigurationsdokumentation definiert sind. Die spezifischen Variablen und Werte, die erforderlich sind, variieren jedoch je nach Anbieter. Konsultieren Sie die Dokumentation Ihres Observability-Anbieters für:

• Erforderliche Endpunkt-URLs und Authentifizierungsmethoden
• Empfohlene Konfigurationseinstellungen
• Anbieterspezifische Umgebungsvariablen
• Alle zusätzlichen Setupschritte

Fügen Sie alle erforderlichen Umgebungsvariablen als Anwendungseinstellungen in Ihrer Funktions-App hinzu.

Entfernen Sie die APPLICATIONINSIGHTS_CONNECTION_STRING Einstellung, es sei denn, Sie möchten die OpenTelemetry-Ausgabe vom Host an Application Insights senden.

Aktivieren von OpenTelemetry in Ihrer App

Nachdem Sie den Funktionenhost für die Verwendung von OpenTelemetry konfiguriert haben, aktualisieren Sie den Anwendungscode so, dass OpenTelemetry-Daten ausgegeben werden. Wenn Sie OpenTelemetry sowohl im Host als auch im Anwendungscode aktivieren, erhalten Sie eine bessere Korrelation zwischen Ablaufverfolgungen und Protokollen, die der Funktionenhostprozess und der Spracharbeitsprozess ausgeben.

Wie Sie Ihre Anwendung zur Verwendung von OpenTelemetry instrumentieren, hängt von Ihrem Ziel-OpenTelemetry-Endpunkt ab:

Beispiele in diesem Artikel gehen davon aus, dass Ihre App IHostApplicationBuilder verwendet, das in Version 2.x und höher von Microsoft.Azure.Functions.Worker verfügbar ist. 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:

   Application Insights

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

   OTLP-Exporter

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

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

   Application Insights

   using Azure.Monitor.OpenTelemetry.Exporter; 
   

   OTLP-Exporter

   using OpenTelemetry; 
   

3. Konfigurieren Sie OpenTelemetry, je nachdem, ob Ihr Projektstart IHostBuilder oder IHostApplicationBuilder verwendet. Letzteres wurde in Version 2.x der .NET-Erweiterung für isoliertes Workermodell eingeführt.

   IHostApplicationBuilder

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

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

   IHostBuilder

   Fügen Sie in program.cs diesen ConfigureServices-Anruf Ihrer HostBuilder-Pipeline hinzu:

   .ConfigureServices(s =>
   {
       s.AddOpenTelemetry()
       .UseFunctionsWorkerDefaults()
       .UseAzureMonitorExporter();
   })
   

   IHostApplicationBuilder

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

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

   IHostBuilder

   Fügen Sie in program.cs diesen ConfigureServices-Anruf Ihrer HostBuilder-Pipeline hinzu:

   .ConfigureServices(s =>
   {
       s.AddOpenTelemetry()
       .UseFunctionsWorkerDefaults()
       .UseOtlpExporter();
   })
   

   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

   <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>
   

   Kotlin

   implementation("com.microsoft.azure.functions:azure-functions-java-opentelemetry:1.0.0")
   implementation("com.azure:azure-monitor-opentelemetry-autoconfigure:1.2.0")
   

   Maven

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

   Kotlin

   implementation("com.microsoft.azure.functions:azure-functions-java-opentelemetry:1.0.0")
   

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:

   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-Exporter

   npm install @opentelemetry/api 
   npm install @opentelemetry/auto-instrumentations-node 
   npm install @opentelemetry/exporter-logs-otlp-http 
   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:

   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-Exporter

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

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:

   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-Exporter

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

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}"
   

Wichtig

Die OpenTelemetry-Ausgabe für Application Insights vom Sprachworker wird für PowerShell-Apps derzeit nicht unterstützt. Sie sollten vielleicht stattdessen einen OTLP-Exporter-Endpunkt verwenden. Wenn Sie Ihren Host für die OpenTelemetry-Ausgabe in Application Insights konfigurieren, werden die vom PowerShell-Arbeitsprozess generierten Protokolle weiterhin weitergeleitet, die verteilte Ablaufverfolgung wird derzeit jedoch nicht unterstützt.

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:

   Application Insights

   azure-monitor-opentelemetry
   

   OTLP-Exporter

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

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

   Application Insights

   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() 
   

   OTLP-Exporter

   Sie müssen das Exportieren von Ablaufverfolgungen, Metriken und Protokollen mithilfe von OpenTelemetry manuell konfigurieren. Weitere Informationen finden Sie unter Instrumentierung für Python.

   Dieses Beispiel zeigt eine einfache Implementierung zum Exportieren von Protokollen:

   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())
           )
       )
   )
   
   

   Informationen zum Verwenden von OpenTelemetry-Komponenten zum Sammeln von Protokollen finden Sie im OpenTelemetry Logging SDK.

3. Überprüfen Sie die Dokumentation zur Verwendung von Verteilungen in Azure Monitor, um Optionen zur weiteren Konfiguration des SDK zu finden.

Überlegungen zu OpenTelemetry

Wenn Sie Ihre Daten mithilfe von OpenTelemetry exportieren, sollten Sie diese Überlegungen berücksichtigen.

• Das Azure-Portal unterstützt Recent function invocation Ablaufverfolgungen nur, wenn die Telemetrie an Azure Monitor gesendet wird.

• Wenn Sie den Host für die Verwendung von OpenTelemetry konfigurieren, unterstützt das Azure-Portal das Protokollstreaming nicht.

• Wenn Sie telemetryMode auf OpenTelemetry setzen, gilt die Konfiguration im Abschnitt logging.applicationInsights der host.json nicht.

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

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

• Verwenden Sie diese Java Virtual Machine (JVM)-Flags, um Telemetrie stumm zu lassen, wenn sie während Komponententests 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 ermittelt OpenTelemetryInvocationMiddleware automatisch.

Problembehandlung

Wenn Sie Ihre Daten mithilfe von OpenTelemetry exportieren, sollten Sie diese häufig auftretenden Probleme und Lösungen berücksichtigen.

Protokollfilterung

Um die Protokollfilterung in Ihrer Funktions-App ordnungsgemäß zu konfigurieren, müssen Sie den Unterschied zwischen dem Hostprozess und dem Arbeitsprozess verstehen.

Der Hostprozess ist die Azure Functions-Laufzeit, mit der Trigger, Skalierung und Telemetrie auf Systemebene verwaltet werden, z. B. Initialisierungsprotokolle, Anforderungsablaufverfolgungen und Laufzeitintegritätsinformationen.

Der Arbeitsprozess ist sprachspezifisch, führt Ihren Funktionscode aus und erzeugt Anwendungsprotokolle und Telemetrie unabhängig voneinander.

Wichtig

Filter, die in host.json definiert sind, gelten nur für Log-Dateien, die vom Hostprozess generiert werden. Sie müssen sprachspezifische OpenTelemetry-Einstellungen verwenden, um Protokolle aus dem Arbeitsprozess zu filtern.

Beispiel: Filtern von Hostprotokollen für alle Anbieter in host.json

Verwenden Sie diesen Ansatz, um eine globale Protokollebene für alle vom Host verwalteten Anbieter festzulegen:

{
  "version": "2.0",
  "telemetryMode": "OpenTelemetry",
  "logging": {
    "logLevel": {
      "default": "Warning"
    }
  }
}

Beispiel: Filterprotokolle nur für den OpenTelemetry-Loggeranbieter

Verwenden Sie diesen Ansatz, um nur auf den OpenTelemetry-Loggeranbieter zu abzielen, während andere Anbieter (z. B. Konsolen- oder Dateiprotokollierung) nicht betroffen sind:

{
  "version": "2.0",
  "telemetryMode": "OpenTelemetry",
  "logging": {
    "OpenTelemetry": {
      "logLevel": {
        "default": "Warning"
      }
    }
  }
}

Konsolenprotokollierung

Der Funktionshost erfasst automatisch alles, was in Stdout oder Stderr geschrieben wurde, und leitet es an die Telemetriepipeline weiter. Wenn Sie auch einen ConsoleExporter verwenden oder direkt in die Konsole in Ihrem Code schreiben, können doppelte Protokolle in Ihren Telemetriedaten auftreten.

Hinweis

Fügen Sie „ConsoleExporter“ nicht hinzu, oder schreiben in die Konsole im Produktionscode, um doppelte Telemetrie zu vermeiden.

Microsoft Entra-Authentifizierung

Wenn Sie die Microsoft Entra-Authentifizierung mit OpenTelemetry verwenden, müssen Sie die Authentifizierung sowohl für den Hostprozess als auch für den Arbeitsprozess separat konfigurieren.

Informationen zum Konfigurieren der Authentifizierung für den Hostprozess finden Sie unter "Anfordern der Microsoft Entra-Authentifizierung".

Informationen zum Konfigurieren der Authentifizierung für den Arbeitsprozess finden Sie unter Aktivieren der Microsoft Entra-Authentifizierung.

Unterstützung von Ressourcenattributen

Die Unterstützung für Ressourcenattribute in Azure Monitor befindet sich momentan in der Vorschauphase. Um dieses Feature zu aktivieren, legen Sie die OTEL_DOTNET_AZURE_MONITOR_ENABLE_RESOURCE_METRICS Umgebungsvariable auf true. Diese Einstellung nimmt Ressourcenattribute in die benutzerdefinierte Metriktabelle ein.

Telemetrie für doppelte Anfragen

Der Hostprozess sendet automatisch die Anfrage-Telemetrie. Wenn der Arbeitsprozess auch mit Anforderungsverfolgungsbibliotheken (z. B. AspNetCoreInstrumentation in .NET) instrumentiert wird, wird dieselbe Anforderung zweimal gemeldet.

Hinweis

Da die Azure Monitor-Distro in der Regel AspNetCoreInstrumentation in .NET und ähnliche Instrumentierung in anderen Sprachen enthält, vermeiden Sie die Verwendung der Azure Monitor-Distro im Arbeitsprozess, um doppelte Telemetrie zu verhindern.

Nicht enthaltene Protokollierungsbereiche

Standardmäßig enthält der Arbeitsprozess keine Geltungsbereiche in seinen Protokollen. Um Scopes zu aktivieren, müssen Sie diese Einstellung explizit im Worker konfigurieren. Das folgende Beispiel zeigt, wie Bereiche in .NET Isolated aktiviert werden:

builder.Logging.AddOpenTelemetry(b => b.IncludeScopes = true);

Fehlende Anforderungstelemetrie

Trigger wie HTTP, Service Bus und Event Hubs hängen von der Kontextverteilung für die verteilte Ablaufverfolgung ab. Bei einem übergeordneten Sampling als Standardverhalten wird die Telemetrieanforderung nicht generiert, wenn die eingehende Anforderung oder Nachricht nicht abgetastet wird.

Doppelte Operations-ID

In Azure Functions kommt der OperationId, der zur Korrelation von Telemetrie verwendet wird, direkt aus dem traceparent-Wert in der eingehenden Anforderung oder Nachricht. Wenn mehrere Aufrufe denselben traceparent Wert wiederverwenden, erhalten sie alle denselben OperationId.

Konfigurieren von OpenTelemetry mit Umgebungsvariablen

Sie können das OpenTelemetry-Verhalten mithilfe der Standardumgebungsvariablen konfigurieren. Diese Variablen bieten eine konsistente Möglichkeit zum Steuern des Verhaltens in verschiedenen Sprachen und Laufzeiten. Sie können Samplingstrategien, Exportereinstellungen und Ressourcenattribute anpassen. Weitere Informationen zu unterstützten Umgebungsvariablen finden Sie in der OpenTelemetry-Dokumentation.

Verwenden Sie Diagnosetools, um Probleme bei der Überwachung zu beheben

Die Azure Functions-Diagnose im Azure-Portal ist eine nützliche Ressource zum Erkennen und Diagnostizieren potenzieller überwachungsbezogener Probleme.

So greifen Sie auf die Diagnose in Ihrer App zu:

1. Wechseln Sie im Azure-Portal zu Ihrer Funktions-App-Ressource.

2. Wählen Sie im linken Bereich Probleme diagnostizieren und beheben aus, und suchen Sie nach dem Workflow In der Funktions-App fehlt Telemetrie von Application Insights oder OpenTelemetry.

3. Wählen Sie diesen Workflow aus, wählen Sie Ihre Aufnahmemethode und dann "Weiter" aus.

4. Überprüfen Sie die Richtlinien und Empfehlungen, die von der Problembehandlung bereitgestellt werden.

Nächste Schritte

Weitere Informationen zu OpenTelemetry und zur Überwachung von Azure Functions:

• Überwachen von Azure-Funktionen mit verteilter OpenTelemetry-Ablaufverfolgung
• Überwachen von Azure-Funktionen