Włączanie eksportera OpenTelemetry usługi Azure Monitor dla aplikacji .NET, Node.js i Python (wersja zapoznawcza)

Artykuł
05/02/2022
Czas czytania: 17 min

W tym artykule opisano sposób włączania i konfigurowania oferty usługi Azure Monitor opartej na usłudze OpenTelemetry w wersji zapoznawczej. Po zakończeniu instrukcji opisanych w tym artykule będziesz mieć możliwość wysyłania śladów biblioteki OpenTelemetry do Szczegółowe informacje aplikacji usługi Azure Monitor. Aby dowiedzieć się więcej o usłudze OpenTelemetry, zobacz Często zadawane pytania dotyczące platformy OpenTelemetry lub OpenTelemetry.

Ważne

Eksporter OpenTelemetry usługi Azure Monitor dla platformy .NET, Node.js i aplikacji języka Python jest obecnie w wersji zapoznawczej. Zobacz Dodatkowe warunki użytkowania wersji zapoznawczych platformy Microsoft Azure, aby zapoznać się z postanowieniami prawnymi dotyczącymi funkcji platformy Azure, które są w wersji beta lub wersji zapoznawczej albo w inny sposób nie zostały jeszcze wydane jako ogólnie dostępne.

Ograniczenia wersji zapoznawczej

Dokładnie zastanów się, czy ta wersja zapoznawcza jest odpowiednia dla Ciebie. Umożliwia tylko śledzenie rozproszone i wyklucza:

Interfejs API metryk (na przykład metryki niestandardowe i wstępnie zagregowane metryki)
Metryki na żywo
Interfejs API rejestrowania (na przykład dzienniki konsoli i biblioteki rejestrowania)
Automatyczne hermetyzacja nieobsługiwanych wyjątków
Profiler
Debuger migawek
Magazyn dysków w trybie offline i logika ponawiania prób
Uwierzytelnianie za pomocą usługi Azure Active Directory
Próbkowanie
Autopopulacji nazwy roli chmury i wystąpienia roli w chmurze w środowiskach platformy Azure
Autopopulacji identyfikatora użytkownika i uwierzytelnionego identyfikatora użytkownika podczas korzystania z zestawu SDK javaScript aplikacji Szczegółowe informacje
Autopopulacji adresu IP użytkownika (w celu określenia atrybutów lokalizacji)
Możliwość zastąpienia nazwy operacji
Możliwość ręcznego ustawiania identyfikatora użytkownika lub identyfikatora uwierzytelnionych użytkowników
Propagacja nazwy operacji na telemetrię zależności
Obsługa bibliotek instrumentacji w Azure Functions

Jeśli potrzebujesz pełnego środowiska funkcji, użyj istniejącej usługi Application Szczegółowe informacje ASP.NET lub ASP.NET Core SDK do czasu dojrzałej oferty opartej na protokole OpenTelemetry.

Rozpoczęcie pracy

Wykonaj kroki opisane w tej sekcji, aby instrumentować aplikację przy użyciu usługi OpenTelemetry.

Wymagania wstępne

Subskrypcja platformy Azure: bezpłatne tworzenie subskrypcji platformy Azure
Zasób Szczegółowe informacje aplikacji: tworzenie zasobu Szczegółowe informacje aplikacji

Aplikacja korzystająca z oficjalnie obsługiwanej wersji platformy .NET Core lub .NET Framework, która jest co najmniej .NET Framework 4.6.1

Instalowanie bibliotek klienckich

Zainstaluj najnowszy pakiet NuGet Azure.Monitor.OpenTelemetry.Exporter:

dotnet add package --prerelease Azure.Monitor.OpenTelemetry.Exporter

Jeśli wystąpi błąd, taki jak "Brak dostępnych wersji dla pakietu Azure.Monitor.OpenTelemetry.Exporter", prawdopodobnie brakuje ustawienia źródeł pakietów NuGet. Spróbuj określić źródło przy użyciu -s opcji :

# Install the latest package with the NuGet package source specified.
dotnet add package --prerelease Azure.Monitor.OpenTelemetry.Exporter -s https://api.nuget.org/v3/index.json

Zainstaluj następujące pakiety:

npm install @opentelemetry/sdk-trace-base
npm install @opentelemetry/sdk-trace-node
npm install @azure/monitor-opentelemetry-exporter

Następujące pakiety są również używane w przypadku niektórych konkretnych scenariuszy opisanych w dalszej części tego artykułu:

npm install @opentelemetry/api
npm install @opentelemetry/resources
npm install @opentelemetry/semantic-conventions
npm install @opentelemetry/instrumentation-http

Zainstaluj najnowszy pakiet PyPI azure-monitor-opentelemetry-exporter :

pip install azure-monitor-opentelemetry-exporter

Włączanie Szczegółowe informacje aplikacji usługi Azure Monitor

Ta sekcja zawiera wskazówki, które pokazują, jak włączyć funkcję OpenTelemetry.

Dodawanie kodu instrumentacji OpenTelemetry

Poniższy kod pokazuje, jak włączyć funkcję OpenTelemetry w aplikacji konsolowej języka C#, konfigurując element TracerProvider openTelemetry. Ten kod musi znajdować się w uruchamianiu aplikacji. W przypadku ASP.NET Core zazwyczaj odbywa się to w ConfigureServices metodzie klasy aplikacjiStartup. W przypadku ASP.NET aplikacji zazwyczaj odbywa się to w systemie Global.asax.cs.

using System.Diagnostics;
using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class Program
{
    private static readonly ActivitySource MyActivitySource = new ActivitySource(
        "OTel.AzureMonitor.Demo");

    public static void Main()
    {
        using var tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource("OTel.AzureMonitor.Demo")
            .AddAzureMonitorTraceExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        using (var activity = MyActivitySource.StartActivity("TestActivity"))
        {
            activity?.SetTag("CustomTag1", "Value1");
            activity?.SetTag("CustomTag2", "Value2");
        }

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

Uwaga

Klasy Activity i ActivitySource z System.Diagnostics przestrzeni nazw reprezentują odpowiednio pojęcia openTelemetry i SpanTracer. Można utworzyć ActivitySource bezpośrednio przy użyciu konstruktora, a nie za pomocą polecenia TracerProvider. Każda ActivitySource klasa musi być jawnie połączona TracerProvider z przy użyciu polecenia AddSource(). Wynika to z faktu, że części interfejsu API śledzenia OpenTelemetry są włączone bezpośrednio do środowiska uruchomieniowego platformy .NET. Aby dowiedzieć się więcej, zobacz Wprowadzenie do interfejsu API śledzenia platformy .NET openTelemetry.

Poniższy kod pokazuje, jak włączyć funkcję OpenTelemetry w prostej aplikacji Node.js:

const { AzureMonitorTraceExporter } = require("@azure/monitor-opentelemetry-exporter");
const { BatchSpanProcessor, Span } = require("@opentelemetry/sdk-trace-base");
const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");

const provider = new NodeTracerProvider();
provider.register();

// Create an exporter instance.
const exporter = new AzureMonitorTraceExporter({
  instrumentationKey: "<Your Connection String>"
});

// Add the exporter to the provider.
provider.addSpanProcessor(
  new BatchSpanProcessor(exporter, {
    bufferTimeout: 15000,
    bufferSize: 1000
  })
);
// Create a span. A span must be closed.
const parentSpan = tracer.startSpan("main");
for (let i = 0; i < 10; i += 1) {
   doWork(parentSpan);
}
// Be sure to end the span.
parentSpan.end();

function doWork(parent: Span) {
  // Start another span. In this example, the main method already started a
  // span, so that will be the parent span, and this will be a child span.
  const ctx = opentelemetry.trace.setSpan(opentelemetry.context.active(), parent);
  const span = tracer.startSpan("doWork", undefined, ctx);
  // Simulate some random work.
  for (let i = 0; i <= Math.floor(Math.random() * 40000000); i += 1) {
    // empty
  }
  // Set attributes to the span.
  span.setAttribute("key", "value");
  // Annotate our span to capture metadata about our operation.
  span.addEvent("invoking doWork");
  span.end();
}

Poniższy kod pokazuje, jak włączyć bibliotekę OpenTelemetry w prostej aplikacji języka Python:

import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

exporter = AzureMonitorTraceExporter.from_connection_string(
    "<Your Connection String>"
)

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

with tracer.start_as_current_span("hello"):
    print("Hello, World!")

Porada

Dodaj biblioteki instrumentacji do automatycznej telemetrii w popularnych strukturach i bibliotekach.

Ustawianie parametrów połączenia Szczegółowe informacje aplikacji

Zastąp symbol zastępczy <Your Connection String> w poprzednim kodzie parametrami połączenia z zasobu Application Szczegółowe informacje.

Screenshot of the Application Insights connection string.

Potwierdzanie przepływu danych

Uruchom aplikację i otwórz kartę Zasób Szczegółowe informacje aplikacji w Azure Portal. Wyświetlenie danych w portalu może potrwać kilka minut.

Uwaga

Jeśli nie możesz uruchomić aplikacji lub nie otrzymujesz danych zgodnie z oczekiwaniami, zobacz Rozwiązywanie problemów.

Screenshot of the Application Insights Overview tab with server requests and server response time highlighted.

Ważne

Jeśli masz co najmniej dwie usługi, które emitują dane telemetryczne do tego samego zasobu aplikacji Szczegółowe informacje, musisz ustawić nazwy ról w chmurze, aby reprezentować je prawidłowo na mapie aplikacji.

W ramach korzystania z instrumentacji Szczegółowe informacje aplikacji zbieramy i wysyłamy dane diagnostyczne do firmy Microsoft. Te dane ułatwiają uruchamianie i ulepszanie Szczegółowe informacje aplikacji. Możesz wyłączyć zbieranie danych bez wpływu. Aby dowiedzieć się więcej, zobacz Statystykibeat w aplikacja systemu Azure Szczegółowe informacje.

Ustawianie nazwy roli chmury i wystąpienia roli w chmurze

Możesz ustawić nazwę roli chmury i wystąpienie roli w chmurze za pomocą atrybutów zasobu . Ten krok aktualizuje nazwę roli chmury i wystąpienie roli chmury z ich wartości domyślnych do czegoś, co ma sens dla twojego zespołu. Zostaną one wyświetlone na mapie aplikacji jako nazwę poniżej węzła. Nazwa roli w chmurze używa atrybutów service.namespace i service.name , chociaż nie service.nameservice.namespace jest ustawiona. Wystąpienie roli w chmurze używa wartości atrybutu service.instance.id .

// Setting role name and role instance
var resourceAttributes = new Dictionary<string, object> {
    { "service.name", "my-service" },
    { "service.namespace", "my-namespace" },
    { "service.instance.id", "my-instance" }};
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);
// Done setting role name and role instance

// Set ResourceBuilder on the provider.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .SetResourceBuilder(resourceBuilder)
        .AddSource("OTel.AzureMonitor.Demo")
        .AddAzureMonitorTraceExporter(o =>
        {
            o.ConnectionString = "<Your Connection String>";
        })
        .Build();

...
import { NodeTracerProvider, NodeTracerConfig } from "@opentelemetry/sdk-trace-node";
import { Resource } from "@opentelemetry/resources";
import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";

// ----------------------------------------
// Setting role name and role instance
// ----------------------------------------
const config: NodeTracerConfig = {
        resource: new Resource({
            [SemanticResourceAttributes.SERVICE_NAME]: "my-helloworld-service",
            [SemanticResourceAttributes.SERVICE_NAMESPACE]: "my-namespace",
            [SemanticResourceAttributes.SERVICE_INSTANCE_ID]: "my-instance",
        }),
    };
// ----------------------------------------
// Done setting role name and role instance
// ----------------------------------------
const provider = new NodeTracerProvider(config);
...

...
from opentelemetry.sdk.resources import SERVICE_NAME, SERVICE_NAMESPACE, SERVICE_INSTANCE_ID, Resource
trace.set_tracer_provider(
    TracerProvider(
        resource=Resource.create(
            {
                SERVICE_NAME: "my-helloworld-service",
# ----------------------------------------
# Setting role name and role instance
# ----------------------------------------
                SERVICE_NAMESPACE: "my-namespace",
                SERVICE_INSTANCE_ID: "my-instance",
# ----------------------------------------------
# Done setting role name and role instance
# ----------------------------------------------
            }
        )
    )
)
...

Aby uzyskać informacje na temat standardowych atrybutów zasobów, zobacz Konwencje semantyczne zasobów.

Próbkowanie

Próbkowanie jest obsługiwane w programie OpenTelemetry, ale nie jest obecnie obsługiwane w eksporterze OpenTelemetry usługi Azure Monitor.

Ostrzeżenie

Włączenie próbkowania w usłudze OpenTelemetry sprawia, że standardowe i oparte na dziennikach metryki są bardzo niedokładne, co niekorzystnie wpływa na wszystkie środowiska Szczegółowe informacje aplikacji. Ponadto włączenie próbkowania obok istniejących zestawów SDK aplikacji Szczegółowe informacje powoduje uszkodzenie śladów.

Biblioteki instrumentacji

Następujące biblioteki są weryfikowane do pracy z wersją zapoznawcza.

Ostrzeżenie

Biblioteki instrumentacji są oparte na eksperymentalnych specyfikacjach OpenTelemetry. Zobowiązanie do pomocy technicznej firmy Microsoft w wersji zapoznawczej polega na upewnieniu się, że następujące biblioteki emitują dane do usługi Azure Monitor Application Szczegółowe informacje, ale istnieje możliwość, że zmiany powodujące niezgodność lub mapowanie eksperymentalne zablokują niektóre elementy danych.

HTTP

baza danych

SQL wersja klienta: 1.0.0-rc7

Uwaga

Oferta w wersji zapoznawczej obejmuje tylko instrumentacje obsługujące żądania HTTP i bazy danych. Aby dowiedzieć się więcej, zobacz OpenTelemetry Semantic Conventions (Konwencje semantyczne OpenTelemetry).

Modyfikowanie danych telemetrycznych

W tej sekcji opisano sposób modyfikowania danych telemetrycznych.

Dodawanie atrybutów zakresu

Aby dodać atrybuty zakresu, użyj jednego z następujących dwóch sposobów:

Użyj opcji udostępnianych przez biblioteki instrumentacji.
Dodaj niestandardowy procesor zakresu.

Te atrybuty mogą obejmować dodawanie właściwości niestandardowej do telemetrii. Możesz również użyć atrybutów, aby ustawić pola opcjonalne w schemacie Szczegółowe informacje aplikacji, na przykład adres IP klienta.

Porada

Zaletą korzystania z opcji udostępnianych przez biblioteki instrumentacji, gdy są dostępne, jest to, że cały kontekst jest dostępny. W związku z tym użytkownicy mogą wybrać opcję dodawania lub filtrowania większej liczby atrybutów. Na przykład opcja wzbogacania w bibliotece instrumentacji HttpClient zapewnia użytkownikom dostęp do samej funkcji httpRequestMessage. Mogą wybierać dowolne elementy i przechowywać je jako atrybut.

Dodawanie właściwości niestandardowej

Wszystkie atrybuty dodawane do zakresów są eksportowane jako właściwości niestandardowe. Wypełniają one pole customDimensions w tabelach żądań lub zależności w Szczegółowe informacje aplikacji.

Wiele bibliotek instrumentacji zapewnia opcję wzbogacania. Aby uzyskać wskazówki, zobacz pliki readme poszczególnych bibliotek instrumentacji:
Użyj niestandardowego procesora:

Porada

Dodaj procesor pokazany tutaj przed eksporterem usługi Azure Monitor.

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddProcessor(new ActivityEnrichingProcessor())
        .AddAzureMonitorTraceExporter(o =>
        {
                o.ConnectionString = "<Your Connection String>"
        })
        .Build();

Dodaj ActivityEnrichingProcessor.cs do projektu następujący kod:

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class ActivityEnrichingProcessor : BaseProcessor<Activity>
{
    public override void OnEnd(Activity activity)
    {
        // The updated activity will be available to all processors which are called after this processor.
        activity.DisplayName = "Updated-" + activity.DisplayName;
        activity.SetTag("CustomDimension1", "Value1");
        activity.SetTag("CustomDimension2", "Value2");
    }
}

Użyj niestandardowego procesora:

Porada

Dodaj procesor pokazany tutaj przed eksporterem usługi Azure Monitor.

import { AzureMonitorTraceExporter } from "@azure/monitor-opentelemetry-exporter";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { ReadableSpan, SimpleSpanProcessor, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";

class SpanEnrichingProcessor implements SpanProcessor{
    forceFlush(): Promise<void>{
        return Promise.resolve();
    }
    shutdown(): Promise<void>{
        return Promise.resolve();
    }
    onStart(_span: Span): void{}
    onEnd(span: ReadableSpan){
        span.attributes["CustomDimension1"] = "value1";
        span.attributes["CustomDimension2"] = "value2";
    }
}

const provider = new NodeTracerProvider();
const azureExporter = new AzureMonitorTraceExporter();
provider.addSpanProcessor(new SpanEnrichingProcessor());
provider.addSpanProcessor(new SimpleSpanProcessor(azureExporter));

Użyj niestandardowego procesora:

Porada

Dodaj procesor pokazany tutaj przed eksporterem usługi Azure Monitor.

...
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

trace.set_tracer_provider(TracerProvider())
span_processor = BatchSpanProcessor(exporter)
span_enrich_processor = SpanEnrichingProcessor()
trace.get_tracer_provider().add_span_processor(span_enrich_processor)
trace.get_tracer_provider().add_span_processor(span_processor)
...

Dodaj SpanEnrichingProcessor.py do projektu następujący kod:

from opentelemetry.sdk.trace import SpanProcessor

class SpanEnrichingProcessor(SpanProcessor):

    def on_end(self, span):
        span._name = "Updated-" + span.name
        span._attributes["CustomDimension1"] = "Value1"
        span._attributes["CustomDimension2"] = "Value2"

Ustawianie adresu IP użytkownika

Możesz wypełnić pole client_IP dla żądań, ustawiając http.client_ip atrybut na rozpiętości. Aplikacja Szczegółowe informacje używa adresu IP do generowania atrybutów lokalizacji użytkownika, a następnie domyślnie odrzuca je.

Użyj przykładu dodawania właściwości niestandardowej, ale zastąp następujące wiersze kodu w pliku ActivityEnrichingProcessor.cs:

// only applicable in case of activity.Kind == Server
activity.SetTag("http.client_ip", "<IP Address>");

Użyj przykładu dodawania właściwości niestandardowej, ale zastąp następujące wiersze kodu:

...
import { SemanticAttributes } from "@opentelemetry/semantic-conventions";

class SpanEnrichingProcessor implements SpanProcessor{
    ...

    onEnd(span: ReadableSpan){
        span.attributes[SemanticAttributes.HTTP_CLIENT_IP] = "<IP Address>";
    }
}

Użyj przykładu dodawania właściwości niestandardowej, ale zastąp następujące wiersze kodu w pliku SpanEnrichingProcessor.py:

span._attributes["http.client_ip"] = "<IP Address>"

Filtrowanie danych telemetrycznych

Aby odfiltrować dane telemetryczne przed opuszczeniem aplikacji, możesz użyć następujących sposobów.

Wiele bibliotek instrumentacji udostępnia opcję filtru. Aby uzyskać wskazówki, zobacz pliki readme poszczególnych bibliotek instrumentacji:

Użyj niestandardowego procesora:

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddProcessor(new ActivityFilteringProcessor())
        .AddAzureMonitorTraceExporter(o =>
        {
                o.ConnectionString = "<Your Connection String>"
        })
        .Build();

Dodaj ActivityFilteringProcessor.cs do projektu następujący kod:

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
    public override void OnStart(Activity activity)
    {
        // prevents all exporters from exporting internal activities
        if (activity.Kind == ActivityKind.Internal)
        {
            activity.IsAllDataRequested = false;
        }
    }
}

Jeśli określone źródło nie zostanie jawnie dodane przy użyciu polecenia AddSource("ActivitySourceName"), żadne z działań utworzonych przy użyciu tego źródła nie zostanie wyeksportowane.

Wyklucz opcję adresu URL udostępnianą przez wiele bibliotek instrumentacji HTTP.

W poniższym przykładzie pokazano, jak wykluczyć określony adres URL z śledzenia przy użyciu biblioteki instrumentacji HTTP/HTTPS:

...
import { HttpInstrumentation, HttpInstrumentationConfig } from "@opentelemetry/instrumentation-http";

...
const httpInstrumentationConfig: HttpInstrumentationConfig = {
    ignoreIncomingPaths: [new RegExp(/dc.services.visualstudio.com/i)]
};
const httpInstrumentation = new HttpInstrumentation(httpInstrumentationConfig);
provider.register();
registerInstrumentations({
    instrumentations: [
        httpInstrumentation,
    ]
});

Użyj niestandardowego procesora. Można użyć niestandardowego procesora zakresu, aby wykluczyć niektóre zakresy z eksportowanych. Aby oznaczyć zakresy, które nie mają być eksportowane, ustaw wartość TraceFlagDEFAULT. Użyj przykładu dodawania właściwości niestandardowej, ale zastąp następujące wiersze kodu:
```
...
import { SpanKind, TraceFlags } from "@opentelemetry/api";

class SpanEnrichingProcessor implements SpanProcessor{
    ...

    onEnd(span: ReadableSpan) {
        if(span.kind == SpanKind.INTERNAL){
            span.spanContext().traceFlags = TraceFlags.NONE;
        }
    }
}
```

Wyklucz opcję adresu URL udostępnianą przez wiele bibliotek instrumentacji HTTP.

W poniższym przykładzie pokazano, jak wykluczyć określony adres URL z śledzenia przy użyciu instrumentacji platformy Flask :

...
import flask

from opentelemetry.instrumentation.flask import FlaskInstrumentor

# You might also populate OTEL_PYTHON_FLASK_EXCLUDED_URLS env variable
# List will consist of comma delimited regexes representing which URLs to exclude
excluded_urls = "client/.*/info,healthcheck"

FlaskInstrumentor().instrument(excluded_urls=excluded_urls) # Do this before flask.Flask
app = flask.Flask(__name__)
...

Użyj niestandardowego procesora. Można użyć niestandardowego procesora zakresu, aby wykluczyć niektóre zakresy z eksportowanych. Aby oznaczyć zakresy, które nie mają być eksportowane, ustaw wartość TraceFlagDEFAULT.

...
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

trace.set_tracer_provider(TracerProvider())
span_processor = BatchSpanProcessor(exporter)
span_filter_processor = SpanFilteringProcessor()
trace.get_tracer_provider().add_span_processor(span_filter_processor)
trace.get_tracer_provider().add_span_processor(span_processor)
...

Dodaj SpanFilteringProcessor.py do projektu następujący kod:

from opentelemetry.trace import SpanContext, SpanKind, TraceFlags
from opentelemetry.sdk.trace import SpanProcessor

class SpanFilteringProcessor(SpanProcessor):

    # prevents exporting spans from internal activities
    def on_start(self, span):
        if span._kind is SpanKind.INTERNAL:
            span._context = SpanContext(
                span.context.trace_id,
                span.context.span_id,
                span.context.is_remote,
                TraceFlags.DEFAULT,
                span.context.trace_state,
            )

Włączanie eksportera OTLP

Możesz włączyć eksportera OpenTelemetry Protocol (OTLP) wraz z eksporterem usługi Azure Monitor w celu wysłania danych telemetrycznych do dwóch lokalizacji.

Uwaga

Eksporter OTLP jest wyświetlany tylko dla wygody. Nie obsługujemy oficjalnie eksportera OTLP ani żadnych składników ani środowisk innych firm podrzędnych. Zalecamy otwarcie problemu z problemami openTelemetry-Collector dla openTelemetry spoza granicy pomoc techniczna platformy Azure.

Zainstaluj pakiet OpenTelemetry.Exporter.OpenTelemetryProtocol wraz z elementem Azure.Monitor.OpenTelemetry.Exporter w projekcie.

Dodaj następujący fragment kodu. W tym przykładzie przyjęto założenie, że masz moduł zbierający OpenTelemetry z uruchomionym odbiornikiem OTLP. Aby uzyskać szczegółowe informacje, zobacz przykład dotyczący GitHub.

// Sends data to Application Insights as well as OTLP
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddAzureMonitorTraceExporter(o =>
        {
            o.ConnectionString = "<Your Connection String>"
        })
        .AddOtlpExporter()
        .Build();

Zainstaluj pakiet eksportera modułu zbierającego OpenTelemetry OpenTelemetry w usłudze OpenTelemetry usługi Azure Monitor w projekcie.
```
    npm install @opentelemetry/exporter-otlp-http
    npm install @azure/monitor-opentelemetry-exporter
```

const { BasicTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-http');

const provider = new BasicTracerProvider();
const azureMonitorExporter = new AzureMonitorTraceExporter({
  instrumentationKey: os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
});
const otlpExporter = new OTLPTraceExporter();
provider.addSpanProcessor(new SimpleSpanProcessor(azureMonitorExporter));
provider.addSpanProcessor(new SimpleSpanProcessor(otlpExporter));
provider.register();

Zainstaluj pakiety azure-monitor-opentelemetry-exporter i opentelemetry-exporter-otlp .

from opentelemetry import trace 

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__) 

exporter = AzureMonitorTraceExporter.from_connection_string(
    "<Your Connection String>"
)
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317")
span_processor = BatchSpanProcessor(otlp_exporter) 
trace.get_tracer_provider().add_span_processor(span_processor)

with tracer.start_as_current_span("test"):
    print("Hello world!")

Rozwiązywanie problemów

Ta sekcja zawiera pomoc dotyczącą rozwiązywania problemów.

Włączanie rejestrowania diagnostycznego

Eksporter usługi Azure Monitor używa usługi EventSource do rejestrowania wewnętrznego. Dzienniki eksportera są dostępne dla dowolnego elementu EventListener, decydując się na źródło o nazwie OpenTelemetry-AzureMonitor-Exporter. Aby uzyskać informacje na temat kroków rozwiązywania problemów, zobacz Rozwiązywanie problemów z funkcją OpenTelemetry.

Eksporter usługi Azure Monitor używa rejestratora interfejsu API OpenTelemetry do dzienników wewnętrznych. Aby ją włączyć, użyj następującego kodu:

const { diag, DiagConsoleLogger, DiagLogLevel } = require("@opentelemetry/api");
const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");

const provider = new NodeTracerProvider();
diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ALL);
provider.register();

Eksporter usługi Azure Monitor używa standardowej biblioteki rejestrowania języka Python na potrzeby własnego rejestrowania wewnętrznego. Dzienniki eksportera interfejsu API OpenTelemetry i eksportera usługi Azure Monitor są zwykle rejestrowane na poziomie ważności OSTRZEŻENIE lub BŁĄD w przypadku nieregularnej aktywności. Poziom ważności INFO jest używany do regularnego lub pomyślnego działania. Domyślnie biblioteka rejestrowania języka Python ustawia poziom ważności na OSTRZEŻENIE, więc musisz zmienić poziom ważności, aby wyświetlić dzienniki w ramach tego ustawienia ważności. W poniższym przykładzie pokazano, jak wyświetlić dzienniki wszystkich poziomów ważności w konsoli i pliku:

...
import logging

logging.basicConfig(format="%(asctime)s:%(levelname)s:%(message)s", level=logging.DEBUG)

logger = logging.getLogger(__name__)
file = logging.FileHandler("example.log")
stream = logging.StreamHandler()
logger.addHandler(file)
logger.addHandler(stream)
...

Znane problemy

Znane problemy dotyczące eksporterów OpenTelemetry usługi Azure Monitor obejmują:

Brak nazwy operacji na telemetrii zależności, co niekorzystnie wpływa na błędy i działanie karty wydajności.
Brak modelu urządzenia w przypadku danych telemetrycznych żądań i zależności, które niekorzystnie wpływają na analizę kohort urządzeń.
Nazwa serwera bazy danych jest pominięta w nazwie zależności, która niepoprawnie agreguje tabele o tej samej nazwie na różnych serwerach.

Pomoc techniczna

Aby uzyskać pomoc techniczną:

Zapoznaj się z krokami rozwiązywania problemów w tym artykule.
W przypadku pomoc techniczna platformy Azure problemów otwórz bilet pomoc techniczna platformy Azure.

W przypadku problemów z usługą OpenTelemetry skontaktuj się bezpośrednio ze społecznością platformy .NET openTelemetry .

Opinie dotyczące usługi OpenTelemetry

Aby przekazać opinię:

Wypełnij ankietę opinii klientów społeczności OpenTelemetry.
Poinformuj firmę Microsoft o sobie, dołączając do Community openTelemetry Early Adopter.
Skontaktuj się z innymi użytkownikami usługi Azure Monitor w witrynie Microsoft Tech Community.
Wyślij żądanie funkcji na forum opinii na temat platformy Azure.

Następne kroki

Aby przejrzeć kod źródłowy, zobacz repozytorium GitHub eksportera usługi Azure Monitor.
Aby zainstalować pakiet NuGet, sprawdź dostępność aktualizacji lub wyświetl informacje o wersji, zobacz stronę pakiet NuGet eksportera usługi Azure Monitor.
Aby lepiej poznać Szczegółowe informacje aplikacji usługi Azure Monitor i bibliotekę OpenTelemetry, zobacz Przykładowa aplikacja usługi Azure Monitor.
Aby dowiedzieć się więcej na temat technologii OpenTelemetry i jej społeczności, zobacz repozytorium openTelemetry .NET GitHub.
Aby włączyć obsługę użycia, włącz monitorowanie użytkowników sieci Web lub przeglądarki.

Włączanie eksportera OpenTelemetry usługi Azure Monitor dla aplikacji .NET, Node.js i Python (wersja zapoznawcza)

Czy ta strona jest pomocna?

Ograniczenia wersji zapoznawczej

Rozpoczęcie pracy

Wymagania wstępne

Instalowanie bibliotek klienckich

Włączanie Szczegółowe informacje aplikacji usługi Azure Monitor

Dodawanie kodu instrumentacji OpenTelemetry

Ustawianie parametrów połączenia Szczegółowe informacje aplikacji

Potwierdzanie przepływu danych

Ustawianie nazwy roli chmury i wystąpienia roli w chmurze

Próbkowanie

Biblioteki instrumentacji

HTTP

baza danych

Modyfikowanie danych telemetrycznych

Dodawanie atrybutów zakresu

Dodawanie właściwości niestandardowej

Ustawianie adresu IP użytkownika

Filtrowanie danych telemetrycznych

Włączanie eksportera OTLP

Rozwiązywanie problemów

Włączanie rejestrowania diagnostycznego

Znane problemy

Pomoc techniczna

Opinie dotyczące usługi OpenTelemetry

Następne kroki