Używanie biblioteki OpenTelemetry z usługą Azure Functions

Ważne

Obsługa technologii OpenTelemetry dla usługi Azure Functions jest obecnie dostępna w wersji zapoznawczej, a aplikacja musi być hostowana w planie Flex Consumption, aby korzystać z technologii OpenTelemetry.

W tym artykule pokazano, jak skonfigurować aplikację funkcji do eksportowania danych dziennika i śledzenia w formacie OpenTelemetry. Usługa Azure Functions generuje dane telemetryczne dotyczące wykonań funkcji zarówno z procesu hosta usługi Functions, jak i procesu roboczego specyficznego dla języka, w którym jest uruchamiany kod funkcji. Domyślnie te dane telemetryczne są wysyłane do usługi Application Szczegółowe informacje przy użyciu zestawu SDK usługi Application Szczegółowe informacje. Można jednak wyeksportować te dane przy użyciu semantyki OpenTelemetry. Mimo że nadal można użyć formatu OpenTelemetry do wysyłania danych do usługi Application Szczegółowe informacje, możesz teraz również wyeksportować te same dane do dowolnego innego punktu końcowego zgodnego z biblioteką OpenTelemetry.

Napiwek

Ponieważ ten artykuł jest przeznaczony dla wybranego języka programowania, pamiętaj, aby wybrać poprawny język w górnej części artykułu.

Obecnie nie ma zoptymalizowanej pod kątem klienta obsługi technologii OpenTelemetry dla aplikacji Java.

Funkcja OpenTelemetry nie jest obecnie obsługiwana w przypadku aplikacji przetwarzania w języku C#.

Te korzyści można uzyskać, włączając funkcję OpenTelemetry w aplikacji funkcji:

• Korelacja między śladami i dziennikami generowanymi zarówno na hoście, jak i w kodzie aplikacji.
• Spójne, oparte na standardach generowanie eksportowalnych danych telemetrycznych.
• Integruje się z innymi dostawcami, którzy mogą korzystać z danych zgodnych ze standardem OpenTeleletry.

Funkcja OpenTelemetry jest włączona na poziomie aplikacji funkcji zarówno w konfiguracji hosta (host.json), jak i w projekcie kodu. Usługa Functions zapewnia również zoptymalizowane pod kątem klienta środowisko eksportowania danych OpenTelemetry z kodu funkcji działającego w procesie roboczym specyficznym dla języka.

1. Włączanie funkcji OpenTelemetry na hoście usługi Functions

Po włączeniu danych wyjściowych openTelemetry w pliku host.json aplikacji funkcji host eksportuje dane wyjściowe openTelemetry niezależnie od stosu języka używanego przez aplikację.

Aby włączyć dane wyjściowe openTelemetry z hosta usługi Functions, zaktualizuj plik host.json w projekcie kodu, aby dodać "telemetryMode": "openTelemetry" element do kolekcji głównej. Po włączeniu funkcji OpenTelemetry plik host.json może wyglądać następująco:

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

2. Konfigurowanie ustawień aplikacji

Po włączeniu funkcji OpenTelemetry w pliku host.json punkty końcowe, do których są wysyłane dane, są określane na podstawie ustawień aplikacji obsługiwanych przez bibliotekę OpenTelemetry są dostępne w zmiennych środowiskowych aplikacji.

Utwórz określone ustawienia aplikacji w aplikacji funkcji na podstawie miejsca docelowego danych wyjściowych OpenTelemetry. Gdy dla obu punktów końcowych są udostępniane ustawienia połączenia zarówno dla Szczegółowe informacje aplikacji, jak i eksportera protokołu OpenTelemetry (OTLP).

Application Insights

APPLICATIONINSIGHTS_CONNECTION_STRING: parametry połączenia obszaru roboczego Szczegółowe informacje aplikacji. Jeśli to ustawienie istnieje, dane OpenTelemetry są wysyłane do tego obszaru roboczego. To ustawienie jest takie samo, jak używane do nawiązywania połączenia z aplikacją Szczegółowe informacje bez włączonej funkcji OpenTelemetry. Jeśli aplikacja nie ma jeszcze tego ustawienia, może być konieczne włączenie integracji Szczegółowe informacje aplikacji.

Eksporter OTLP

OTEL_EXPORTER_OTLP_ENDPOINT: adres URL punktu końcowego eksportera OTLP.

OTEL_EXPORTER_OTLP_HEADERS: (Opcjonalnie) lista nagłówków, które mają być stosowane do wszystkich danych wychodzących. Jest to używane przez wiele punktów końcowych do przekazania klucza interfejsu API.

Jeśli punkt końcowy wymaga ustawienia innych zmiennych środowiskowych, należy je również dodać do ustawień aplikacji. Aby uzyskać więcej informacji, zobacz dokumentację DOTYCZĄCĄ konfiguracji eksportera OTLP.

Należy usunąć APPLICATIONINSIGHTS_CONNECTION_STRING to ustawienie, chyba że chcesz również wyświetlić dane wyjściowe OpenTelemetry z hosta wysłanego do aplikacji Szczegółowe informacje.

3. Włączanie funkcji OpenTelemetry w aplikacji

Po skonfigurowaniu hosta usługi Functions do używania funkcji OpenTelemetry należy również zaktualizować kod aplikacji w celu wyprowadzenia danych openTelemetrii. Włączenie biblioteki OpenTelemetry zarówno na hoście, jak i kodzie aplikacji umożliwia lepszą korelację między śladami i dziennikami emitowanych zarówno przez proces hosta usługi Functions, jak i z procesu roboczego języka.

Sposób instrumentowania aplikacji do używania metody OpenTelemetry zależy od docelowego punktu końcowego openTelemetry:

1. Uruchom następujące polecenia, aby zainstalować wymagane zestawy w aplikacji:

   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  
   

   Eksporter OTLP

   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. W pliku projektu Program.cs dodaj następującą using instrukcję:

   Application Insights

   using Azure.Monitor.OpenTelemetry.AspNetCore; 
   

   Eksporter OTLP

   using OpenTelemetry; 
   

3. W delegacie ConfigureServices dodaj tę konfigurację usługi:

   Application Insights

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

   Eksporter OTLP

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

   Aby wyeksportować do obu punktów końcowych OpenTelemetry, wywołaj metodę i UseAzureMonitor UseOtlpExporter.

Optymalizacje procesów roboczych Języka Java nie są jeszcze dostępne dla biblioteki OpenTelemetry, więc nie ma nic do skonfigurowania w kodzie Java.

1. Zainstaluj następujące pakiety npm w projekcie:

   Application Insights

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

   Eksporter OTLP

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

1. Utwórz plik kodu w projekcie, skopiuj i wklej następujący kod w tym nowym pliku, a następnie zapisz plik jako 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()],
   });
   

   Eksporter OTLP

   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. main Zaktualizuj pole w pliku package.json, aby uwzględnić ten nowy src/index.js plik, co może wyglądać następująco:

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

1. Utwórz plik kodu w projekcie, skopiuj i wklej następujący kod w tym nowym pliku, a następnie zapisz plik jako 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()],
   });
   

   Eksporter OTLP

   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. main Zaktualizuj pole w pliku package.json, aby uwzględnić dane wyjściowe tego nowego src/index.ts pliku, co może wyglądać następująco:

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

Ważne

Dane wyjściowe openTelemetry do aplikacji Szczegółowe informacje z procesu roboczego języka nie są obecnie obsługiwane w przypadku aplikacji programu PowerShell. Zamiast tego warto użyć punktu końcowego eksportera OTLP. Po skonfigurowaniu hosta dla danych wyjściowych openTelemetry do usługi Application Szczegółowe informacje dzienniki generowane przez proces roboczy programu PowerShell są nadal przekazywane, ale śledzenie rozproszone nie jest obecnie obsługiwane.

Te instrukcje dotyczą tylko eksportera OTLP:

1. Dodaj ustawienie aplikacji o nazwie OTEL_FUNCTIONS_WORKER_ENABLED z wartością True.

2. Utwórz folder na poziomie Modules aplikacji w katalogu głównym aplikacji i uruchom następujące polecenie:

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

   Spowoduje to zainstalowanie wymaganego AzureFunctions.PowerShell.OpenTelemetry.SDK modułu bezpośrednio w aplikacji. Nie można użyć requirements.psd1 pliku do automatycznego zainstalowania tej zależności, ponieważ zależności zarządzane nie są obecnie obsługiwane w wersji zapoznawczej planu Flex Consumption.

3. Dodaj ten kod do pliku profile.ps1:

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

1. Dodaj ten wpis w requirements.txt pliku:

   Application Insights

   azure.monitor.opentelemetry
   

   Eksporter OTLP

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

2. Dodaj ten kod do function_app.py głównego pliku punktu wejścia:

   Application Insights

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

   Eksporter OTLP

   Ślady, metryki i dzienniki eksportowane przy użyciu biblioteki OpenTelemetry muszą być konfigurowane ręcznie. Aby uzyskać więcej informacji, zobacz Instrumentacja dla języka Python.

   Jest to prosta implementacja eksportowania dzienników:

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

   Zapoznaj się z zestawem OPENTelemetry Logging SDK , aby dowiedzieć się, jak zbierać dzienniki przy użyciu składników OpenTelemetry.

Zagadnienia dotyczące platformy OpenTelemetry

Podczas eksportowania danych przy użyciu biblioteki OpenTelemetry należy pamiętać o tych bieżących kwestiach.

• Gdy host jest skonfigurowany do używania funkcji OpenTelemetry, eksportowane są tylko dzienniki i ślady. Metryki hosta nie są obecnie eksportowane.

• Obecnie nie można uruchomić projektu aplikacji lokalnie przy użyciu narzędzi Core Tools, jeśli na hoście jest włączona funkcja OpenTelemetry. Obecnie musisz wdrożyć kod na platformie Azure, aby zweryfikować aktualizacje związane z biblioteką OpenTelemetry.

• Obecnie tylko wyzwalacze HTTP i wyzwalacze oparte na zestawie AZURE SDK są obsługiwane z danymi wyjściowymi biblioteki OpenTelemetry.

Powiązana zawartość

Monitorowanie planu Flex Consumption usługi Azure Functions