Udostępnij za pośrednictwem

Dodawanie i modyfikowanie usługi Azure Monitor OpenTelemetry dla aplikacji .NET, Java, Node.js i Python

Ten przewodnik zawiera instrukcje dotyczące integrowania i dostosowywania instrumentacji OpenTelemetry (OTel) w usłudze Azure Monitor Application Insights.

Aby dowiedzieć się więcej na temat pojęć związanych z platformą OpenTelemetry, zobacz Temat OpenTelemetry overview (Omówienie usługi OpenTelemetry) lub OpenTelemetry FAQ (Często zadawane pytania dotyczące platformy OpenTelemetry).

Uwaga

W przypadku aplikacji funkcji platformy Azure zobacz Use OpenTelemetry with Azure Functions (Używanie funkcji OpenTelemetry z usługą Azure Functions).

Automatyczne zbieranie danych

Dystrybucje automatycznie zbierają dane, dołączając biblioteki instrumentacji OpenTelemetry.

Dołączone biblioteki narzędziowe

Żądania

Zależności

Rejestrowanie

  • ILogger

Aby zmniejszyć lub zwiększyć liczbę dzienników wysyłanych do usługi Azure Monitor, skonfiguruj rejestrowanie, aby ustawić odpowiedni poziom dziennika lub zastosować filtry. Na przykład możesz zdecydować się na wysyłanie tylko dzienników Warning i Error do usługi OpenTelemetry/Azure Monitor. OpenTelemetry nie kontroluje routingu ani filtrowania dzienników — to Twoja ILogger konfiguracja podejmuje te decyzje. Aby uzyskać więcej informacji na temat konfigurowania ILogger, zobacz Konfigurowanie rejestrowania.

Aby uzyskać więcej informacji na temat ILogger, zobacz Logowanie w C# i .NET oraz przykłady kodu.

Przypisy

  • ¹: Obsługuje automatyczne raportowanie nieobsłużonych/nieprzechwyconych wyjątków
  • ²: Obsługuje metryki OpenTelemetry

Uwaga

Dystrybucje OpenTelemetry usługi Azure Monitor obejmują mapowanie niestandardowe i logikę, aby automatycznie emitować standardowe metryki usługi Application Insights.

Napiwek

Wszystkie metryki OpenTelemetry, niezależnie od tego, czy są automatycznie zbierane z bibliotek instrumentacji, czy ręcznie zbierane z niestandardowego kodowania, są obecnie traktowane jako "metryki niestandardowe" usługi Application Insights na potrzeby rozliczeń. Dowiedz się więcej.

Dodaj bibliotekę instrumentacji społecznościowej

Więcej danych można zbierać automatycznie, dołączając biblioteki instrumentacji ze społeczności OpenTelemetry.

Uwaga

Nie wspieramy ani nie gwarantujemy jakości bibliotek instrumentacji społecznych. Aby zasugerować coś dla naszej dystrybucji, opublikuj post lub zagłosuj w naszej społeczności opinii. Należy pamiętać, że niektóre są oparte na eksperymentalnych specyfikacjach OpenTelemetry i mogą wprowadzać przyszłe zmiany powodujące problemy z kompatybilnością.

Aby dodać bibliotekę społeczności, najpierw dodaj pakiet NuGet dla biblioteki, a następnie użyj metod ConfigureOpenTelemetryMeterProvider lub ConfigureOpenTelemetryTracerProvider.

W poniższym przykładzie pokazano, jak można dodać instrumentację środowiska uruchomieniowego w celu zbierania dodatkowych metryk.

dotnet add package OpenTelemetry.Instrumentation.Runtime 

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add runtime instrumentation.
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddRuntimeInstrumentation());

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Narzędzia do wykrywania zasobów

Narzędzia do wykrywania zasobów odnajdują metadane środowiska podczas uruchamiania i wypełniają atrybuty zasobów OpenTelemetry, takie jak service.name, cloud.provider i cloud.resource_id. Te meta dane zasilają funkcje w usłudze Application Insights, takie jak Mapa aplikacji i łączenie obliczeń, i poprawiają korelację między śladami, metrykami i dziennikami.

Napiwek

Atrybuty zasobów opisują proces i jego środowisko. Atrybuty span opisują jedną operację. Użyj atrybutów zasobów dla właściwości na poziomie aplikacji, takich jak service.name.

Obsługiwane środowiska

Środowisko Jak działa wykrywanie Notatki
Azure App Service SDK języka lub dystrybucja Azure Monitor odczytuje te dobrze znane zmienne środowiskowe usługi App Service oraz metadane hosta. Współpracuje z platformami .NET, Java, Node.js i Python, gdy korzystasz ze wskazówek w tym artykule.
Azure Functions Zobacz instrukcje dotyczące usługi Azure Functions OpenTelemetry Wszystkie wskazówki dotyczące usługi Azure Functions znajdują się tam.
Azure Virtual Machines Zestaw SDK języka lub dystrybucja wysyła zapytania do usługi Azure Instance Metadata Service Upewnij się, że maszyna wirtualna ma dostęp do punktu końcowego usługi Instance Metadata Service.
Azure Kubernetes Service (AKS) Użyj procesora k8sattributes OpenTelemetry Collector, aby dodać metadane platformy Kubernetes Zalecane dla wszystkich języków działających w AKS.
Azure Container Apps Detektory mapują zmienne środowiskowe i identyfikatory zasobów, gdy są dostępne Można również ustawić OTEL_RESOURCE_ATTRIBUTES, aby wypełnić luki.

Instrumentacja ręczna i automatyczna

  • Automatyczna instrumentacja i dystrybutywy Azure Monitor umożliwiają wykrywanie zasobów podczas uruchamiania w obsługiwanych środowiskach platformy Azure.

  • W przypadku instalacji ręcznych można ustawić atrybuty zasobów bezpośrednio przy użyciu standardowych opcji OpenTelemetry:

    # Applies to .NET (ASP.NET/ASP.NET Core), Java, Node.js, and Python
export OTEL_SERVICE_NAME="my-service"
export OTEL_RESOURCE_ATTRIBUTES="cloud.provider=azure,cloud.region=westus,cloud.resource_id=/subscriptions/<SUB>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<APP>"

    W programie Windows PowerShell:

    $Env:OTEL_SERVICE_NAME="my-service"
$Env:OTEL_RESOURCE_ATTRIBUTES="cloud.provider=azure,cloud.region=westus,cloud.resource_id=/subscriptions/<SUB>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<APP>"

Zagadnienia dotyczące przetwarzania OTLP

  • Usługa Application Insights używa service.name do uzyskania nazwy roli chmury. Wybierz stabilną nazwę dla usługi, aby uniknąć fragmentowanych węzłów na mapie aplikacji.
  • cloud.resource_id usprawnia łączenie zasobów obliczeniowych z zasobami platformy Azure. Jeśli brakuje tego atrybutu, niektóre środowiska mogą nie wyświetlać zasobu platformy Azure, który wygenerował dane.

Zbieraj niestandardowe dane telemetryczne

W tej sekcji opisano sposób zbierania niestandardowych danych telemetrycznych z aplikacji.

W zależności od języka i typu sygnału istnieją różne sposoby zbierania niestandardowych danych telemetrycznych, w tym:

  • OpenTelemetry API
  • Językowe biblioteki logowania i metryk
  • Klasyczny interfejs API usługi Application Insights

Uwaga

Micrometer Tracing API dla języka Java nie jest wspierane.

W poniższej tabeli przedstawiono obecnie obsługiwane niestandardowe typy telemetrii:

Język Zdarzenia niestandardowe Metryki niestandardowe Zależności Wyjątki Widoki stron Żądania Ślady
ASP.NET Rdzeń
   OpenTelemetry API Tak Tak Tak Tak
    ILogger Interfejs Programowania Aplikacji (API) Tak
   Klasyczny interfejs API sztucznej inteligencji
Jawa
   OpenTelemetry API Tak Tak Tak Tak
   Logback, Log4j, JUL Tak Tak
   Metryki mikrometryczne Tak
   Klasyczny interfejs API sztucznej inteligencji Tak Tak Tak Tak Tak Tak Tak
Node.js
   OpenTelemetry API Tak Tak Tak Tak
Pyton
   OpenTelemetry API Tak Tak Tak Tak
   Moduł rejestrowania języka Python Tak
   Rozszerzenie wydarzeń Tak Tak

Uwaga

Usługi Application Insights Java 3.x i Application Insights Node.js 3.x zbierają dane telemetryczne z klasycznego interfejsu API usługi Application Insights. To zachowanie upraszcza uaktualnianie i tymczasowo obsługuje telemetrię niestandardową, dopóki interfejs API OpenTelemetry nie zawiera wszystkich niestandardowych typów telemetrii.

Dodawanie metryk niestandardowych

W tym kontekście termin metryk niestandardowych odnosi się do ręcznego instrumentowania kodu w celu zbierania dodatkowych metryk poza tym, co biblioteki instrumentacji OpenTelemetry automatycznie zbierają. Aby dowiedzieć się więcej na temat korzystania z metryk, zobacz Metryki w usłudze Application Insights.

Interfejs API OpenTelemetry oferuje sześć narzędzi do pracy z metrykami, które obejmują różnorodne scenariusze metryk. Należy wybrać odpowiedni typ agregacji podczas wizualizacji metryk w narzędziu Metrics Explorer. To wymaganie ma zastosowanie podczas używania interfejsu API metryk OpenTelemetry do wysyłania danych i korzystania z biblioteki do instrumentacji.

W poniższej tabeli przedstawiono zalecane typy agregacji dla każdego z instrumentów metryk OpenTelemetry.

Narzędzie OpenTelemetry Typ agregacji usługi Azure Monitor
Licznik Suma
Licznik asynchroniczny Suma
Histogram Minimalna, Maksymalna, Średnia, Suma i Liczba
Miernik asynchroniczny Średnia
UpDownCounter Suma
Asynchroniczny licznik góra-dół Suma

Uwaga

W większości przypadków inne typy agregacji nie mają znaczenia.

Specyfikacja OpenTelemetry opisuje instrumenty i zawiera przykłady użycia każdego z nich.

Napiwek

Histogram jest najbardziej wszechstronny i najbardziej zbliżony do klasycznego interfejsu API Application Insights GetMetric. Usługa Azure Monitor obecnie spłaszcza instrument histogramu do pięciu obsługiwanych przez nas typów agregacji, a wsparcie dla percentyli jest w trakcie realizacji. Chociaż mniej wszechstronny, inne instrumenty OpenTelemetry mają mniejszy wpływ na wydajność aplikacji.

Przykład histogramu

Proces uruchamiania aplikacji musi zarejestrować się do miernika według nazwy.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Element Meter musi zostać zainicjowany przy użyciu tej samej nazwy:

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new histogram metric named "FruitSalePrice".
Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

// Create a new Random object.
var rand = new Random();

// Record a few random sale prices for apples and lemons, with different colors.
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "green"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));

Kontrprzykład

Proces uruchamiania aplikacji musi zarejestrować się do miernika według nazwy.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Element Meter musi zostać zainicjowany przy użyciu tej samej nazwy:

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new counter metric named "MyFruitCounter".
Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

// Record the number of fruits sold, grouped by name and color.
myFruitCounter.Add(1, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(2, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(1, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(2, new("name", "apple"), new("color", "green"));
myFruitCounter.Add(5, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(4, new("name", "lemon"), new("color", "yellow"));

Przykład miernika

Proces uruchamiania aplikacji musi zarejestrować się do miernika według nazwy.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Element Meter musi zostać zainicjowany przy użyciu tej samej nazwy:

// Get the current process.
var process = Process.GetCurrentProcess();

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new observable gauge metric named "Thread.State".
// This metric will track the state of each thread in the current process.
ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

private static IEnumerable<Measurement<int>> GetThreadState(Process process)
{
    // Iterate over all threads in the current process.
    foreach (ProcessThread thread in process.Threads)
    {
        // Create a measurement for each thread, including the thread state, process ID, and thread ID.
        yield return new((int)thread.ThreadState, new("ProcessId", process.Id), new("ThreadId", thread.Id));
    }
}

Dodawanie wyjątków niestandardowych

Wybrane biblioteki instrumentacji automatycznie zgłaszają wyjątki do usługi Application Insights. Można jednak ręcznie zgłaszać wyjątki, które nie są raportowane przez biblioteki instrumentacji. Na przykład wyjątki, które twój kod przechwytuje, nie są zwykle zgłaszane. Możesz zgłosić je, aby zwrócić uwagę na odpowiednie doświadczenia, w tym sekcję błędów i całościowe widoki transakcji.

  • Aby zarejestrować wyjątek przy użyciu działania:

    // Start a new activity named "ExceptionExample".
using (var activity = activitySource.StartActivity("ExceptionExample"))
{
    // Try to execute some code.
    try
    {
        throw new Exception("Test exception");
    }
    // If an exception is thrown, catch it and set the activity status to "Error".
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error);
        activity?.RecordException(ex);
    }
}

  • Aby zarejestrować wyjątek przy użyciu polecenia ILogger:

    // Create a logger using the logger factory. The logger category name is used to filter and route log messages.
var logger = loggerFactory.CreateLogger(logCategoryName);

// Try to execute some code.
try
{
    throw new Exception("Test Exception");
}
catch (Exception ex)
{
    // Log an error message with the exception. The log level is set to "Error" and the event ID is set to 0.
    // The log message includes a template and a parameter. The template will be replaced with the value of the parameter when the log message is written.
    logger.Log(
        logLevel: LogLevel.Error,
        eventId: 0,
        exception: ex,
        message: "Hello {name}.",
        args: new object[] { "World" });
}

Dodaj zakresy niestandardowe

Możesz dodać niestandardowy zakres w dwóch scenariuszach. Po pierwsze, gdy istnieje żądanie dotyczące zależności, które nie jest jeszcze zbierane przez bibliotekę instrumentacji. Po drugie, jeśli chcesz zaprezentować proces aplikacji jako przedział w pełnym widoku transakcji.

Uwaga

Klasy Activity i ActivitySource z przestrzeni nazw System.Diagnostics reprezentują pojęcia OpenTelemetry Span oraz Tracer. Można utworzyć ActivitySource bezpośrednio przy użyciu jego konstruktora zamiast przy użyciu TracerProvider. Każda ActivitySource klasa musi być jawnie połączona z TracerProvider przy użyciu AddSource(). Wynika to z faktu, że części interfejsu API śledzenia OpenTelemetry są dołączane bezpośrednio do środowiska uruchomieniowego platformy .NET. Aby dowiedzieć się więcej, zobacz Wprowadzenie do interfejsu API OpenTelemetry .NET Tracing.

// Define an activity source named "ActivitySourceName". This activity source will be used to create activities for all requests to the application.
internal static readonly ActivitySource activitySource = new("ActivitySourceName");

// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a source named "ActivitySourceName". This will ensure that all activities created by the activity source are traced.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

// Map a GET request to the root path ("/") to the specified action.
app.MapGet("/", () =>
{
    // Start a new activity named "CustomActivity". This activity will be traced and the trace data will be sent to Azure Monitor.
    using (var activity = activitySource.StartActivity("CustomActivity"))
    {
        // your code here
    }

    // Return a response message.
    return $"Hello World!";
});

// Start the ASP.NET Core application.
app.Run();

StartActivity wartość domyślna to ActivityKind.Internal, ale można podać dowolną inną ActivityKindwartość . ActivityKind.Client, ActivityKind.Produceri ActivityKind.Internal są mapowane na usługę Application Insights dependencies. ActivityKind.Server i ActivityKind.Consumer są mapowane na usługę Application Insights requests.

Wysyłanie zdarzeń niestandardowych

Usługa Application Insights przechowuje zdarzenia niestandardowe w customEvents tabeli. Jednym ze sposobów analizowania, filtrowania i wizualizowania ich jest użycie środowisk użycia usługi Application Insights.

Jeśli chcesz zautomatyzować zbieranie zdarzeń interakcji po stronie klienta, możesz użyć wtyczki w zestawie SDK języka JavaScript.

Zdarzenia niestandardowe są w publicznej wersji zapoznawczej i używają wersji Azure.Monitor.OpenTelemetry.AspNetCore 1.3.0-beta.3.

Ważne

Zobacz dodatkowe warunki użytkowania dla wersji zapoznawczych platformy Microsoft Azure, aby zapoznać się z postanowieniami prawnymi dotyczącymi funkcji platformy Azure, które są w wersji beta, wersji zapoznawczej lub w inny sposób nie zostały jeszcze wydane w wersji ogólnodostępnej.

Aby wysłać CustomEvent przy użyciu ILogger, ustaw atrybut "microsoft.custom_event.name" w szablonie wiadomości.

// Create a logger factory and configure OpenTelemetry with Azure Monitor
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddOpenTelemetry(options =>
        {
            options.AddAzureMonitorLogExporter();
        });
});

// Create a logger for the specified category
var logger = loggerFactory.CreateLogger(logCategoryName);

// Log a custom event with a custom name and additional attribute
// The 'microsoft.custom_event.name' value will be used as the name of the customEvent
logger.LogInformation("{microsoft.custom_event.name} {additional_attrs}", "test-event-name", "val1");

Modyfikowanie telemetrii

W tej sekcji opisano sposób modyfikowania danych telemetrycznych.

Dodawanie atrybutów rozpiętości

Te atrybuty mogą obejmować dodawanie właściwości niestandardowej do telemetrii. Atrybuty mogą również służyć do ustawiania pól opcjonalnych w schemacie usługi Application Insights, takich jak adres IP klienta.

Dodawanie właściwości niestandardowej do zakresu

Wszystkie atrybuty dodawane do zakresów są eksportowane jako właściwości niestandardowe. Wypełniają one pole customDimensions w tabeli żądań, zależności, śladów lub wyjątków.

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

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

Napiwek

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 wzbogacenia w bibliotece instrumentacji HttpClient zapewnia użytkownikom dostęp do HttpRequestMessage oraz samego HttpResponseMessage. Mogą wybrać dowolne elementy i zapisać je jako atrybut.

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

  2. Użyj niestandardowego procesora:

    Napiwek

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

    // Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a new processor named ActivityEnrichingProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityEnrichingProcessor()));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

// Start the ASP.NET Core application.
app.Run();

    Dodaj ActivityEnrichingProcessor.cs do swojego projektu, używając następującego kodu:

    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");
    }
}

Ustawianie adresu IP użytkownika

Pole client_IP dla żądań można wypełnić, ustawiając atrybut na rozpiętości. Usługa Application Insights używa adresu IP do generowania atrybutów lokalizacji użytkownika, a następnie domyślnie go odrzuca.

Użyj przykładu właściwości niestandardowej

// Add the client IP address to the activity as a tag.
// only applicable in case of activity.Kind == Server
activity.SetTag("client.address", "<IP Address>");

Ustawianie identyfikatora użytkownika lub uwierzytelnionego identyfikatora użytkownika

Możesz wypełnić pole user_Id lub user_AuthenticatedId dla żądań, korzystając z poniższych wskazówek. Identyfikator użytkownika to anonimowy identyfikator użytkownika. Uwierzytelniony identyfikator użytkownika jest znanym identyfikatorem użytkownika.

Ważne

Zanim ustawisz uwierzytelniony identyfikator użytkownika, zapoznaj się z obowiązującymi przepisami dotyczącymi ochrony prywatności.

Użyj przykładu właściwości niestandardowej:

// Add the user ID to the activity as a tag, but only if the activity is not null.
activity?.SetTag("enduser.id", "<User Id>");

Dodawanie atrybutów dziennika

OpenTelemetry używa elementu .NET ILogger. Dołączanie wymiarów niestandardowych do dzienników można wykonać przy użyciu szablonu komunikatu.

Pobierz identyfikator śledzenia lub identyfikator zakresu

Aby uzyskać Trace ID i Span ID dla aktualnie aktywnego zakresu, wykonaj następujące kroki.

Uwaga

Klasy Activity i ActivitySource z przestrzeni nazw System.Diagnostics reprezentują pojęcia OpenTelemetry Span oraz Tracer. Wynika to z faktu, że części interfejsu API śledzenia OpenTelemetry są dołączane bezpośrednio do środowiska uruchomieniowego platformy .NET. Aby dowiedzieć się więcej, zobacz Wprowadzenie do interfejsu API OpenTelemetry .NET Tracing.

// Get the current activity.
Activity activity = Activity.Current;
// Get the trace ID of the activity.
string traceId = activity?.TraceId.ToHexString();
// Get the span ID of the activity.
string spanId = activity?.SpanId.ToHexString();

Następne kroki

  • Last updated on