Lägga till, ändra och filtrera OpenTelemetry

  • Artikel

Den här artikeln innehåller vägledning om hur du lägger till, ändrar och filtrerar OpenTelemetry för program med Hjälp av Azure Monitor Application Insights.

Mer information om OpenTelemetry-begrepp finns i OpenTelemetry-översikten eller Vanliga frågor och svar om OpenTelemetry.

Automatisk datainsamling

Distributionerna samlar automatiskt in data genom att paketera OpenTelemetry-instrumentationsbibliotek.

Inkluderade instrumentationsbibliotek

begäranden

Beroenden

Loggning

  • ILogger

Mer information om ILoggerfinns i Loggning i C# och .NET och kodexempel.

Fotnoter

  • ¹: Stöder automatisk rapportering av ohanterade/ohanterade undantag
  • ²: Stöder OpenTelemetry-mått
  • ³: Som standard samlas loggning endast in på INFO-nivå eller högre. Information om hur du ändrar den här inställningen finns i konfigurationsalternativen.
  • ⁴: Som standard samlas loggning endast in när loggningen utförs på VARNING-nivån eller högre.

Kommentar

Azure Monitor OpenTelemetry Distros innehåller anpassad mappning och logik för att automatiskt generera Application Insights-standardmått.

Dricks

Alla OpenTelemetry-mått oavsett om de samlas in automatiskt från instrumentationsbibliotek eller manuella insamlade från anpassad kodning anses för närvarande vara Application Insights "anpassade mått" i faktureringssyfte. Läs mer.

Lägga till ett bibliotek för communityinstrumentation

Du kan samla in mer data automatiskt när du inkluderar instrumentationsbibliotek från OpenTelemetry-communityn.

Varning

Vi stöder inte eller garanterar inte kvaliteten på communityinstrumentationsbibliotek. Att föreslå en för vår distribution, post eller up-vote i vår feedback community. Tänk på att vissa baseras på experimentella OpenTelemetry-specifikationer och kan introducera framtida icke-bakåtkompatibla ändringar.

Om du vill lägga till ett community-bibliotek använder du ConfigureOpenTelemetryMeterProvider metoderna eller ConfigureOpenTelemetryTracerProvider när du har lagt till nuget-paketet för biblioteket.

I följande exempel visas hur Körningsinstrumentation kan läggas till för att samla in extra mått.

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

Samla in anpassad telemetri

I det här avsnittet beskrivs hur du samlar in anpassad telemetri från ditt program.

Beroende på språk och signaltyp finns det olika sätt att samla in anpassad telemetri, inklusive:

  • OpenTelemetry-API
  • Språkspecifika loggnings-/måttbibliotek
  • Klassiskt API för Application Insights

Följande tabell representerar de anpassade telemetrityper som stöds för närvarande:

Språk Anpassade händelser Anpassade mått Beroenden Undantag Sidvisningar begäranden Spårningar
ASP.NET Core
   OpenTelemetry-API Ja Ja Ja Ja
   ILogger API Ja
   KLASSISK API för AI
Java
   OpenTelemetry-API Ja Ja Ja Ja
   Logback, Log4j, JUL Ja Ja
   Mått för Micrometer Ja
   KLASSISK API för AI Ja Ja Ja Ja Ja Ja Ja
Node.js
   OpenTelemetry-API Ja Ja Ja Ja
Python
   OpenTelemetry-API Ja Ja Ja Ja
   Python-loggningsmodul Ja
   Händelsetillägg Ja Ja

Kommentar

Application Insights Java 3.x lyssnar efter telemetri som skickas till det klassiska API:et för Application Insights. På samma sätt samlar Application Insights Node.js 3.x in händelser som skapats med det klassiska API:et för Application Insights. Detta gör uppgraderingen enklare och fyller ett tomrum i vårt anpassade telemetristöd tills alla anpassade telemetrityper stöds via OpenTelemetry-API:et.

Lägga till anpassade mått

I det här sammanhanget refererar anpassade mått till att manuellt instrumentera koden för att samla in ytterligare mått utöver vad OpenTelemetry Instrumentation Libraries automatiskt samlar in.

OpenTelemetry-API:et erbjuder sex måttinstrument för olika måttscenarier och du måste välja rätt sammansättningstyp när du visualiserar mått i Metrics Explorer. Det här kravet gäller när du använder OPENTelemetry Metric API för att skicka mått och när du använder ett instrumentationsbibliotek.

I följande tabell visas de rekommenderade aggregeringstyperna för vart och ett av Måttinstrumenten för OpenTelemetry.

OpenTelemetry-instrument Sammansättningstyp för Azure Monitor
Räknare Sum
Asynkron räknare Sum
Histogram Min, Max, Genomsnitt, Summa och Antal
Asynkron mätare Genomsnitt
UpDownCounter Sum
Asynkron UpDownCounter Sum

Varning

Sammansättningstyper utöver vad som visas i tabellen är vanligtvis inte meningsfulla.

OpenTelemetry-specifikationen beskriver instrumenten och ger exempel på när du kan använda var och en.

Dricks

Histogrammet är det mest mångsidiga och närmaste motsvarigheten till Application Insights GetMetric Classic API. Azure Monitor plattar för närvarande ut histograminstrumentet till våra fem sammansättningstyper som stöds och stöd för percentiler pågår. Även om de är mindre mångsidiga har andra OpenTelemetry-instrument en mindre inverkan på programmets prestanda.

Histogramexempel

Programstart måste prenumerera på en mätare efter namn.

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

Meter Måste initieras med samma namn.

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

Räknarexempel

Programstart måste prenumerera på en mätare efter namn.

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

Meter Måste initieras med samma namn.

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

Mätarexempel

Programstart måste prenumerera på en mätare efter namn.

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

Meter Måste initieras med samma namn.

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

Lägga till anpassade undantag

Välj instrumentationsbibliotek rapporterar automatiskt undantag till Application Insights. Du kanske dock vill rapportera undantag manuellt utöver vilken rapport om instrumentationsbibliotek. Till exempel rapporteras undantag som fångas av koden vanligtvis inte. Du kanske vill rapportera dem för att uppmärksamma relevanta upplevelser, inklusive avsnittet fel och transaktionsvyer från slutpunkt till slutpunkt.

  • Så här loggar du ett undantag med hjälp av en aktivitet: 
    // 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);
    }
}
  • Så här loggar du ett undantag med :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" });
}

Lägga till anpassade intervall

Du kanske vill lägga till ett anpassat spann i två scenarier. Först när det finns en beroendebegäran som inte redan samlats in av ett instrumentationsbibliotek. För det andra, när du vill modellera en programprocess som ett spann i transaktionsvyn från slutpunkt till slutpunkt.

Kommentar

Klasserna Activity och ActivitySource från System.Diagnostics namnområdet representerar OpenTelemetry-begreppen Span för respektive Tracer. Du skapar ActivitySource direkt med konstruktorn i stället för med hjälp TracerProviderav . Varje ActivitySource klass måste uttryckligen anslutas till TracerProvider med hjälp AddSource()av . Det beror på att delar av OpenTelemetry-spårnings-API:et införlivas direkt i .NET-körningen. Mer information finns i Introduktion till OpenTelemetry .NET Tracing API.

// 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 standardvärdet är ActivityKind.Internal, men du kan ange andra ActivityKind. ActivityKind.Client, ActivityKind.Produceroch ActivityKind.Internal mappas till Application Insights dependencies. ActivityKind.Server och ActivityKind.Consumer mappas till Application Insights requests.

Skicka anpassad telemetri med det klassiska API:et för Application Insights

Vi rekommenderar att du använder OpenTelemetry-API:er när det är möjligt, men det kan finnas vissa scenarier när du måste använda det klassiska API:et för Application Insights.

Händelser

  1. Lägg till Microsoft.ApplicationInsights i ditt program.

  2. Skapa en TelemetryClient instans.

Kommentar

Det är viktigt att bara skapa en instans av TelemetryClient per program.

var telemetryConfiguration = new TelemetryConfiguration { ConnectionString = "" };
var telemetryClient = new TelemetryClient(telemetryConfiguration);
  1. Använd klienten för att skicka anpassad telemetri.
telemetryClient.TrackEvent("testEvent");

Ändra telemetri

I det här avsnittet beskrivs hur du ändrar telemetri.

Lägga till span-attribut

Dessa attribut kan vara att lägga till en anpassad egenskap i telemetrin. Du kan också använda attribut för att ange valfria fält i Application Insights-schemat, till exempel klient-IP.

Lägga till en anpassad egenskap i ett spann

Alla attribut som du lägger till i intervall exporteras som anpassade egenskaper. De fyller i fältet customDimensions i tabellen begäranden, beroenden, spårningar eller undantag.

Om du vill lägga till span-attribut använder du något av följande två sätt:

Dricks

Fördelen med att använda alternativ som tillhandahålls av instrumentationsbibliotek, när de är tillgängliga, är att hela kontexten är tillgänglig. Därför kan användarna välja att lägga till eller filtrera fler attribut. Till exempel ger alternativet berika i instrumentationsbiblioteket HttpClient användarna åtkomst till Själva HttpRequestMessage och Själva HttpResponseMessage . De kan välja vad som helst från den och lagra den som ett attribut.

  1. Många instrumentationsbibliotek ger ett berikande alternativ. Vägledning finns i readme-filerna för enskilda instrumentationsbibliotek:

  2. Använd en anpassad processor:

Dricks

Lägg till processorn som visas här innan du lägger till 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();

Lägg till ActivityEnrichingProcessor.cs i projektet med följande kod:

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

Ange användarens IP-adress

Du kan fylla i fältet client_IP för begäranden genom att ange ett attribut för intervallet. Application Insights använder IP-adressen för att generera attribut för användarplatser och tar sedan bort den som standard.

Använd exemplet lägg till anpassad egenskap, men ersätt följande kodrader i ActivityEnrichingProcessor.cs:

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

Ange användar-ID eller autentiserat användar-ID

Du kan fylla i fältet user_Id eller user_AuthenticatedId för begäranden med hjälp av följande vägledning. Användar-ID är en anonym användaridentifierare. Autentiserat användar-ID är en känd användaridentifierare.

Viktigt!

Läs gällande sekretesslagar innan du anger autentiserat användar-ID.

Använd exemplet lägg till anpassad egenskap.

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

Lägga till loggattribut

OpenTelemetry använder . NET:s ILogger. Det går att koppla anpassade dimensioner till loggar med hjälp av en meddelandemall.

Filtrera telemetri

Du kan använda följande sätt att filtrera bort telemetri innan den lämnar programmet.

  1. Många instrumentationsbibliotek tillhandahåller ett filteralternativ. Vägledning finns i readme-filerna för enskilda instrumentationsbibliotek:

  2. Använd en anpassad processor:

    Dricks

    Lägg till processorn som visas här innan du lägger till 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 ActivityFilteringProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityFilteringProcessor()));
// Configure the OpenTelemetry tracer provider to add a new source named "ActivitySourceName".
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();

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

    Lägg till ActivityFilteringProcessor.cs i projektet med följande kod:

    public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
    // The OnStart method is called when an activity is started. This is the ideal place to filter activities.
    public override void OnStart(Activity activity)
    {
        // prevents all exporters from exporting internal activities
        if (activity.Kind == ActivityKind.Internal)
        {
            activity.IsAllDataRequested = false;
        }
    }
}

  3. Om en viss källa inte uttryckligen läggs till med hjälp AddSource("ActivitySourceName")av exporteras ingen av de aktiviteter som skapas med den källan.

Hämta spårnings-ID:t eller span-ID:t

Du kanske vill hämta spårnings-ID:t eller span-ID:t. Om du har loggar som skickats till ett annat mål än Application Insights kan du överväga att lägga till spårnings-ID:t eller span-ID:t. Detta möjliggör bättre korrelation vid felsökning och diagnostisering av problem.

Kommentar

Klasserna Activity och ActivitySource från System.Diagnostics namnområdet representerar OpenTelemetry-begreppen Span för respektive Tracer. Det beror på att delar av OpenTelemetry-spårnings-API:et införlivas direkt i .NET-körningen. Mer information finns i Introduktion till OpenTelemetry .NET Tracing API.

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

Nästa steg

Vanliga frågor och svar

Det här avsnittet innehåller svar på vanliga frågor.

Vad är OpenTelemetry?

Det är en ny standard med öppen källkod för observerbarhet. Läs mer på OpenTelemetry.

Varför investerar Microsoft Azure Monitor i OpenTelemetry?

Microsoft är bland de största bidragsgivarna till OpenTelemetry.

De viktigaste värdeförslagen för OpenTelemetry är att det är leverantörsneutralt och ger konsekventa API:er/SDK:er mellan olika språk.

Med tiden tror vi att OpenTelemetry gör det möjligt för Azure Monitor-kunder att observera program som skrivits på språk utöver våra språk som stöds. Den utökar också de typer av data som du kan samla in via en omfattande uppsättning instrumentationsbibliotek. Dessutom tenderar OpenTelemetry SDK:er att vara mer högpresterande i stor skala än sina föregångare, Application Insights SDK:er.

Slutligen överensstämmer OpenTelemetry med Microsofts strategi att ta till sig öppen källkod.

Vad är statusen för OpenTelemetry?

Se Status för OpenTelemetry.

Vad är "Azure Monitor OpenTelemetry Distro"?

Du kan se det som en tunn omslutning som buntar ihop alla OpenTelemetry-komponenter för en förstklassig upplevelse i Azure. Den här omslutningen kallas även för en distribution i OpenTelemetry.

Varför ska jag använda "Azure Monitor OpenTelemetry Distro"?

Det finns flera fördelar med att använda Azure Monitor OpenTelemetry Distro över inbyggd OpenTelemetry från communityn:

I OpenTelemetrys anda utformade vi distributionen så att den var öppen och utökningsbar. Du kan till exempel lägga till:

  • En OpenTelemetry Protocol-exportör (OTLP) och skicka till ett andra mål samtidigt
  • Andra instrumentationsbibliotek som inte ingår i distributionen

Eftersom Distro tillhandahåller en OpenTelemetry-distribution stöder distributionen allt som stöds av OpenTelemetry. Du kan till exempel lägga till fler telemetriprocessorer, exportörer eller instrumentationsbibliotek om OpenTelemetry stöder dem.

Kommentar

Distributionen anger sampler till en anpassad, fast frekvensexempel för Application Insights. Du kan ändra detta till en annan provtagare, men om du gör det kan du inaktivera några av distributionsfunktionerna. Mer information om exempelprogrammet som stöds finns i avsnittet Aktivera sampling i Konfigurera Azure Monitor OpenTelemetry.

För språk utan en fristående OpenTelemetry-exportör som stöds är Azure Monitor OpenTelemetry Distro det enda sättet att använda OpenTelemetry med Azure Monitor. För språk med en fristående OpenTelemetry-exportör som stöds kan du använda antingen Azure Monitor OpenTelemetry Distro eller lämplig fristående OpenTelemetry-exportör beroende på ditt telemetriscenario. Mer information finns i När ska jag använda Azure Monitor OpenTelemetry-exportören?.

Hur kan jag testa Azure Monitor OpenTelemetry Distro?

Kolla in våra aktiveringsdokument för .NET, Java, JavaScript (Node.js) och Python.

Ska jag använda OpenTelemetry eller Application Insights SDK?

Vi rekommenderar att du använder OpenTelemetry Distro om du inte behöver en funktion som endast är tillgänglig med formell support i Application Insights SDK.

Att använda OpenTelemetry förhindrar nu att du behöver migrera vid ett senare tillfälle.

När ska jag använda Azure Monitor OpenTelemetry-exportören?

För ASP.NET Core, Java, Node.js och Python rekommenderar vi att du använder Azure Monitor OpenTelemetry Distro. Det är en kodrad för att komma igång.

För alla andra .NET-scenarier, inklusive klassiska ASP.NET, konsolappar osv., rekommenderar vi att du använder .NET Azure Monitor OpenTelemetry-exportören: Azure.Monitor.OpenTelemetry.Exporter.

För mer komplexa Python-telemetriscenarier som kräver avancerad konfiguration rekommenderar vi att du använder Python Azure Monitor OpenTelemetry Exporter.

Vad är det aktuella versionstillståndet för funktioner i Azure Monitor OpenTelemetry Distro?

Följande diagram delar upp funktionsstöd för OpenTelemetry för varje språk.

Funktion .NET Node.js Python Java
Distribuerad spårning ✅ ✅ ✅ ✅
Anpassade mått ✅ ✅ ✅ ✅
Standardmått (noggrannhet som för närvarande påverkas av sampling) ✅ ✅ ✅ ✅
Sampling med fast frekvens ✅ ✅ ✅ ✅
Offlinelagring och automatiska återförsök ✅ ✅ ✅ ✅
Undantagsrapportering ✅ ✅ ✅ ✅
Loggsamling ✅ ⚠️ ✅ ✅
Anpassade händelser ⚠️ ⚠️ ⚠️ ✅
Microsoft Entra-autentisering ✅ ✅ ✅ ✅
Live-mått ❌ ❌ ❌ ✅
Identifiera resurskontext för virtuell dator/VMSS och App Service ✅ ❌ ✅ ✅
Identifiera resurskontext för AKS och funktioner ❌ ❌ ❌ ✅
Filtrering av tillgänglighetstestintervall ❌ ❌ ❌ ✅
Automatisk inpopulation av användar-ID, autentiserat användar-ID och användar-IP ❌ ❌ ❌ ✅
Åsidosätt/ange åtgärdsnamn, användar-ID eller autentiserat användar-ID manuellt ❌ ❌ ❌ ✅
Adaptiv sampling ❌ ❌ ❌ ✅
Profilerare ❌ ❌ ❌ ⚠️
Felsökning av ögonblicksbild ❌ ❌ ❌ ❌

Tangent

  • ✅ Den här funktionen är tillgänglig för alla kunder med formell support.
  • ⚠️ Den här funktionen är tillgänglig som en offentlig förhandsversion. Se Kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.
  • ❌ Den här funktionen är inte tillgänglig eller är inte tillämplig.

Kan OpenTelemetry användas för webbläsare?

Ja, men vi rekommenderar det inte och Azure stöder det inte. OpenTelemetry JavaScript är mycket optimerat för Node.js. I stället rekommenderar vi att du använder Application Insights JavaScript SDK.

När kan vi förvänta oss att OpenTelemetry SDK ska vara tillgängligt för användning i webbläsare?

OpenTelemetry-webb-SDK:t har ingen fastställd tillgänglighetstidslinje. Vi är förmodligen flera år från en webbläsar-SDK som är ett genomförbart alternativ till Application Insights JavaScript SDK.

Kan jag testa OpenTelemetry i en webbläsare idag?

OpenTelemetry-webbsandlådan är en förgrening som utformats för att få OpenTelemetry att fungera i en webbläsare. Det går ännu inte att skicka telemetri till Application Insights. SDK:t definierar inte allmänna klienthändelser.

Stöds application insights tillsammans med konkurrerande agenter som AppDynamics, DataDog och NewRelic?

Nej. Den här metoden är inte något som vi planerar att testa eller stödja, även om våra distributioner gör att du kan exportera till en OTLP-slutpunkt tillsammans med Azure Monitor samtidigt.

Kan jag använda förhandsversionsfunktioner i produktionsmiljöer?

Vi rekommenderar det inte. Se Kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

Vad är skillnaden mellan manuell och automatisk instrumentering?

Se Översikt över OpenTelemetry.

Kan jag använda OpenTelemetry Collector?

Vissa kunder använder OpenTelemetry Collector som ett agentalternativ, även om Microsoft inte officiellt stöder en agentbaserad metod för programövervakning ännu. Under tiden bidrog communityn med öppen källkod med en OpenTelemetry Collector Azure Monitor-exportör som vissa kunder använder för att skicka data till Azure Monitor Application Insights. Detta stöds inte av Microsoft.

Vad är skillnaden mellan OpenCensus och OpenTelemetry?

OpenCensus är föregångaren till OpenTelemetry. Microsoft hjälpte till att samla OpenTracing och OpenCensus för att skapa OpenTelemetry, en enda observerbarhetsstandard för världen. Den aktuella produktionsrekommenderade Python SDK :t för Azure Monitor baseras på OpenCensus. Microsoft har åtagit sig att göra Azure Monitor baserat på OpenTelemetry.

Felsökning

Fungerar det inte? Kolla in felsökningssidan för ASP.NET Core.

Support

Välj en flik för det språk du väljer för att identifiera supportalternativ.

Feedback om OpenTelemetry

Så här ger du feedback: