OpenTelemetry gebruiken met Azure Functions

Belangrijk

Ondersteuning voor OpenTelemetry voor Azure Functions is momenteel in preview en uw app moet worden gehost in een Flex Consumption-abonnement om OpenTelemetry te kunnen gebruiken.

In dit artikel leest u hoe u uw functie-app configureert voor het exporteren van logboek- en traceringsgegevens in een OpenTelemetry-indeling. Azure Functions genereert telemetriegegevens over de uitvoering van uw functie vanuit zowel het Functions-hostproces als het taalspecifieke werkproces waarin uw functiecode wordt uitgevoerd. Deze telemetriegegevens worden standaard verzonden naar Application Insights met behulp van de Application Insights SDK. U kunt er echter voor kiezen om deze gegevens te exporteren met behulp van semantiek van OpenTelemetry. Hoewel u nog steeds een OpenTelemetry-indeling kunt gebruiken om uw gegevens naar Application Insights te verzenden, kunt u nu ook dezelfde gegevens exporteren naar elk ander openTelemetry-compatibel eindpunt.

Tip

Omdat dit artikel is gericht op uw ontwikkeltaal van keuze, moet u de juiste taal bovenaan het artikel kiezen.

Momenteel is er geen client geoptimaliseerde OpenTelemetry-ondersteuning voor Java-apps.

OpenTelemetry wordt momenteel niet ondersteund voor in-process C#-apps.

U kunt deze voordelen verkrijgen door OpenTelemetry in te schakelen in uw functie-app:

• Correlatie tussen traceringen en logboeken die zowel op de host als in uw toepassingscode worden gegenereerd.
• Consistente, op standaarden gebaseerde generatie van exportbare telemetriegegevens.
• Integreert met andere providers die openTeleletry-compatibele gegevens kunnen gebruiken.

OpenTelemetry is ingeschakeld op het niveau van de functie-app, zowel in de hostconfiguratie (host.json) als in uw codeproject. Functions biedt ook een door de client geoptimaliseerde ervaring voor het exporteren van OpenTelemetry-gegevens uit uw functiecode die wordt uitgevoerd in een taalspecifiek werkproces.

1. OpenTelemetry inschakelen in de Functions-host

Wanneer u OpenTelemetry-uitvoer inschakelt in het host.json-bestand van de functie-app, exporteert de host OpenTelemetry-uitvoer, ongeacht de taalstack die door uw app wordt gebruikt.

Als u OpenTelemetry-uitvoer van de Functions-host wilt inschakelen, werkt u het host.json-bestand in uw codeproject bij om een "telemetryMode": "openTelemetry" element toe te voegen aan de hoofdverzameling. Als OpenTelemetry is ingeschakeld, ziet uw host.json bestand er als volgt uit:

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

2. Toepassingsinstellingen configureren

Wanneer OpenTelemetry is ingeschakeld in het host.json bestand, worden de eindpunten waarnaar gegevens worden verzonden bepaald op basis van welke openTelemetry-ondersteunde toepassingsinstellingen beschikbaar zijn in de omgevingsvariabelen van uw app.

Maak specifieke toepassingsinstellingen in uw functie-app op basis van de doeluitvoer van OpenTelemetry. Wanneer verbindingsinstellingen worden opgegeven voor zowel Application Insights als een OTLP-exporteur (OpenTelemetry Protocol), worden OpenTelemetry-gegevens naar beide eindpunten verzonden.

Application Insights

APPLICATIONINSIGHTS_CONNECTION_STRING: het verbindingsreeks voor een Application Insights-werkruimte. Wanneer deze instelling bestaat, worden OpenTelemetry-gegevens naar die werkruimte verzonden. Deze instelling is dezelfde die wordt gebruikt om verbinding te maken met Application Insights zonder OpenTelemetry ingeschakeld. Als uw app deze instelling nog niet heeft, moet u mogelijk Application Insights-integratie inschakelen.

OTLP-exporteur

OTEL_EXPORTER_OTLP_ENDPOINT: een EINDPUNT-URL van OTLP-exporteur.

OTEL_EXPORTER_OTLP_HEADERS: (Optioneel) lijst met headers die moeten worden toegepast op alle uitgaande gegevens. Dit wordt door veel eindpunten gebruikt om een API-sleutel door te geven.

Als voor uw eindpunt u andere omgevingsvariabelen moet instellen, moet u deze ook toevoegen aan uw toepassingsinstellingen. Zie de configuratiedocumentatie voor OTLP-exporteurs voor meer informatie.

Verwijder de APPLICATIONINSIGHTS_CONNECTION_STRING instelling, tenzij u ook OpenTelemetry-uitvoer van de host naar Application Insights wilt verzenden.

3. OpenTelemetry inschakelen in uw app

Als de Functions-host is geconfigureerd voor het gebruik van OpenTelemetry, moet u ook uw toepassingscode bijwerken om OpenTelemetry-gegevens uit te voeren. Als u OpenTelemetry inschakelt in zowel de host als uw toepassingscode, kunt u beter correlatie tussen traceringen en logboeken die worden verzonden door het Functions-hostproces en vanuit uw taalwerkproces.

De manier waarop u uw toepassing instrumenteren voor het gebruik van OpenTelemetry, is afhankelijk van uw doeleindpunt voor OpenTelemetry:

1. Voer deze opdrachten uit om de vereiste assembly's in uw app te installeren:

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

   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. Voeg in het Program.cs projectbestand deze using instructie toe:

   Application Insights

   using Azure.Monitor.OpenTelemetry.AspNetCore; 
   

   OTLP-exporteur

   using OpenTelemetry; 
   

3. Voeg in de ConfigureServices gemachtigde deze serviceconfiguratie toe:

   Application Insights

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

   OTLP-exporteur

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

   Als u wilt exporteren naar beide OpenTelemetry-eindpunten, roept u beide UseAzureMonitor aan en UseOtlpExporter.

Optimalisaties voor Java-werkrollen zijn nog niet beschikbaar voor OpenTelemetry, dus er is niets te configureren in uw Java-code.

1. Installeer deze NPM-pakketten in uw project:

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

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

1. Maak een codebestand in uw project, kopieer en plak de volgende code in dit nieuwe bestand en sla het bestand op als 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-exporteur

   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. Werk het veld in het main package.json-bestand bij om dit nieuwe src/index.js bestand op te nemen. Dit kan er als volgt uitzien:

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

1. Maak een codebestand in uw project, kopieer en plak de volgende code in dit nieuwe bestand en sla het bestand op als 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-exporteur

   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. Werk het veld in het main package.json-bestand bij om de uitvoer van dit nieuwe src/index.ts bestand op te nemen. Dit kan er als volgt uitzien:

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

Belangrijk

OpenTelemetry-uitvoer naar Application Insights van de taalwerker wordt momenteel niet ondersteund voor PowerShell-apps. U kunt in plaats daarvan een OTLP-exporteur-eindpunt gebruiken. Wanneer uw host is geconfigureerd voor OpenTelemetry-uitvoer naar Application Insights, worden de logboeken die door het PowerShell-werkproces worden gegenereerd, nog steeds doorgestuurd, maar gedistribueerde tracering wordt op dit moment niet ondersteund.

Deze instructies zijn alleen van toepassing op een OTLP-exporteur:

1. Voeg een toepassingsinstelling toe met de OTEL_FUNCTIONS_WORKER_ENABLED naam met de waarde van True.

2. Maak een map op app-niveau Modules in de hoofdmap van uw app en voer de volgende opdracht uit:

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

   Hiermee wordt de vereiste AzureFunctions.PowerShell.OpenTelemetry.SDK module rechtstreeks in uw app geïnstalleerd. U kunt het requirements.psd1 bestand niet gebruiken om deze afhankelijkheid automatisch te installeren, omdat beheerde afhankelijkheden momenteel niet worden ondersteund in de preview van het Flex Consumption-abonnement .

3. Voeg deze code toe aan uw profiel.ps1-bestand:

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

1. Voeg deze vermelding toe aan uw requirements.txt bestand:

   Application Insights

   azure.monitor.opentelemetry
   

   OTLP-exporteur

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

2. Voeg deze code toe aan het function_app.py hoofdinvoerpuntbestand:

   Application Insights

   from azure.monitor.opentelemetry import configure_azure_monitor 
   configure_azure_monitor() 
   

   OTLP-exporteur

   Traceringen, metrische gegevens en logboeken die worden geëxporteerd met behulp van OpenTelemetry, moeten handmatig worden geconfigureerd. Zie Instrumentatie voor Python voor meer informatie.

   Dit is een eenvoudige implementatie voor het exporteren van logboeken:

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

   Bekijk de OpenTelemetry Logging SDK voor meer informatie over het gebruik van OpenTelemetry-onderdelen voor het verzamelen van logboeken.

Overwegingen voor OpenTelemetry

Wanneer u uw gegevens exporteert met Behulp van OpenTelemetry, moet u rekening houden met deze huidige overwegingen.

• Wanneer de host is geconfigureerd voor het gebruik van OpenTelemetry, worden alleen logboeken en traceringen geëxporteerd. Metrische hostgegevens worden momenteel niet geëxporteerd.

• U kunt uw app-project momenteel niet lokaal uitvoeren met Behulp van Core Tools wanneer OpenTelemetry is ingeschakeld op de host. U moet uw code momenteel implementeren in Azure om uw OpenTelemetry-gerelateerde updates te valideren.

• Op dit moment worden alleen HTTP-triggers en op Azure SDK gebaseerde triggers ondersteund met OpenTelemetry-uitvoer.

Gerelateerde inhoud

Azure FunctionsFlex Consumption-abonnement bewaken