Dela via

Migrera från .NET Application Insights SDK:er till Azure Monitor OpenTelemetry

  • Artikel

Den här guiden innehåller stegvisa instruktioner för att migrera olika .NET-program från att använda Application Insights-programutvecklingspaket (SDK:er) till Azure Monitor OpenTelemetry.

Förvänta dig en liknande upplevelse med Azure Monitor OpenTelemetry-instrumentation som med Application Insights SDK:er. Mer information och en jämförelse av funktioner finns i versionstillstånd för funktioner.

Om du kommer igång med Application Insights och inte behöver migrera från det klassiska API:et läser du Aktivera Azure Monitor OpenTelemetry.

Förutsättningar

  • Ett ASP.NET Core-webbprogram som redan har instrumenterats med Application Insights utan några anpassningar
  • En version av .NET som stöds aktivt

Dricks

Vår produktgrupp söker aktivt feedback om den här dokumentationen. Ge feedback till otel@microsoft.com eller se avsnittet Support .

Ta bort Application Insights SDK

Kommentar

Innan du fortsätter med de här stegen bör du bekräfta att du har en aktuell säkerhetskopia av programmet.

  1. Ta bort NuGet-paket

    Microsoft.ApplicationInsights.AspNetCore Ta bort paketet från .csproj

    dotnet remove package Microsoft.ApplicationInsights.AspNetCore

  2. Ta bort initieringskod och anpassningar

    Ta bort alla referenser till Application Insights-typer i din kodbas.

    Dricks

    När du har tagit bort Application Insights-paketet kan du återskapa ditt program för att hämta en lista med referenser som måste tas bort.

    • Ta bort Application Insights från din ServiceCollection genom att ta bort följande rad:

      builder.Services.AddApplicationInsightsTelemetry();

    • Ta bort avsnittet ApplicationInsights från .appsettings.json

      {
    "ApplicationInsights": {
        "ConnectionString": "<Your Connection String>"
    }
}

  3. Rensa och skapa

    Kontrollera din bin-katalog för att verifiera att alla referenser till Microsoft.ApplicationInsights.* har tagits bort.

  4. Testa ditt program

    Kontrollera att programmet inte har några oväntade konsekvenser.

Dricks

Vår produktgrupp söker aktivt feedback om den här dokumentationen. Ge feedback till otel@microsoft.com eller se avsnittet Support .

Aktivera OpenTelemetry

Vi rekommenderar att du skapar en utvecklingsresurs och använder dess anslutningssträng när du följer dessa instruktioner.

Skärmbild som visar Översikt över Application Insights och anslutningssträng.

Planera att uppdatera anslutningssträng för att skicka telemetri till den ursprungliga resursen när du har bekräftat att migreringen har slutförts.

  1. Installera Azure Monitor-distributionen

    Vår Azure Monitor-distribution möjliggör automatisk telemetri genom att inkludera OpenTelemetry-instrumentationsbibliotek för insamling av spårningar, mått, loggar och undantag, och tillåter insamling av anpassad telemetri.

    När du installerar Azure Monitor Distro får OpenTelemetry SDK som ett beroende.

    dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore

  2. Lägga till och konfigurera både OpenTelemetry och Azure Monitor

    OpenTelemery SDK måste konfigureras vid programstart som en del av , ServiceCollectionvanligtvis i Program.cs.

    OpenTelemetry har begreppet tre signaler; Spårningar, mått och loggar. Azure Monitor Distro konfigurerar var och en av dessa signaler.

Program.cs

Följande kodexempel visar grunderna.

using Azure.Monitor.OpenTelemetry.AspNetCore;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // Call AddOpenTelemetry() to add OpenTelemetry to your ServiceCollection.
        // Call UseAzureMonitor() to fully configure OpenTelemetry.
        builder.Services.AddOpenTelemetry().UseAzureMonitor();

        var app = builder.Build();
        app.MapGet("/", () => "Hello World!");
        app.Run();
    }
}

Vi rekommenderar att du ställer in anslutningssträngen i en miljövariabel:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Fler alternativ för att konfigurera anslutningssträngen beskrivs här: Konfigurera Application Insights-anslutningssträngen.

Dricks

Vår produktgrupp söker aktivt feedback om den här dokumentationen. Ge feedback till otel@microsoft.com eller se avsnittet Support .

Installera och konfigurera instrumentationsbibliotek

Instrumentationsbibliotek kan läggas till i projektet för automatisk insamling av telemetri om specifika komponenter eller beroenden.

Följande bibliotek ingår i distributionen.

Anpassa instrumentationsbibliotek

Azure Monitor Distro innehåller .NET OpenTelemetry-instrumentation för ASP.NET Core, HttpClient och SQLClient. Du kan anpassa dessa inkluderade instrumentationer eller manuellt lägga till extra instrumentation på egen hand med hjälp av OpenTelemetry-API:et.

Här följer några exempel på hur du anpassar instrumentationen:

Anpassa AspNetCoreTraceInstrumentationOptions
builder.Services.AddOpenTelemetry().UseAzureMonitor();
builder.Services.Configure<AspNetCoreTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.Filter = (httpContext) =>
    {
        // only collect telemetry about HTTP GET requests
        return HttpMethods.IsGet(httpContext.Request.Method);
    };
});
Anpassa HttpClientTraceInstrumentationOptions
builder.Services.AddOpenTelemetry().UseAzureMonitor();
builder.Services.Configure<HttpClientTraceInstrumentationOptions>(options =>
{
    options.RecordException = true;
    options.FilterHttpRequestMessage = (httpRequestMessage) =>
    {
        // only collect telemetry about HTTP GET requests
        return HttpMethods.IsGet(httpRequestMessage.Method.Method);
    };
});
Anpassa SqlClientInstrumentationOptions

Vi skapar SQLClient-instrumentationen i vårt paket medan den fortfarande är i betaversion. När den når en stabil version tar vi med den som en standardpaketreferens. Tills dess lägger du till paketreferensen till projektet och använder dess offentliga API för att anpassa SQLClient-instrumentationen OpenTelemetry.Instrumentation.SqlClient .

dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient

builder.Services.AddOpenTelemetry().UseAzureMonitor().WithTracing(builder =>
{
    builder.AddSqlClientInstrumentation(options =>
    {
        options.SetDbStatementForStoredProcedure = false;
    });
});

Konfigurera Azure Monitor

Application Insights erbjöd många fler konfigurationsalternativ via ApplicationInsightsServiceOptions.

Application Insights-inställning OpenTelemetry Alternativ
AddAutoCollectedMetricExtractor Ej tillämpligt
ApplicationVersion Ange "service.version" på Resurs
ConnectionString Se anvisningar om hur du konfigurerar anslutningssträngen.
DependencyCollectionOptions Saknas. Om du vill anpassa beroenden läser du de tillgängliga konfigurationsalternativen för tillämpliga instrumentationsbibliotek.
DeveloperMode Ej tillämpligt
EnableActiveTelemetryConfigurationSetup Ej tillämpligt
EnableAdaptiveSampling Saknas. Endast fast sampling stöds.
EnableAppServicesHeartbeatTelemetryModule Ej tillämpligt
EnableAuthenticationTrackingJavaScript Ej tillämpligt
AktiveraAzureInstanceMetadataTelemetryModule Ej tillämpligt
EnableDependencyTrackingTelemetryModule Se instruktioner för filtrering av spårningar.
EnableDiagnosticsTelemetryModule Ej tillämpligt
EnableEventCounterCollectionModule Ej tillämpligt
EnableHeartbeat Ej tillämpligt
EnablePerformanceCounterCollectionModule Ej tillämpligt
EnableQuickPulseMetricStream AzureMonitorOptions.EnableLiveMetrics
EnableRequestTrackingTelemetryModule Se instruktioner för filtrering av spårningar.
EndpointAddress Använd ConnectionString.
InstrumentationKey Använd ConnectionString.
RequestCollectionOptions Saknas. Se Alternativ för OpenTelemetry.Instrumentation.AspNetCore.

Ta bort anpassade konfigurationer

Följande scenarier är valfria och gäller endast för avancerade användare.

  • Om du har fler referenser till TelemetryClient, som kan användas för att manuellt registrera telemetri, bör de tas bort.

  • Om du har lagt till någon anpassad filtrering eller berikning i form av en anpassad TelemetryProcessor eller TelemetryInitializer, bör de tas bort. De finns i din ServiceCollection.

    builder.Services.AddSingleton<ITelemetryInitializer, MyCustomTelemetryInitializer>();

    builder.Services.AddApplicationInsightsTelemetryProcessor<MyCustomTelemetryProcessor>();

  • Ta bort JavaScript-kodfragment

    Om du använde kodfragmentet som tillhandahålls av Application Insights .NET SDK måste det också tas bort. Fullständiga kodexempel på vad du vill ta bort finns i guiden aktivera telemetri på klientsidan för webbprogram.

    Om du har lagt till JavaScript SDK för att samla in telemetri på klientsidan kan den också tas bort även om den fortsätter att fungera utan .NET SDK. Fullständiga kodexempel på vad du vill ta bort finns i registreringsguiden för JavaScript SDK.

  • Ta bort alla Visual Studio-artefakter

    Om du använde Visual Studio för att registrera dig för Application Insights kan du ha fler filer kvar i projektet.

    • Properties/ServiceDependencies -katalogen kan ha en referens till application insights-resursen.

Dricks

Vår produktgrupp söker aktivt feedback om den här dokumentationen. Ge feedback till otel@microsoft.com eller se avsnittet Support .

Vanliga frågor och svar

Det här avsnittet är till för kunder som använder telemetriinitierare eller processorer, eller skriver anpassad kod mot det klassiska Application Insights-API:et för att skapa anpassad telemetri.

Hur mappar SDK-API:et till OpenTelemetry-begrepp?

OpenTelemetry är ett leverantörsneutralt observerbarhetsramverk. Det finns inga Application Insights-API:er i OpenTelemetry SDK eller bibliotek. Innan du migrerar är det viktigt att förstå några av OpenTelemetrys begrepp.

  • I Application Insights hanterades all telemetri via en enda TelemetryClient och TelemetryConfiguration. I OpenTelemetry har var och en av de tre telemetrisignalerna (spårningar, mått och loggar) sin egen konfiguration. Du kan skapa telemetri manuellt via .NET-körningen utan externa bibliotek. Mer information finns i .NET-guiderna för distribuerad spårning, mått och loggning.

  • Application Insights används TelemetryModules för att automatiskt samla in telemetri för ditt program. I stället använder OpenTelemetry Instrumentation-bibliotek för att samla in telemetri från specifika komponenter (till exempel AspNetCore för begäranden och HttpClient för beroenden).

  • Application Insights används TelemetryInitializers för att utöka telemetri med ytterligare information eller för att åsidosätta egenskaper. Med OpenTelemetry kan du skriva en processor för att anpassa en specifik signal. Dessutom erbjuder många OpenTelemetry Instrumentation-bibliotek en Enrich metod för att anpassa telemetrin som genereras av den specifika komponenten.

  • Application Insights används TelemetryProcessors för att filtrera telemetri. En OpenTelemetry-processor kan också användas för att tillämpa filtreringsregler på en specifik signal.

Hur mappas Application Insights-telemetrityper till OpenTelemetry?

Den här tabellen mappar Application Insights-datatyper till OpenTelemetry-begrepp och deras .NET-implementeringar.

Azure Monitor-tabell Application Insights DataType OpenTelemetry DataType .NET-implementering
customEvents EventTelemetry Saknas Saknas
customMetrics MetricTelemetry Mått System.Diagnostics.Metrics.Meter
beroenden DependencyTelemetry Intervall (klient, intern, konsument) System.Diagnostics.Activity
undantag ExceptionTelemetry Undantag System.Exception
begäranden RequestTelemetry Intervall (server, producent) System.Diagnostics.Activity
spårningar TraceTelemetry Loggar Microsoft.Extensions.Logging.ILogger

Följande dokument innehåller mer information.

Hur mappar Application Insights-samplingsbegrepp till OpenTelemetry?

Application Insights erbjöd flera alternativ för att konfigurera sampling, men Azure Monitor Exporter eller Azure Monitor Distro erbjuder endast sampling med fast hastighet. Endast begäranden och beroenden (OpenTelemetry Traces) kan samplas.

Kodexempel som beskriver hur du konfigurerar sampling finns i vår guide Aktivera sampling

Hur mappas telemetriprocessorer och initierare till OpenTelemetry?

I Application Insights .NET SDK använder du telemetriprocessorer för att filtrera och ändra eller ta bort telemetri. Använd telemetriinitierare för att lägga till eller ändra anpassade egenskaper. Mer information finns i Dokumentation om Azure Monitor. OpenTelemetry ersätter dessa begrepp med aktivitets- eller loggprocessorer som berikar och filtrerar telemetri.

Filtrera spårningar

Om du vill filtrera telemetridata i OpenTelemetry kan du implementera en aktivitetsprocessor. Det här exemplet motsvarar Application Insights-exemplet för filtrering av telemetridata enligt beskrivningen i Azure Monitor-dokumentationen. Exemplet visar var misslyckade beroendeanrop filtreras.

using System.Diagnostics;
using OpenTelemetry;

internal sealed class SuccessfulDependencyFilterProcessor : BaseProcessor<Activity>
{
    public override void OnEnd(Activity activity)
    {
        if (!OKtoSend(activity))
        {
            activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded;
        }
    }

    private bool OKtoSend(Activity activity)
    {
        return activity.Kind == ActivityKind.Client && activity.Status == ActivityStatusCode.Ok;
    }
}

Om du vill använda den här processorn måste du skapa en TracerProvider och lägga till processorn före AddAzureMonitorTraceExporter.

using OpenTelemetry.Trace;

public static void Main()
{
    var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddProcessor(new SuccessfulDependencyFilterProcessor())
        .AddAzureMonitorTraceExporter()
        .Build();
}

Filtrera loggar

ILogger implementeringar har en inbyggd mekanism för att tillämpa loggfiltrering. Med den här filtreringen kan du styra loggarna som skickas till varje registrerad provider, inklusive OpenTelemetryLoggerProvider. "OpenTelemetry" är aliaset för OpenTelemetryLoggerProvider, som används för att konfigurera filtreringsregler.

I följande exempel definieras "Fel" som standard LogLevel och "Varning" definieras som minimum LogLevel för en användardefinierad kategori. Dessa regler som definieras gäller endast för OpenTelemetryLoggerProvider.

builder.AddFilter<OpenTelemetryLoggerProvider>("*", LogLevel.Error);
builder.AddFilter<OpenTelemetryLoggerProvider>("MyProduct.MyLibrary.MyClass", LogLevel.Warning);

Mer information finns i OpenTelemetry .NET-dokumentationen om loggar.

Lägga till anpassade egenskaper i spårningar

I OpenTelemetry kan du använda aktivitetsprocessorer för att utöka telemetridata med fler egenskaper. Det liknar att använda telemetriinitierare i Application Insights, där du kan ändra telemetriegenskaper.

Som standard flaggar Azure Monitor Exporter alla HTTP-begäranden med en svarskod på 400 eller senare som misslyckade. Men om du vill behandla 400 som ett lyckat resultat kan du lägga till en berikande aktivitetsprocessor som anger lyckad aktivitet och lägger till en tagg för att inkludera fler telemetriegenskaper. Det liknar att lägga till eller ändra egenskaper med hjälp av en initierare i Application Insights enligt beskrivningen i Azure Monitor-dokumentationen.

Här är ett exempel på hur du lägger till anpassade egenskaper och åsidosätter standardbeteendet för vissa svarskoder:

using System.Diagnostics;
using OpenTelemetry;

/// <summary>
/// Custom Processor that overrides the default behavior of treating response codes >= 400 as failed requests.
/// </summary>
internal class MyEnrichingProcessor : BaseProcessor<Activity>
{
    public override void OnEnd(Activity activity)
    {
        if (activity.Kind == ActivityKind.Server)
        {
            int responseCode = GetResponseCode(activity);

            if (responseCode >= 400 && responseCode < 500)
            {
                // If we set the Success property, the SDK won't change it
                activity.SetStatus(ActivityStatusCode.Ok);

                // Allow to filter these requests in the portal
                activity.SetTag("Overridden400s", "true");
            }

            // else leave the SDK to set the Success property
        }
    }

    private int GetResponseCode(Activity activity)
    {
        foreach (ref readonly var tag in activity.EnumerateTagObjects())
        {
            if (tag.Key == "http.response.status_code" && tag.Value is int value)
            {
                return value;
            }
        }

        return 0;
    }
}

Om du vill använda den här processorn måste du skapa en TracerProvider och lägga till processorn före AddAzureMonitorTraceExporter.

using OpenTelemetry.Trace;

public static void Main()
{
    var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("Company.Product.Name")
        .AddProcessor(new MyEnrichingProcessor())
        .AddAzureMonitorTraceExporter()
        .Build();
}

Hur gör jag för att spåra telemetri manuellt med OpenTelemetry?

Skicka spårningar – manuell

Spårningar i Application Insights lagras som RequestTelemetry och DependencyTelemetry. I OpenTelemetry modelleras spårningar som Span att använda Activity klassen.

OpenTelemetry .NET använder ActivitySource klasserna och Activity för spårning, som ingår i .NET-körningen. Den här metoden är distinkt eftersom .NET-implementeringen integrerar spårnings-API:et direkt i själva körningen. Paketet System.Diagnostics.DiagnosticSource gör att utvecklare kan använda ActivitySource för att skapa och hantera Activity instanser. Den här metoden ger ett sömlöst sätt att lägga till spårning i .NET-program utan att förlita sig på externa bibliotek, med hjälp av de inbyggda funktionerna i .NET-ekosystemet. Mer detaljerad information finns i genomgången av distribuerade spårningsinstrument.

Så här migrerar du manuell spårning:

Kommentar

I Application Insights kan rollnamnet och rollinstansen anges på per telemetrinivå. Med Azure Monitor Exporter kan vi dock inte anpassa på per telemetrinivå. Rollnamnet och rollinstansen extraheras från OpenTelemetry-resursen och tillämpas på all telemetri. Läs det här dokumentet om du vill ha mer information: Ange namnet på molnrollen och molnrollinstansen.

DependencyTelemetry

Application Insights DependencyTelemetry används för att modellera utgående begäranden. Så här konverterar du den till OpenTelemetry:

Application Insights-exempel:

DependencyTelemetry dep = new DependencyTelemetry
{
   Name = "DependencyName",
   Data = "https://www.example.com/",
   Type = "Http",
   Target = "www.example.com",
   Duration = TimeSpan.FromSeconds(10),
   ResultCode = "500",
   Success = false
};

dep.Context.Cloud.RoleName = "MyRole";
dep.Context.Cloud.RoleInstance = "MyRoleInstance";
dep.Properties["customprop1"] = "custom value1";
client.TrackDependency(dep);

OpenTelemetry-exempel:

var activitySource = new ActivitySource("Company.Product.Name");
var resourceAttributes = new Dictionary<string, object>
{
   { "service.name", "MyRole" },
   { "service.instance.id", "MyRoleInstance" }
};

var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
  .SetResourceBuilder(resourceBuilder)
  .AddSource(activitySource.Name)
  .AddAzureMonitorTraceExporter()
  .Build();

// Emit traces
using (var activity = activitySource.StartActivity("DependencyName", ActivityKind.Client))
{
  activity?.SetTag("url.full", "https://www.example.com/");
  activity?.SetTag("server.address", "www.example.com");
  activity?.SetTag("http.request.method", "GET");
  activity?.SetTag("http.response.status_code", "500");
  activity?.SetTag("customprop1", "custom value1");
  activity?.SetStatus(ActivityStatusCode.Error);
  activity?.SetEndTime(activity.StartTimeUtc.AddSeconds(10));
}

RequestTelemetry

Application Insights modellerar RequestTelemetry inkommande begäranden. Så här migrerar du den till OpenTelemetry:

Application Insights-exempel:

RequestTelemetry req = new RequestTelemetry
{
   Name = "RequestName",
   Url = new Uri("http://example.com"),
   Duration = TimeSpan.FromSeconds(10),
   ResponseCode = "200",
   Success = true,
   Properties = { ["customprop1"] = "custom value1" }
};

req.Context.Cloud.RoleName = "MyRole";
req.Context.Cloud.RoleInstance = "MyRoleInstance";
client.TrackRequest(req);

OpenTelemetry-exempel:

var activitySource = new ActivitySource("Company.Product.Name");
var resourceAttributes = new Dictionary<string, object>
{
   { "service.name", "MyRole" },
   { "service.instance.id", "MyRoleInstance" }
};

var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
  .SetResourceBuilder(resourceBuilder)
  .AddSource(activitySource.Name)
  .AddAzureMonitorTraceExporter()
  .Build();

// Emit traces
using (var activity = activitySource.StartActivity("RequestName", ActivityKind.Server))
{
  activity?.SetTag("url.scheme", "https");
  activity?.SetTag("server.address", "www.example.com");
  activity?.SetTag("url.path", "/");
  activity?.SetTag("http.response.status_code", "200");
  activity?.SetTag("customprop1", "custom value1");
  activity?.SetStatus(ActivityStatusCode.Ok);
}

Spårning av anpassade åtgärder

I Application Insights spårar du anpassade åtgärder med hjälp av StartOperation och StopOperation metoder. Uppnå det med hjälp av ActivitySource och Activity i OpenTelemetry .NET. För åtgärder med ActivityKind.Server och ActivityKind.Consumergenererar Azure Monitor Exporter RequestTelemetry. För ActivityKind.Client, ActivityKind.Produceroch ActivityKind.Internalgenererar DependencyTelemetryden . Mer information om spårning av anpassade åtgärder finns i Dokumentation om Azure Monitor. Mer information om hur du använder ActivitySource och Activity i .NET finns i genomgångarna för .NET-distribuerade spårningsinstrumentation.

Här är ett exempel på hur du startar och stoppar en aktivitet för anpassade åtgärder:

using System.Diagnostics;
using OpenTelemetry;

var activitySource = new ActivitySource("Company.Product.Name");

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource(activitySource.Name)
    .AddAzureMonitorTraceExporter()
    .Build();

// Start a new activity
using (var activity = activitySource.StartActivity("CustomOperation", ActivityKind.Server))
{
    activity?.SetTag("customTag", "customValue");

    // Perform your custom operation logic here

    // No need to explicitly call Activity.Stop() because the using block automatically disposes the Activity object, which stops it.
}

Skicka loggar

Loggar i Application Insights lagras som TraceTelemetry och ExceptionTelemetry.

TraceTelemetry

I OpenTelemetry integreras loggning via ILogger gränssnittet. Så här migrerar TraceTelemetrydu :

Application Insights-exempel:

TraceTelemetry traceTelemetry = new TraceTelemetry
{
   Message = "hello from tomato 2.99",
   SeverityLevel = SeverityLevel.Warning,
};

traceTelemetry.Context.Cloud.RoleName = "MyRole";
traceTelemetry.Context.Cloud.RoleInstance = "MyRoleInstance";
client.TrackTrace(traceTelemetry);

OpenTelemetry-exempel:

var resourceAttributes = new Dictionary<string, object>
{
   { "service.name", "MyRole" },
   { "service.instance.id", "MyRoleInstance" }
};

var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);

using var loggerFactory = LoggerFactory.Create(builder => builder
   .AddOpenTelemetry(logging =>
   {
       logging.SetResourceBuilder(resourceBuilder);
       logging.AddAzureMonitorLogExporter();
   }));

// Create a new instance `ILogger` from the above LoggerFactory
var logger = loggerFactory.CreateLogger<Program>();

// Use the logger instance to write a new log
logger.FoodPrice("tomato", 2.99);

internal static partial class LoggerExtensions
{
    [LoggerMessage(LogLevel.Warning, "Hello from `{name}` `{price}`.")]
    public static partial void FoodPrice(this ILogger logger, string name, double price);
}
ExceptionTelemetry

Application Insights använder ExceptionTelemetry för att logga undantag. Så här migrerar du till OpenTelemetry:

Application Insights-exempel:

ExceptionTelemetry exceptionTelemetry = new ExceptionTelemetry(new Exception("Test exception"))
{
    SeverityLevel = SeverityLevel.Error
};

exceptionTelemetry.Context.Cloud.RoleName = "MyRole";
exceptionTelemetry.Context.Cloud.RoleInstance = "MyRoleInstance";
exceptionTelemetry.Properties["customprop1"] = "custom value1";
client.TrackException(exceptionTelemetry);

OpenTelemetry-exempel:

var resourceAttributes = new Dictionary<string, object>
{
   { "service.name", "MyRole" },
   { "service.instance.id", "MyRoleInstance" }
};

var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);

using var loggerFactory = LoggerFactory.Create(builder => builder
   .AddOpenTelemetry(logging =>
   {
       logging.SetResourceBuilder(resourceBuilder);
       logging.AddAzureMonitorLogExporter();
   }));

// Create a new instance `ILogger` from the above LoggerFactory.
var logger = loggerFactory.CreateLogger<Program>();

try
{
    // Simulate exception
    throw new Exception("Test exception");
}
catch (Exception ex)
{
    logger?.LogError(ex, "An error occurred");
}

Skicka mått

Mått i Application Insights lagras som MetricTelemetry. I OpenTelemetry modelleras Meter mått som System.Diagnostics.DiagnosticSource från paketet.

Application Insights har både icke-föraggregering (TrackMetric()) och föraggregering (GetMetric().TrackValue()) mått-API:er. Till skillnad från OpenTelemetry har Application Insights ingen uppfattning om instrument. Application Insights har samma API för alla måttscenarier.

OpenTelemetry å andra sidan kräver att användarna först väljer rätt måttinstrument baserat på måttets faktiska semantik. Om avsikten till exempel är att räkna något (t.ex. antalet totala serverbegäranden som tagits emot osv.) ska OpenTelemetry Counter användas. Om avsikten är att beräkna olika percentiler (t.ex. P99-värdet för serverfördröjning) bör OpenTelemetry Histogram-instrument användas. På grund av den här grundläggande skillnaden mellan Application Insights och OpenTelemetry görs ingen direkt jämförelse mellan dem.

Till skillnad från Application Insights tillhandahåller OpenTelemetry inte inbyggda mekanismer för att berika eller filtrera mått. I Application Insights kan telemetriprocessorer och initiatorer användas för att ändra eller ta bort mått, men den här funktionen är inte tillgänglig i OpenTelemetry.

Dessutom har OpenTelemetry inte stöd för att skicka råmått direkt, eftersom det inte finns någon motsvarighet till de TrackMetric() funktioner som finns i Application Insights.

Att migrera från Application Insights till OpenTelemetry innebär att ersätta alla Application Insights Metric API-användningar med OpenTelemetry-API:et. Det kräver förståelse för de olika OpenTelemetry-instrumenten och deras semantik.

Dricks

Histogrammet är den mest mångsidiga och närmaste motsvarigheten till Application Insights-API GetMetric().TrackValue() :et. Du kan ersätta Application Insights Metric API:er med Histogram för att uppnå samma syfte.

Andra telemetrityper

CustomEvents

Stöds inte i OpenTelemetry.

Application Insights-exempel:

TelemetryClient.TrackEvent()
TillgänglighetTelemetri

Stöds inte i OpenTelemetry.

Application Insights-exempel:

TelemetryClient.TrackAvailability()
PageViewTelemetry

Stöds inte i OpenTelemetry.

Application Insights-exempel:

TelemetryClient.TrackPageView()

Kan jag hämta livemått för konsol- och arbetstjänstprogram?

Vi rekommenderar Azure Monitor OpenTelemetry Exporter för konsol- och arbetstjänstprogram, som inte innehåller livemått.

Nästa steg

Dricks

Vår produktgrupp söker aktivt feedback om den här dokumentationen. Ge feedback till otel@microsoft.com eller se avsnittet Support .

Support