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

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 Insights przy użyciu zestawu SDK usługi Application Insights. 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 Insights, możesz teraz również wyeksportować te same dane do dowolnego innego punktu końcowego zgodnego z biblioteką OpenTelemetry.

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

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

Podczas korzystania z tego artykułu należy pamiętać o następujących kwestiach:

• Wypróbuj samouczek OpenTelemetry, który został zaprojektowany, aby ułatwić szybkie rozpoczęcie pracy z usługami OpenTelemetry i Azure Functions. W tym artykule użyto interfejsu wiersza polecenia dla deweloperów platformy Azure (azd), aby utworzyć i wdrożyć aplikację funkcji korzystającą z integracji OpenTelemetry na potrzeby śledzenia rozproszonego.

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

• OpenTelemetry nie jest obecnie obsługiwane dla aplikacji C# działających w procesie.

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

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",
    "telemetryMode": "OpenTelemetry",
    ...
}

Konfigurowanie ustawień aplikacji

Po włączeniu OpenTelemetry w pliku host.json, zmienne środowiskowe aplikacji określają punkty końcowe wysyłania danych na podstawie dostępnych ustawień aplikacji, które są obsługiwane przez OpenTelemetry.

Utwórz określone ustawienia aplikacji w aplikacji funkcji na podstawie miejsca docelowego danych wyjściowych OpenTelemetry. Po podaniu ustawień połączenia zarówno dla usługi Application Insights, jak i eksportera protokołu OpenTelemetry (OTLP), dane OpenTelemetry są wysyłane do obu punktów końcowych.

Application Insights

APPLICATIONINSIGHTS_CONNECTION_STRING: parametry połączenia dla obszaru roboczego usługi Application Insights. Jeśli to ustawienie istnieje, dane OpenTelemetry są wysyłane do tego obszaru roboczego. Użyj tego samego ustawienia, aby nawiązać połączenie z usługą Application Insights bez włączonej funkcji OpenTelemetry. Jeśli aplikacja nie ma jeszcze tego ustawienia, może być konieczne włączenie integracji usługi Application Insights.

JAVA_APPLICATIONINSIGHTS_ENABLE_TELEMETRY: ustaw na true, aby host usługi Functions umożliwiał procesowi roboczemu Java przesyłanie strumieniowe dzienników OpenTelemetry bezpośrednio, co zapobiega duplikowaniu wpisów na poziomie hosta.

PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY: ustaw wartość na true tak, aby host usługi Functions umożliwiał procesowi roboczemu języka Python bezpośrednie przesyłanie strumieniowe dzienników OpenTelemetry, co zapobiega zduplikowanym wpisom na poziomie hosta.

Eksporter OTLP

Usługa Azure Functions obsługuje eksportowanie danych OpenTelemetry do dowolnego punktu końcowego zgodnego ze standardem OTLP. Określone zmienne środowiskowe, które należy skonfigurować, zależą od wybranego dostawcy obserwacji (np. Datadog, New Relic, Grafana lub inne).

Większość dostawców wymaga:

OTEL_EXPORTER_OTLP_ENDPOINT: adres URL punktu końcowego OTLP dostarczony przez dostawcę możliwości obserwacji.

Wielu dostawców wymaga również:

OTEL_EXPORTER_OTLP_HEADERS: nagłówki dla poświadczeń uwierzytelniania, takich jak klucze interfejsu API.

PYTHON_ENABLE_OPENTELEMETRY: ustaw wartość tak true , aby host usługi Functions umożliwiał procesowi roboczemu języka Python przesyłanie strumieniowe dzienników OpenTelemetry bezpośrednio, co uniemożliwia zduplikowanie wpisów na poziomie hosta.

Usługa Azure Functions obsługuje wszystkie zmienne środowiskowe zdefiniowane w dokumentacji konfiguracji zestawu OpenTelemetry SDK. Jednak określone zmienne i wartości wymagane różnią się w zależności od dostawcy. Zapoznaj się z dokumentacją dostawcy obserwacji, aby uzyskać:

• Wymagane adresy URL punktu końcowego i metody uwierzytelniania
• Zalecane ustawienia konfiguracji
• Zmienne środowiskowe specyficzne dla dostawcy
• Wszelkie dodatkowe kroki konfiguracji

Dodaj wszystkie wymagane zmienne środowiskowe jako ustawienia aplikacji w aplikacji funkcji.

APPLICATIONINSIGHTS_CONNECTION_STRING Usuń to ustawienie, chyba że chcesz również wyświetlić dane wyjściowe OpenTelemetry z hosta wysłanego do usługi Application Insights.

Włączanie funkcji OpenTelemetry w aplikacji

Po skonfigurowaniu hosta usługi Functions do używania biblioteki OpenTelemetry zaktualizuj kod aplikacji, aby wyświetlić dane telemetryczne OpenTelemetry. Po włączeniu funkcji OpenTelemetry zarówno na hoście, jak i kodzie aplikacji uzyskasz lepszą korelację między śladami i dziennikami emitowymi przez proces hosta usługi Functions i proces roboczy języka.

Instrumentacja aplikacji w celu korzystania z funkcji OpenTelemetry zależy od docelowego punktu końcowego OpenTelemetry:

W przykładach w tym artykule założono, że aplikacja używa elementu IHostApplicationBuilder, który jest dostępny w wersji 2.x i nowszej microsoft.Azure.Functions.Worker. Aby uzyskać więcej informacji, zobacz Version 2.x (Wersja 2.x ) w przewodniku dotyczącym izolowanego modelu roboczego języka C#.

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

   Application Insights

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

   Eksporter OTLP

   dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry
   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.Exporter; 
   

   Eksporter OTLP

   using OpenTelemetry; 
   

3. Skonfiguruj OpenTelemetry w zależności od tego, czy uruchamianie projektu korzysta z IHostBuilder, czy IHostApplicationBuilder. Ten ostatni został wprowadzony w wersji 2.x rozszerzenia modelu izolowanego procesu roboczego platformy .NET.

   IHostApplicationBuilder

   W program.cs dodaj ten wiersz kodu po :ConfigureFunctionsWebApplication

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

   IHostBuilder

   W program.cs dodaj to ConfigureServices wywołanie w swoim HostBuilder potoku.

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

   IHostApplicationBuilder

   W program.cs dodaj ten wiersz kodu po :ConfigureFunctionsWebApplication

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

   IHostBuilder

   W program.cs dodaj to ConfigureServices wywołanie w swoim HostBuilder potoku.

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

   Możesz wyeksportować do obu punktów końcowych OpenTelemetry z tej samej aplikacji.

1. Dodaj wymagane biblioteki do aplikacji. Sposób dodawania bibliotek zależy od tego, czy wdrażasz przy użyciu narzędzia Maven, czy Kotlin, a jeśli chcesz również wysyłać dane do usługi Application Insights.

   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. (Opcjonalnie) Dodaj ten kod, aby utworzyć niestandardowe zakresy:

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

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

3. main Zaktualizuj pole w pliku package.json, aby uwzględnić nowy src/index.js plik. Przykład:

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

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

3. 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 usługi Application Insights 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. Podczas konfigurowania hosta dla danych wyjściowych usługi OpenTelemetry w usłudze Application Insights 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. Modules na poziomie aplikacji w katalogu głównym aplikacji i uruchom następujące polecenie:

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

   To polecenie instaluje wymagany AzureFunctions.PowerShell.OpenTelemetry.SDK moduł 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. Upewnij się, że te biblioteki znajdują się w pliku requirements.txt, poprzez usunięcie komentarzy lub dodanie ich samodzielnie:

   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

   Jeśli już dodałeś PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY=true w ustawieniach aplikacji, możesz pominąć ten krok. Aby ręcznie włączyć zbieranie usługi Application Insights bez automatycznej instrumentacji, dodaj ten kod do aplikacji:

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

   Eksporter OTLP

   Należy ręcznie skonfigurować eksportowanie śladów, metryk i dzienników przy użyciu biblioteki OpenTelemetry. Aby uzyskać więcej informacji, zobacz Instrumentacja dla języka Python.

   W tym przykładzie przedstawiono prostą implementację 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())
           )
       )
   )
   
   

   Aby dowiedzieć się, jak używać składników OpenTelemetry do zbierania dzienników, zapoznaj się z zestawem SDK rejestrowania openTelemetry.

3. Zapoznaj się z dokumentacją użycia dystrybucji Azure Monitor, aby uzyskać opcje dalszej konfiguracji pakietu SDK.

Zagadnienia dotyczące platformy OpenTelemetry

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

• Portal Azure obsługuje Recent function invocation ślady tylko wtedy, gdy dane telemetryczne są wysyłane do Azure Monitor.

• Podczas konfigurowania hosta do korzystania z OpenTelemetry portal Azure nie obsługuje strumieniowania dzienników.

• Jeśli ustawiono telemetryMode na OpenTelemetry, konfiguracja w sekcji logging.applicationInsights pliku host.json nie ma zastosowania.

• Zakresy niestandardowe automatycznie obejmują wszystkie atrybuty zasobów i używają eksporterów skonfigurowanych w aplikacji.

• Gdy aplikacja działa poza platformą Azure, w tym podczas programowania lokalnego, detektor zasobów ustawia atrybut service.name na java-function-app domyślnie.

• Użyj tych flag maszyny wirtualnej Java (JVM), aby wyciszyć dane telemetryczne podczas uruchamiania lokalnie podczas testów jednostkowych:

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

• Nie musisz ręcznie rejestrować middleware; pracownik Java automatycznie wykrywa OpenTelemetryInvocationMiddleware.

Rozwiązywanie problemów

Podczas eksportowania danych przy użyciu biblioteki OpenTelemetry należy pamiętać o typowych problemach i rozwiązaniach.

Filtrowanie dzienników

Aby poprawnie skonfigurować filtrowanie dzienników w aplikacji funkcji, należy zrozumieć różnicę między procesem hosta a procesem roboczym.

Proces hosta to środowisko uruchomieniowe usługi Azure Functions, które zarządza wyzwalaczami, skalowaniem i emituje dane telemetryczne na poziomie systemu, takie jak dzienniki inicjowania, ślady żądań i informacje o kondycji środowiska uruchomieniowego.

Proces roboczy jest specyficzny dla języka, wykonuje kod funkcji i niezależnie tworzy dzienniki aplikacji i dane telemetryczne.

Ważne

Filtry zdefiniowane w host.json mają zastosowanie tylko do dzienników generowanych przez proces hosta. Aby filtrować dzienniki z procesu roboczego, należy użyć ustawień OpenTelemetry specyficznych dla języka.

Przykład: filtrowanie dzienników hostów dla wszystkich dostawców w host.json

Użyj tego podejścia, aby ustawić globalny poziom dziennika dla wszystkich dostawców zarządzanych przez hosta:

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

Przykład: filtrowanie dzienników tylko dla dostawcy rejestratora OpenTelemetry

Użyj tego podejścia, aby kierować tylko dostawcę rejestratora OpenTelemetry, pozostawiając innych dostawców (takich jak konsola lub rejestrowanie plików) bez wpływu:

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

Rejestrowanie konsoli

Host usługi Functions automatycznie przechwytuje wszystko zapisane w stdout lub stderr i przekazuje je do potoku telemetrii. Jeśli również używasz ConsoleExporter lub zapisujesz bezpośrednio na konsolę w swoim kodzie, w danych telemetrycznych mogą pojawić się zduplikowane dzienniki.

Uwaga / Notatka

Aby uniknąć zduplikowanych wpisów telemetrii, nie należy dodawać ConsoleExporter ani zapisywać do konsoli w kodzie produkcyjnym.

Uwierzytelnianie usługi Microsoft Entra

W przypadku korzystania z uwierzytelniania Microsoft Entra w usłudze OpenTelemetry należy skonfigurować uwierzytelnianie oddzielnie zarówno dla procesu hosta, jak i procesu roboczego.

Aby skonfigurować uwierzytelnianie dla procesu hosta, zobacz Wymagaj uwierzytelniania Microsoft Entra.

Aby skonfigurować uwierzytelnianie dla procesu roboczego, zapoznaj się z Włączanie uwierzytelniania Microsoft Entra.

Obsługa atrybutów zasobów

Obsługa atrybutów zasobów w usłudze Azure Monitor jest obecnie dostępna w wersji zapoznawczej. Aby włączyć tę funkcję, ustaw zmienną środowiskową OTEL_DOTNET_AZURE_MONITOR_ENABLE_RESOURCE_METRICS na true. To ustawienie wprowadza atrybuty zasobów do niestandardowej tabeli metryk.

Telemetria zdublowanego żądania

Proces hosta automatycznie emituje telemetrię żądania. Jeśli proces roboczy jest również instrumentowany za pomocą bibliotek śledzenia żądań (na przykład AspNetCoreInstrumentation na platformie .NET), to samo żądanie jest zgłaszane dwa razy.

Uwaga / Notatka

Ponieważ dystrybucja Azure Monitor zazwyczaj zawiera AspNetCoreInstrumentation na platformie .NET oraz podobne instrumentacje w innych językach, unikaj używania dystrybucji Azure Monitor w procesie roboczym, aby zapobiec duplikowaniu danych telemetrycznych.

Zakresy rejestrowania nieuwzględniane

Domyślnie proces roboczy nie zawiera zakresów w dziennikach. Aby włączyć zakresy, należy jawnie skonfigurować tę opcję w agencie roboczym. W poniższym przykładzie pokazano, jak włączyć zakresy w programie .NET Isolated:

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

Brak telemetrii żądania

Wyzwalacze, takie jak HTTP, Service Bus i Event Hubs, zależą od propagacji kontekstu na potrzeby śledzenia rozproszonego. W przypadku próbkowania opartego na elementach nadrzędnych jako domyślnego zachowania telemetria żądania nie jest generowana, gdy żądanie przychodzące lub komunikat nie są próbkowane.

Powielony identyfikator OperationId

W usłudze Azure Functions OperationId używany do korelowania danych telemetrycznych pochodzi bezpośrednio z wartości traceparent zawartej w przychodzącym żądaniu lub komunikacie. Jeśli wiele wywołań ponownie używa tej samej wartości traceparent, wszystkie otrzymują tę samą OperationId.

Konfigurowanie biblioteki OpenTelemetry ze zmiennymi środowiskowymi

Zachowanie biblioteki OpenTelemetry można skonfigurować przy użyciu standardowych zmiennych środowiskowych. Te zmienne zapewniają spójny sposób kontrolowania zachowania w różnych językach i środowiskach uruchomieniowych. Można dostosować strategie próbkowania, ustawienia eksportera i atrybuty zasobów. Aby uzyskać więcej informacji na temat obsługiwanych zmiennych środowiskowych, zobacz dokumentację platformy OpenTelemetry.

Rozwiązywanie problemów z monitorowaniem przy użyciu diagnostyki

Diagnostyka usługi Azure Functions w witrynie Azure Portal to przydatny zasób do wykrywania i diagnozowania potencjalnych problemów związanych z monitorowaniem.

Aby uzyskać dostęp do diagnostyki w aplikacji:

1. W portalu Azure przejdź do zasobu aplikacji funkcji.

2. W okienku po lewej stronie wybierz pozycję Diagnozuj i rozwiąż problemy i wyszukaj przepływ pracy dla aplikacji funkcji, z brakującą telemetrią Application Insights lub OpenTelemetry.

3. Wybierz ten przepływ pracy, metodę pobierania danych, a następnie Dalej.

4. Zapoznaj się z wytycznymi i wszelkimi zaleceniami dostarczonymi przez narzędzie do rozwiązywania problemów.

Dalsze kroki

Dowiedz się więcej o usłudze OpenTelemetry i monitorowaniu usługi Azure Functions:

• Monitorowanie usługi Azure Functions przy użyciu rozproszonego śledzenia OpenTelemetry
• Monitorowanie usługi Azure Functions