Verwenden von OpenTelemetry mit Azure Functions

Wichtig

Die OpenTelemery-Unterstützung für Azure Functions befindet sich derzeit in der Vorschau, und Ihre App muss in einem Flex-Verbrauchsplan gehostet werden, um OpenTelemetry zu verwenden.

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.

Tipp

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

Derzeit gibt es keine clientoptimierte OpenTelemetry-Unterstützung für Java-Apps.

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

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

• Korrelation über Ablaufverfolgungen und Protokolle hinweg, die sowohl auf dem Host als auch im Anwendungscode generiert werden.
• Konsistente, standardsbasierte Generierung exportierter Telemetriedaten.
• Integriert sich in andere Anbieter, die mit OpenTeleletry kompatible Daten nutzen können.

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.

1. Aktivieren von OpenTelemetry im Functions-Host

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

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",
    "logging": {
        "applicationInsights": {
            "samplingSettings": {
                "isEnabled": true,
                "excludedTypes": "Request"
            },
            "enableLiveMetricsFilters": true
        }
    },
    "telemetryMode": "openTelemetry"
}

2. Konfigurieren von Anwendungseinstellungen

Wenn OpenTelemetry in der Datei host.json aktiviert ist, werden die Endpunkte, an die Daten gesendet werden, auf der Grundlage der von OpenTelemetry unterstützten Anwendungseinstellungen bestimmt, die in den Umgebungsvariablen Ihrer App verfügbar sind.

Erstellen Sie bestimmte Anwendungseinstellungen in Ihrer Funktions-App basierend auf dem OpenTelemetry-Ausgabeziel. Wenn Verbindungseinstellungen sowohl für Application Insights als auch für einen OTLP-Exporter (OpenTelemetry-Protokoll) bereitgestellt werden, 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. Diese Einstellung ist die gleiche, mit der Sie eine Verbindung zu Application Insights herstellen, 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.

OTLP-Exporter

OTEL_EXPORTER_OTLP_ENDPOINT: eine OTLP-Exporterendpunkt-URL.

OTEL_EXPORTER_OTLP_HEADERS: (Optional) Liste der Header, die auf alle ausgehenden Daten angewendet werden sollen. Dies wird von vielen Endpunkten verwendet, um einen API-Schlüssel zu übergeben.

Wenn Ihr Endpunkt erfordert, dass Sie andere Umgebungsvariablen festlegen, müssen Sie sie auch zu Ihren Anwendungseinstellungen hinzufügen. Weitere Informationen finden Sie in der OTLP Exporter-Konfigurationsdokumentation.

Sie sollten die Einstellung APPLICATIONINSIGHTS_CONNECTION_STRING entfernen, es sei denn, Sie möchten auch die OpenTelemetry-Ausgabe vom Host, der an Application Insights gesendet wird.

3. Aktivieren von OpenTelemetry in Ihrer App

Wenn der Functions-Host für die Verwendung von OpenTelemetry konfiguriert ist, sollten Sie den Anwendungscode auch so aktualisieren, dass OpenTelemetry-Daten ausgegeben werden. Das Aktivieren von OpenTelemetry sowohl im Host als auch im Anwendungscode ermöglicht eine bessere Korrelation zwischen Ablaufverfolgungen und Protokollen, die sowohl vom Hostprozess der Funktionen als auch vom Spracharbeitsprozess ausgegeben werden.

Die Art und Weise, wie Sie Ihre Anwendung zur Verwendung von OpenTelemetry instrumentieren, hängt vom OpenTelemetry-Zielendpunkt ab:

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 --version 1.0.0-preview1 
   dotnet add package OpenTelemetry.Extensions.Hosting 
   dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore  
   

   OTLP-Exporter

   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. Fügen Sie in Ihrer Program.cs-Projektdatei diese using-Anweisung hinzu:

   Application Insights

   using Azure.Monitor.OpenTelemetry.AspNetCore; 
   

   OTLP-Exporter

   using OpenTelemetry; 
   

3. Fügen Sie im Delegat ConfigureServices diese Dienstkonfiguration hinzu:

   Application Insights

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

   OTLP-Exporter

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

   Zum Exportieren in beide OpenTelemetry-Endpunkte rufen Sie sowohl UseAzureMonitor als auch UseOtlpExporter auf.

Java-Workeroptimierungen sind für OpenTelemetry noch nicht verfügbar, daher gibt es in Ihrem Java-Code nichts zu konfigurieren.

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
   

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

2. Aktualisieren Sie das Feld main in Ihrer package.json Datei, um diese neue Datei src/index.js einzuschließen, die wie folgt aussehen kann:

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

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

2. 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 Ihr Host für die OpenTelemetry-Ausgabe in Application Insights konfiguriert ist, werden die vom PowerShell-Workerprozess 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
   

   Dadurch 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. Fügen Sie diesen Eintrag in Ihrer requirements.txt-Datei hinzu:

   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

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

   OTLP-Exporter

   Ablaufverfolgungen, Metriken und Protokolle, die mithilfe von OpenTelemetry exportiert werden, müssen manuell konfiguriert werden. Weitere Informationen finden Sie unter Instrumentierung für Python.

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

   Sehen Sie sich das OpenTelemetry Logging SDK an, um zu erfahren, wie Sie OpenTelemetry-Komponenten zum Sammeln von Protokollen verwenden.

Überlegungen zu OpenTelemetry

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

• Wenn der Host für die Verwendung von OpenTelemetry konfiguriert ist, werden nur Protokolle und Ablaufverfolgungen exportiert. Hostmetriken werden derzeit nicht exportiert.

• Sie können Ihr App-Projekt derzeit nicht lokal mit Core Tools ausführen, wenn OpenTelemetry im Host aktiviert ist. Sie müssen Ihren Code derzeit in Azure bereitstellen, um Ihre OpenTelemetry-bezogenen Updates zu überprüfen.

• Derzeit werden nur HTTP-Trigger und Azure SDK-basierte Trigger mit OpenTelemetry-Ausgaben unterstützt.

Zugehöriger Inhalt

Überwachen von Azure FunctionsFlex-Verbrauchsplan