OpenTelemetria használata az Azure Functions használatával

Cikk
12/11/2024

Fontos

Az Azure Functions OpenTelemetry-támogatása jelenleg előzetes verzióban érhető el.

Ez a cikk bemutatja, hogyan konfigurálhatja a függvényalkalmazást a napló- és nyomkövetési adatok OpenTelemetria formátumban való exportálására. Az Azure Functions telemetriai adatokat hoz létre a függvényvégrehajtásokról mind a Functions-gazdagépfolyamatból, mind a nyelvspecifikus feldolgozói folyamatból, amelyben a függvénykód fut. Alapértelmezés szerint ezek a telemetriai adatok az Application Insights SDK-val lesznek elküldve az Application Insightsba. Azonban dönthet úgy, hogy openTelemetria szemantikával exportálja ezeket az adatokat. Bár továbbra is használhat OpenTelemetry-formátumot az adatok Application Insightsba való küldéséhez, ugyanezeket az adatokat exportálhatja bármely más OpenTelemetria-kompatibilis végpontra is.

Tipp.

Mivel ez a cikk a választott fejlesztési nyelvre irányul, ne felejtse el kiválasztani a megfelelő nyelvet a cikk tetején.

Jelenleg nincs ügyféloptimalizált OpenTelemetry-támogatás Java-alkalmazásokhoz.

Az OpenTelemetry jelenleg nem támogatott a C# folyamatban lévő alkalmazások esetében.

Ezeket az előnyöket az OpenTelemetria függvényalkalmazásban való engedélyezésével érheti el:

Korreláció a gazdagépen és az alkalmazás kódjában létrehozott nyomkövetések és naplók között.
Exportálható telemetriai adatok konzisztens, szabványokon alapuló generálása.
Integrálható más, OpenTelemetry-kompatibilis adatokat használó szolgáltatókkal.

Az OpenTelemetria a függvényalkalmazás szintjén engedélyezve van a gazdagép konfigurációjában (host.json) és a kódprojektben is. A Functions emellett ügyféloptimalizált felületet biztosít az OpenTelemetry-adatok exportálásához a nyelvspecifikus feldolgozói folyamatban futó függvénykódból.

1. OpenTelemetria engedélyezése a Functions-gazdagépen

Ha engedélyezi az OpenTelemetry kimenetet a függvényalkalmazás host.json fájljában, a gazdagép az alkalmazás által használt nyelvi veremtől függetlenül exportálja az OpenTelemetry kimenetet.

Ha engedélyezni szeretné az OpenTelemetry-kimenetet a Functions-gazdagépről, frissítse a kódprojekt host.json fájlját , hogy hozzáadjon egy "telemetryMode": "openTelemetry" elemet a gyökérgyűjteményhez. Ha az OpenTelemetry engedélyezve van, a host.json fájl a következőképpen nézhet ki:

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

2. Alkalmazásbeállítások konfigurálása

Ha az OpenTelemetria engedélyezve van a host.json fájlban, a rendszer meghatározza azokat a végpontokat, amelyekre az adatokat küldi a rendszer, amelyek alapján az OpenTelemetria által támogatott alkalmazásbeállítások elérhetők az alkalmazás környezeti változóiban.

Hozzon létre konkrét alkalmazásbeállításokat a függvényalkalmazásban az OpenTelemetry kimeneti célhelyének megfelelően. Ha az Application Insights és az OpenTelemetry protocol (OTLP) exportőre is megadja a kapcsolati beállításokat, az OpenTelemetry-adatokat a rendszer mindkét végpontra elküldi.

Application Insights
OTLP-exportőr

APPLICATIONINSIGHTS_CONNECTION_STRING: egy Application Insights-munkaterület kapcsolati sztring. Ha ez a beállítás létezik, a rendszer OpenTelemetry-adatokat küld az adott munkaterületre. Ez a beállítás ugyanaz, mint az Application Insightshoz való csatlakozáshoz az OpenTelemetry engedélyezése nélkül. Ha az alkalmazás még nem rendelkezik ezzel a beállítással, lehetséges, hogy engedélyeznie kell az Application Insights integrációját.

OTEL_EXPORTER_OTLP_ENDPOINT: egy OTLP-exportőr végpont URL-címe.

OTEL_EXPORTER_OTLP_HEADERS: (Nem kötelező) az összes kimenő adatra alkalmazandó fejlécek listája. Ezt számos végpont használja egy API-kulcs átadásához.

Ha a végponthoz más környezeti változókat is be kell állítania, ezeket is hozzá kell adnia az alkalmazás beállításaihoz. További információkért tekintse meg az OTLP-exportőr konfigurációs dokumentációját.

Távolítsa el a APPLICATIONINSIGHTS_CONNECTION_STRING beállítást, hacsak nem szeretné, hogy az Application Insightsnak küldött gazdagép OpenTelemetry-kimenete is legyen.

3. OpenTelemetria engedélyezése az alkalmazásban

Az OpenTelemetria használatára konfigurált Functions-gazdagéppel az alkalmazás kódját is frissítenie kell az OpenTelemetria-adatok kimenetére. Az OpenTelemetria engedélyezése mind a gazdagépen, mind az alkalmazáskódban jobb korrelációt tesz lehetővé a Functions gazdagépfolyamat és a nyelvi feldolgozó folyamat által kibocsátott nyomkövetések és naplók között.

Az alkalmazás OpenTelemetry használatára való eszközkezelésének módja a cél OpenTelemetry-végponttól függ:

Futtassa az alábbi parancsokat a szükséges szerelvények telepítéséhez az alkalmazásban:

Application Insights
OTLP-exportőr

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

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

A Program.cs projektfájlban adja hozzá ezt az utasítást using :
- Application Insights
- OTLP-exportőr
```
using Azure.Monitor.OpenTelemetry.AspNetCore; 
```
```
using OpenTelemetry; 
```
A meghatalmazottban adja hozzá ezt a ConfigureServices szolgáltatáskonfigurációt:
- Application Insights
- OTLP-exportőr
```
services.AddOpenTelemetry()
.UseFunctionsWorkerDefaults()
.UseAzureMonitor();
```
```
services.AddOpenTelemetry()
.UseFunctionsWorkerDefaults()
.UseOtlpExporter();
```
Ha mindkét OpenTelemetry-végpontra szeretne exportálni, hívja meg mindkettőt UseAzureMonitor és UseOtlpExporter.

A Java-feldolgozó optimalizálásai még nem érhetők el az OpenTelemetryhez, ezért nincs mit konfigurálni a Java-kódban.

Telepítse ezeket az npm-csomagokat a projektben:

Application Insights
OTLP-exportőr

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

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

Hozzon létre egy kódfájlt a projektben, másolja és illessze be az alábbi kódot az új fájlba, és mentse a fájlt a következőként src/index.js:

Application Insights
OTLP-exportőr

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

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

Frissítse a main package.json fájl mezőjét úgy, hogy az tartalmazza ezt az új src/index.js fájlt, amely így nézhet ki:
```
"main": "src/{index.js,functions/*.js}"
```

Hozzon létre egy kódfájlt a projektben, másolja és illessze be az alábbi kódot az új fájlba, és mentse a fájlt a következőként src/index.ts:

Application Insights
OTLP-exportőr

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

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

Frissítse a main package.json fájl mezőjét úgy, hogy az tartalmazza az új src/index.ts fájl kimenetét, amely így nézhet ki:
```
"main": "dist/src/{index.js,functions/*.js}"
```

Fontos

A PowerShell-alkalmazások jelenleg nem támogatják az Application Insights openTelemetry kimenetét a nyelvi feldolgozótól. Érdemes lehet inkább OTLP-exportőri végpontot használnia. Ha a gazdagép OpenTelemetry-kimenethez van konfigurálva az Application Insightshoz, a PowerShell-feldolgozó folyamat által létrehozott naplók továbbra is továbbítva lesznek, de az elosztott nyomkövetés jelenleg nem támogatott.

Ezek az utasítások csak egy OTLP-exportőrre vonatkoznak:

Adjon hozzá egy olyan alkalmazásbeállítást OTEL_FUNCTIONS_WORKER_ENABLED , amelynek értéke : True.
Hozzon létre egy alkalmazásszintű Modules mappát az alkalmazás gyökerében, és futtassa a következő parancsot:
```
Save-Module -Name AzureFunctions.PowerShell.OpenTelemetry.SDK
```
Ez közvetlenül az alkalmazásban telepíti a szükséges AzureFunctions.PowerShell.OpenTelemetry.SDK modult. A fájllal nem telepítheti automatikusan ezt a requirements.psd1 függőséget, mert a Felügyelt függőségek jelenleg nem támogatottak a Flex Consumption csomag előzetes verziójában.

Adja hozzá ezt a kódot a profile.ps1 fájlhoz:

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

Adja hozzá ezt a bejegyzést a requirements.txt fájlhoz:

Application Insights
OTLP-exportőr

azure.monitor.opentelemetry

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

Adja hozzá ezt a kódot a fő belépési pont fájljához function_app.py :

Application Insights
OTLP-exportőr

from azure.monitor.opentelemetry import configure_azure_monitor 
configure_azure_monitor()

Az OpenTelemetria használatával exportált nyomkövetéseket, metrikákat és naplókat manuálisan kell konfigurálni. További információ: Instrumentation for Python.

Ez egy egyszerű implementáció a naplók exportálásához:

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

Tekintse át az OpenTelemetry Logging SDK-t , és ismerje meg, hogyan gyűjthet naplókat az OpenTelemetry-összetevőkkel.

Az OpenTelemetria szempontjai

Amikor OpenTelemetria használatával exportálja az adatokat, tartsa szem előtt ezeket az aktuális szempontokat.

Ha a gazdagép OpenTelemetria használatára van konfigurálva, csak a naplók és nyomkövetések lesznek exportálva. A gazdagépmetrikák jelenleg nincsenek exportálva.
Jelenleg nem futtathatja helyileg az alkalmazásprojektet a Core Tools használatával, ha engedélyezve van az OpenTelemetry a gazdagépen. Az OpenTelemetryvel kapcsolatos frissítések érvényesítéséhez jelenleg telepítenie kell a kódot az Azure-ban.
Jelenleg csak a HTTP-eseményindítók és az Azure SDK-alapú triggerek támogatottak OpenTelemetry-kimenetekkel.

Az Azure Functions Flex használati csomag figyelése

Megosztás a következőn keresztül:

OpenTelemetria használata az Azure Functions használatával

1. OpenTelemetria engedélyezése a Functions-gazdagépen

2. Alkalmazásbeállítások konfigurálása

3. OpenTelemetria engedélyezése az alkalmazásban

Az OpenTelemetria szempontjai

Visszajelzés

További források

Megosztás a következőn keresztül:

OpenTelemetria használata az Azure Functions használatával

1. OpenTelemetria engedélyezése a Functions-gazdagépen

2. Alkalmazásbeállítások konfigurálása

3. OpenTelemetria engedélyezése az alkalmazásban

Az OpenTelemetria szempontjai

Kapcsolódó tartalom

Visszajelzés

További források