OpenTelemetry használata Azure Functions-szel

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. Azure Functions telemetriaadatokat hoz létre a függvényvégrehajtásokról mind a Functions-gazdafolyamatbó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 használatával lesznek elküldve az Application Insightsnak. Azonban az OpenTelemetria szemantikával exportálhatja 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.

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

  • Korrelálja az adatokat a gazdagépen és az alkalmazás kódjában létrehozott nyomkövetések és naplók között.
  • Lehetővé teszi az exportálható telemetriai adatok konzisztens, szabványokon alapuló létrehozását.
  • Integrálható más, OpenTelemetry-kompatibilis adatokat használó szolgáltatókkal.

A cikk használatakor tartsa szem előtt ezeket a szempontokat:

  • Próbálja ki a OpenTelemetria oktatóanyagot, amely az OpenTelemetria és a Azure Functions használatának gyors megkezdéséhez nyújt segítséget. Ez a cikk a Azure fejlesztői parancssori felület (azd) használatával hoz létre és helyez üzembe egy OpenTelemetry-integrációt használó függvényalkalmazást az elosztott nyomkövetéshez.
  • Mivel ez a cikk a választott fejlesztési nyelvre irányul, ne felejtse el kiválasztani a megfelelő nyelvet a cikk tetején.
  • Az OpenTelemetry a függvényalkalmazás szintjén van engedélyezve, mind a gazdagép konfigurációjában (host.json), mind a kódprojektben. 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.

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 függetlenül az alkalmazás által használt nyelvi veremtő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",
    "telemetryMode": "OpenTelemetry",
    ...
}

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

Amikor engedélyezi az OpenTelemetryt a host.json fájlban, az alkalmazás környezeti változói határozzák meg az adatok küldésének végpontjait az OpenTelemetry által támogatott alkalmazásbeállítások alapján.

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

APPLICATIONINSIGHTS_CONNECTION_STRING: egy Application Insights-munkaterület kapcsolati karakterlánca. Ha ez a beállítás létezik, a rendszer OpenTelemetry-adatokat küld az adott munkaterületre. Ugyanezzel a beállítással csatlakozhat az Application Insightshoz 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.

JAVA_APPLICATIONINSIGHTS_ENABLE_TELEMETRY: true értékre van állítva, így a Functions-gazdagép lehetővé teszi, hogy a Java feldolgozó folyamat közvetlenül streamelje az OpenTelemetry-naplókat, ami megakadályozza az ismétlődő gazdagépszintű bejegyzéseket.

PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY: true értékre van állítva, így a Functions-gazdagép lehetővé teszi, hogy a Python feldolgozó folyamat közvetlenül streamelje az OpenTelemetry-naplókat, ami megakadályozza az ismétlődő gazdagépszintű bejegyzéseket.

Go-alkalmazások esetén ez a beállítás konfigurálja az OpenTelemetry exportálását a Functions-gazdagépről az Application Insightsba. Nem konfigurálja a Go worker OpenTelemetry middleware-jét, amely az OTLP-beállításokkal exportálja a worker telemetriai adatait. A Go-munkafolyamat telemetriai adatainak az Application Insightsba való küldéséhez irányítsa az OTLP-kimenetet egy OpenTelemetry Collectoron vagy egy másik, az Azure Monitorba történő exportálásra konfigurált OpenTelemetry-alapú folyamaton keresztül.

OpenTelemetria engedélyezése az alkalmazásban

Miután konfigurálta a Functions-gazdagépet az OpenTelemetria használatára, frissítse az alkalmazáskódot az OpenTelemetry-adatok kimenetére. Ha az OpenTelemetryt a gazdagépen és az alkalmazás kódjában is engedélyezi, jobb korrelációt kap a Functions-gazdafolyamat é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ó előkészítése attól függ, melyik cél OpenTelemetry-végpontot használja:

A cikkben szereplő példák feltételezik, hogy az alkalmazás IHostApplicationBuilder használ, amely a 2.x és újabb verzióiban érhető el a Microsoft.Azure.Functions.Worker esetében. További információ: 2.x verzió a C# izolált feldolgozómodell útmutatójában.

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

    Megjegyzés:

    A 3.0-s verziótól kezdve a Microsoft.ApplicationInsights.WorkerService csomag Azure Monitor Exportőrt használja. Ezzel a csomagtal fenntarthatja a meglévő Application Insights-konfigurációs viselkedéseket, miközben belsőleg használja a Azure Monitor folyamatot, beleértve az OpenTelemetry-exportőrt is. A Microsoft.ApplicationInsights.WorkerService csomag helyett használhatja a Azure.Monitor.OpenTelemetry.Exporter csomagot (3.0-s vagy újabb verzió), amely az alábbi példában látható.

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

  2. A Program.cs projektfájlban adja hozzá ezt az utasítást using :

    using Azure.Monitor.OpenTelemetry.Exporter;

  3. Konfigurálja az OpenTelemetryt attól függően, hogy a projekt indítása IHostBuilder vagy IHostApplicationBuilder használatával történik. Ez utóbbi a .NET izolált feldolgozómodell-bővítmény 2.x verziójában lett bevezetve.

    Adja hozzá ezt a kódsort a program.cs fájlban a következő után ConfigureFunctionsWebApplication.

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

    Mindkét OpenTelemetry-végpontra exportálhat ugyanabból az alkalmazásból.

  1. Adja hozzá a szükséges könyvtárakat az alkalmazáshoz. A kódtárak hozzáadásának módja attól függ, hogy a Maven vagy a Kotlin használatával helyezi-e üzembe, és hogy adatokat szeretne-e küldeni az Application Insightsnak.

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

  2. (Nem kötelező) Adja hozzá ezt a kódot egyéni tartományok létrehozásához:

    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. Telepítse ezeket az npm-csomagokat a projektben:

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

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

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

  2. Frissítse a main package.json fájl mezőjét úgy, hogy az tartalmazza az új src/index.js fájlt. Például:

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

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

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

  2. 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. Amikor a hostot beállítja OpenTelemetry-kimenetre az Application Insights számára, a PowerShell-munkafolyamat által generált naplók továbbra is továbbítódnak, de az elosztott nyomkövetés jelenleg nincs támogatva.

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

  1. Adjon hozzá egy olyan alkalmazásbeállítást OTEL_FUNCTIONS_WORKER_ENABLED , amelynek értéke : True.

  2. 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 a parancs 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.

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

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

  1. Győződjön meg arról, hogy ezek a könyvtárak a requirements.txt fájlban szerepelnek, akár úgy, hogy megjegyzésből kivesszük, akár úgy, hogy saját maga adja hozzá őket:

    azure-monitor-opentelemetry

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

    Ha már felvette PYTHON_APPLICATIONINSIGHTS_ENABLE_TELEMETRY=true az alkalmazásbeállításokba, kihagyhatja ezt a lépést. Ha automatikus rendszerezés nélkül szeretné manuálisan engedélyezni az Application Insights-gyűjteményt, adja hozzá ezt a kódot az alkalmazáshoz:

    from azure.monitor.opentelemetry import configure_azure_monitor 
configure_azure_monitor()

  3. Tekintse át az Azure Disztró használatának monitorozása dokumentációt az SDK további konfigurálási lehetőségeiről.

Go-alkalmazások esetén ugyanazt a feldolgozói beállítást használja a rendszer bármely OpenTelemetry-célhelyhez. A köztes szoftver az OTLP-beállítások használatával exportálja a feldolgozói telemetriát. Az OTLP-végpont lehet szállítói végpont vagy OpenTelemetria-gyűjtő, amely a telemetriát egy másik célhelyre továbbítja, például Azure Monitor.

  1. Győződjön meg arról, hogy a projekt az OpenTelemetry köztes szoftverét tartalmazó Go-feldolgozó SDK-t használja:

    go get github.com/azure/azure-functions-golang-worker@latest
go mod tidy

  2. A(z) main.go fájlban importálja az OpenTelemetry köztes réteget, és regisztrálja azt, mielőtt regisztrálná a függvényeket:

    package main

import (
    "fmt"
    "log/slog"
    "net/http"

    "github.com/azure/azure-functions-golang-worker/middleware/otelfunc"
    "github.com/azure/azure-functions-golang-worker/sdk"
    "github.com/azure/azure-functions-golang-worker/worker"
)

func hello(w http.ResponseWriter, r *http.Request) {
    slog.InfoContext(r.Context(), "processing request", "path", r.URL.Path)
    fmt.Fprintln(w, "hello")
}

func main() {
    app := sdk.FunctionApp()
    app.Use(otelfunc.Middleware())

    app.HTTP("hello", hello,
        sdk.WithMethods("GET"),
        sdk.WithAuth("anonymous"),
    )
    worker.Start(app)
}

A nulla argumentumú köztes szoftver a cikkben korábban konfigurált szabványos OTEL_EXPORTER_OTLP_* alkalmazásbeállításokat használja. Hívási időtartamokat hoz létre, korrelálja slog a hívási környezettel kibocsátott rekordokat, és minden egyes hívás után kiüríti a telemetriát.

Egyéni gyermek spanok létrehozásához használja a szabványos OpenTelemetry Go API-kat a hívási kontextussal. HTTP-eseményindítók esetén használja r.Context() szülőkörnyezetként. Más triggertípusok esetén használja a context.Context kezelőnek átadott paramétert.

Az OpenTelemetria szempontjai

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

  • Az Azure portál csak akkor támogatja a Recent function invocation nyomkövetést, ha a telemetriát az Azure Monitorhoz küldik el.

  • Amikor a gazdagépet OpenTelemetria használatára konfigurálja, a Azure portál nem támogatja a naplóstreamelést.

  • Ha a telemetryMode értéket OpenTelemetry-re állítja, a host.json fájl logging.applicationInsights szakaszának konfigurációja nem alkalmazható.

  • Az egyéni spanok automatikusan tartalmazzák az összes erőforrásattribútumot, és az alkalmazásban konfigurált exportőröket használják.

  • Ha az alkalmazás Azure kívül fut, beleértve a helyi fejlesztés során is, az erőforrás-detektor alapértelmezés szerint service.name értékre állítja a java-function-app attribútumot.

  • Az alábbi Java virtuális gép (JVM) jelzőkkel elnémíthatja a telemetriát, amikor helyileg fut az egységtesztek során:

    • -Dotel.traces.exporter=none
    • -Dotel.metrics.exporter=none
    • -Dotel.logs.exporter=none
  • Nem kell manuálisan regisztrálnia a middleware-t; a Java feldolgozó automatikusan észleli OpenTelemetryInvocationMiddleware.

  • Használjon környezettudatos metódusokat a standard log/slog csomagból, például slog.InfoContext és slog.ErrorContext, a strukturált naplók és az aktuális hívás és nyomkövetés korrelálásához.

  • A Go worker OpenTelemetry köztes rétege külön engedélyezhető. Azok az alkalmazások, amelyek nem importálnak és regisztrálnak middleware/otelfunc , nem tartalmaznak OpenTelemetria-csomagokat a lefordított bináris fájlban.

  • Ha ideiglenesen le szeretné tiltani a Go-feldolgozó köztes szoftverét az alkalmazás ismételt üzembe helyezése nélkül, állítsa a következőre AZURE_FUNCTIONS_WORKER_OPENTELEMETRY_DISABLEDtrue: .

  • A speciális konfigurációhoz a köztes szoftver regisztrálása előtt egyéni OpenTelemetria-szolgáltatókat, exportőröket, erőforrás-attribútumokat és propagátorokat konfigurálhat kódban.

Erőforrás-érzékelők és szemantikai konvenciók

A Azure Functions az erőforrásattribútumok a függvényalkalmazás folyamatát és környezetét írják le. A span attribútumok egyetlen meghívást írnak le.

Alapértelmezett viselkedés (nincs szükség műveletre)

Az Azure Functions az App Service-en belül az erőforrás-érzékelők általában automatikusan feltöltik a gyakori attribútumokat, például:

  • service.name (a függvényalkalmazás nevének alapértelmezett értéke)
  • Azure felhőattribútumok, például cloud.provider, cloud.region és cloud.resource_id

A legtöbb esetben ezek az alapértelmezett értékek elegendőek a megfelelő alkalmazástérkép-csoportosításhoz és Azure környezethez.

Mikor kell felülírni service.name (felhőbeli szerepkör neve)

Csak akkor bírálja felül, ha az Application Insightsban (alkalmazástérkép-csoportosításban) eltérő, stabil csomópontnévre van szüksége, például a pontok vagy környezetek elnevezésének normalizálásához.

Állítsa be OTEL_SERVICE_NAME az észlelt érték felülbírálására:

export OTEL_SERVICE_NAME="my-function-app"

Meghívási span attribútumok (általában automatikus)

Ezeket csak akkor kell manuálisan beállítania, ha egyéni invokációs időtartamot hoz létre.

  • faas.name (függvény neve)
  • faas.trigger(például http, servicebus, eventhubs)
  • faas.execution (hívás/végrehajtás azonosítója)

Fontos

A függvényalkalmazások több függvényt is üzemeltethetnek egy folyamat során. Ne helyezzen függvényspecifikus értékeket az erőforrásra. Az egyes hívásokhoz tartozó identitást rendelje hozzá a spanokhoz.

Megjegyzés:

Ha helyileg (Functions Core Tools) vagy olyan tárolóalapú/saját üzemeltetésű környezetben fut, ahol Azure metaadatok nem érhetők el, előfordulhat, hogy a service.name alapértelmezés szerint általános értéket ad meg. Állítsa be OTEL_SERVICE_NAME helyileg úgy, hogy megfeleljen a termelési elnevezésnek.

Hibaelhárítás

Amikor OpenTelemetria használatával exportálja az adatokat, tartsa szem előtt ezeket a gyakori problémákat és megoldásokat.

Naplószűrés

Ha megfelelően szeretné konfigurálni a naplószűrést a függvényalkalmazásban, ismernie kell a gazdafolyamat és a feldolgozói folyamat közötti különbséget.

A host folyamat az a Azure Functions futtatókörnyezet, amely kezeli az eseményindítókat, a skálázást, és rendszerszintű telemetriát bocsát ki, például inicializálási naplókat, kérelmek nyomkövetését és futásidejű állapotinformációkat.

A feldolgozói folyamat nyelvspecifikus, végrehajtja a függvénykódot, és egymástól függetlenül állítja elő az alkalmazásnaplókat és a telemetriát.

Fontos

A host.json fájlban meghatározott szűrők csak a gazdagépfolyamat által létrehozott naplókra vonatkoznak. A munkavégző folyamat naplóinak szűréséhez nyelvspecifikus OpenTelemetria-beállításokat kell használnia.

Példa: Gazdagépnaplók szűrése az host.jsonösszes szolgáltatója számára

Ezzel a módszerrel globális naplószintet állíthat be a gazdagép által felügyelt összes szolgáltatóra:

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

Példa: Csak az OpenTelemetry logger szolgáltató esetében szűrje a naplókat

Ezzel a módszerrel csak az OpenTelemetry-naplózó szolgáltatóját célozhatja meg, miközben más szolgáltatókat (például konzolt vagy fájlnaplózást) nem érint:

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

Konzolnaplózás

A Functions-gazdagép automatikusan rögzíti az stdout-ra vagy stderrre írt adatokat, és továbbítja azt a telemetriai folyamatnak. Ha ConsoleExportert használ, vagy közvetlenül a konzolra írja a kódot, telemetriai adataiban ismétlődő naplóbejegyzések fordulhatnak elő.

Megjegyzés:

Az ismétlődő telemetriai bejegyzések elkerülése érdekében ne adjon hozzá ConsoleExportert, és ne írjon a konzolra gyártói kódban.

Microsoft Entra hitelesítés

Ha Microsoft Entra-hitelesítést használ Az OpenTelemetria használatával, a hitelesítést külön kell konfigurálnia mind a gazdafolyamathoz, mind a feldolgozó folyamathoz.

A gazdafolyamat hitelesítésének konfigurálásához lásd: Require Microsoft Entra hitelesítés.

A feldolgozó folyamat hitelesítésének konfigurálásához lásd: Enable Microsoft Entra authentication.

Erőforrásattribútumok támogatása

Az erőforrásattribútumok Azure Monitor támogatása jelenleg előzetes verzióban érhető el. A funkció engedélyezéséhez állítsa a OTEL_DOTNET_AZURE_MONITOR_ENABLE_RESOURCE_METRICS környezeti változót a következőre: true. Ez a beállítás betölti az erőforrásattribútumokat az egyéni metrikák táblájába.

Ismétlődő lekérdezés-telemetria

A gazdafolyamat automatikusan küldi a kérés telemetriáját. Ha a munkafolyamatot a lekérdezéskövetési könyvtárak is használják (például az AspNetCoreInstrumentation .NET-ben), ugyanazt a kérést kétszer jelenti a rendszer.

Megjegyzés:

Mivel az Azure Monitor disztribúció általában az AspNetCoreInstrumentation .NET-et és más nyelvek hasonló rendszerállapotát tartalmazza, kerülje az Azure Monitor disztribúció használatát a munkafolyamatban az ismétlődő telemetriai adatok elkerülése érdekében.

Nem tartalmazzák a naplózási hatóköröket

Alapértelmezés szerint a feldolgozói folyamat nem tartalmaz hatóköröket a naplóiban. A hatókörök engedélyezéséhez ezt a beállítást explicit módon kell konfigurálnia a feldolgozóban. Az alábbi példa bemutatja, hogyan engedélyezheti a hatóköröket .NET izolált környezetben:

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

Hiányzó kérés telemetria

Az olyan eseményindítók, mint a HTTP, a Service Bus és az Event Hubs, az elosztott nyomkövetés környezetpropagálásától függenek. Ha a szülőalapú mintavételezés az alapértelmezett viselkedés, a kérés telemetriája nem jön létre, ha a bejövő kérés vagy üzenet nincs mintavételezésre.

Duplikált műveletazonosító

A Azure Functions a telemetriai adatok korrelálásához használt OperationId közvetlenül a bejövő kérés vagy üzenet traceparent értékéből származik. Ha több hívás is ugyanazt traceparent az értéket használja újra, mindegyik ugyanazt OperationIdkapja.

OpenTelemetria konfigurálása környezeti változókkal

Az OpenTelemetry viselkedését a szokásos környezeti változók használatával konfigurálhatja. Ezek a változók egységes módot biztosítanak a különböző nyelvek és futtatókörnyezetek viselkedésének szabályozására. Módosíthatja a mintavételezési stratégiákat, az exportőr beállításait és az erőforrás-attribútumokat. A támogatott környezeti változókkal kapcsolatos további információkért tekintse meg az OpenTelemetry dokumentációját.

Monitorozási problémák elhárítása diagnosztikák használatával

Azure Functions diagnosztika a Azure portálon hasznos forrás a lehetséges monitorozással kapcsolatos problémák észleléséhez és diagnosztizálására.

Diagnosztikához való hozzáférés az alkalmazásban:

  1. A Azure portálon lépjen a függvényalkalmazás erőforrására.

  2. A bal oldali panelen válassza a Problémák diagnosztizálása és megoldása lehetőséget, és keresse meg a Függvényalkalmazás hiányzó telemetriáját az Application Insights vagy az OpenTelemetry munkafolyamat esetében.

  3. Válassza ki ezt a munkafolyamatot, válassza ki a betöltési módszert, és válassza a Tovább lehetőséget.

  4. Tekintse át a hibaelhárító által megadott irányelveket és javaslatokat.

Következő lépések

További információ az OpenTelemetry-ről és az Azure Functions monitorozásáról:

  • Last updated on