Sdílet prostřednictvím

Migrace ze sad .NET Application Insights SDK na OpenTelemetry služby Azure Monitor

  • Článek

Tento průvodce obsahuje podrobné pokyny k migraci různých aplikací .NET z používání sad Sdk (Application Insights Software Development Kit) do Služby Azure Monitor OpenTelemetry.

Počítejte s podobným prostředím s instrumentací OpenTelemetry služby Azure Monitor jako u sad SDK Application Insights. Další informace a porovnání funkcí podle funkcí najdete v tématu Stav vydaných funkcí.

  • ASP.NET migrace core do distribuce OpenTelemetry služby Azure Monitor. (Azure.Monitor.OpenTelemetry.AspNetCore balíček NuGet)
  • ASP.NET, konzoly a migrace WorkerService do exportéru OpenTelemetry služby Azure Monitor. (Azure.Monitor.OpenTelemetry.Exporter balíček NuGet)

Pokud s Application Insights začínáte a nepotřebujete migrovat z klasického rozhraní API, přečtěte si téma Povolení OpenTelemetry služby Azure Monitor.

Požadavky

  • Webová aplikace ASP.NET Core už instrumentovaná pomocí Application Insights bez jakýchkoli vlastních nastavení
  • Aktivně podporovaná verze .NET

Tip

Naše produktová skupina aktivně hledá zpětnou vazbu k této dokumentaci. Poskytněte nám svůj názor nebo se podívejte do otel@microsoft.com části Podpora .

Odebrání sady Application Insights SDK

Poznámka:

Než budete pokračovat v těchto krocích, měli byste potvrdit, že máte aktuální zálohu aplikace.

  1. Odebrání balíčků NuGet

    Microsoft.ApplicationInsights.AspNetCore Odeberte balíček z vašeho csprojsouboru .

    dotnet remove package Microsoft.ApplicationInsights.AspNetCore

  2. Odebrání inicializačního kódu a přizpůsobení

    Odeberte všechny odkazy na typy Application Insights v základu kódu.

    Tip

    Po odebrání balíčku Application Insights můžete aplikaci znovu sestavit, abyste získali seznam odkazů, které je potřeba odebrat.

    • Odeberte Application Insights z aplikace ServiceCollection odstraněním následujícího řádku:

      builder.Services.AddApplicationInsightsTelemetry();

    • Odeberte oddíl ze svého appsettings.jsonoddílu ApplicationInsights .

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

  3. Vyčištění a sestavení

    Zkontrolujte adresář přihrádky a ověřte, že byly odebrány všechny odkazy Microsoft.ApplicationInsights.* .

  4. Otestování aplikace

    Ověřte, že vaše aplikace nemá neočekávané důsledky.

Tip

Naše produktová skupina aktivně hledá zpětnou vazbu k této dokumentaci. Poskytněte nám svůj názor nebo se podívejte do otel@microsoft.com části Podpora .

Povolení OpenTelemetry

Při provádění těchto pokynů doporučujeme vytvořit vývojový prostředek a použít jeho připojovací řetězec.

Snímek obrazovky znázorňující přehled a připojovací řetězec Application Insights

Po potvrzení úspěšné migrace naplánujte aktualizaci připojovací řetězec tak, aby odesílala telemetrii do původního prostředku.

  1. Instalace distribuce služby Azure Monitor

    Naše distribuce služby Azure Monitor umožňuje automatickou telemetrii zahrnutím knihoven instrumentace OpenTelemetry ke shromažďování trasování, metrik, protokolů a výjimek a umožňuje shromažďování vlastní telemetrie.

    Instalace distribuce služby Azure Monitor přináší sadu OpenTelemetry SDK jako závislost.

    dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore

  2. Přidání a konfigurace OpenTelemetry i Azure Monitoru

    Sada OpenTelemery SDK musí být nakonfigurována při spuštění aplikace jako součást vašeho ServiceCollectionsouboru , obvykle v nástroji Program.cs.

    OpenTelemetry má koncept tří signálů; Trasování, metriky a protokoly Distribuce služby Azure Monitor konfiguruje každý z těchto signálů.

Program.cs

Následující ukázka kódu ukazuje základy.

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

Doporučujeme nastavit připojovací řetězec v proměnné prostředí:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Další možnosti konfigurace připojovacího řetězce najdete tady: Nakonfigurujte připojovací řetězec Application Insights.

Tip

Naše produktová skupina aktivně hledá zpětnou vazbu k této dokumentaci. Poskytněte nám svůj názor nebo se podívejte do otel@microsoft.com části Podpora .

Instalace a konfigurace knihoven instrumentace

Knihovny instrumentace je možné do projektu přidat, aby se automaticky shromažďuje telemetrie o konkrétních komponentách nebo závislostech.

V distribucích jsou zahrnuté následující knihovny.

Přizpůsobení knihoven instrumentace

Distro služby Azure Monitor zahrnuje instrumentaci .NET OpenTelemetry pro ASP.NET Core, HttpClient a SQLClient. Tyto zahrnuté instrumentace můžete přizpůsobit nebo ručně přidat další instrumentaci sami pomocí rozhraní Api OpenTelemetry.

Tady je několik příkladů, jak instrumentaci přizpůsobit:

Přizpůsobení 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);
    };
});
Přizpůsobení 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);
    };
});
Přizpůsobení sqlClientInstrumentationOptions

Instrumentaci SQLClient v rámci našeho balíčku nabízíme, i když je stále v beta verzi. Když dosáhne stabilní verze, zahrneme ji jako standardní odkaz na balíček. Do té doby přidejte do projektu odkaz na balíček a použijte jeho veřejné rozhraní API, OpenTelemetry.Instrumentation.SqlClient abyste mohli přizpůsobit instrumentaci SQLClient.

dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient

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

Konfigurace služby Azure Monitor

Application Insights nabízí mnoho dalších možností konfigurace prostřednictvím ApplicationInsightsServiceOptions.

Nastavení Application Insights Alternativní řešení OpenTelemetry
AddAutoCollectedMetricExtractor –
ApplicationVersion Nastavení service.version u prostředku
ConnectionString Přečtěte si pokyny ke konfiguraci připojovacího řetězce.
DependencyCollectionOptions Není k dispozici. Pokud chcete přizpůsobit závislosti, projděte si dostupné možnosti konfigurace pro příslušné knihovny instrumentace.
DeveloperMode –
EnableActiveTelemetryConfigurationSetup –
EnableAdaptiveSampling Není k dispozici. Podporuje se pouze vzorkování s pevnou rychlostí.
EnableAppServicesHeartbeatTelemetryModule –
EnableAuthenticationTrackingJavaScript –
EnableAzureInstanceMetadataTelemetryModule –
EnableDependencyTrackingTelemetryModule Přečtěte si pokyny k filtrování trasování.
EnableDiagnosticsTelemetryModule –
EnableEventCounterCollectionModule –
EnableHeartbeat –
EnablePerformanceCounterCollectionModule –
EnableQuickPulseMetricStream AzureMonitorOptions.EnableLiveMetrics
EnableRequestTrackingTelemetryModule Přečtěte si pokyny k filtrování trasování.
EndpointAddress Použijte ConnectionString.
InstrumentationKey Použijte ConnectionString.
RequestCollectionOptions Není k dispozici. Viz možnosti OpenTelemetry.Instrumentation.AspNetCore.

Odebrání vlastních konfigurací

Následující scénáře jsou volitelné a vztahují se pouze na pokročilé uživatele.

  • Pokud máte nějaké další odkazy na TelemetryClienttelemetrii, které se dají použít k ručnímu záznamu telemetrie, měly by se odebrat.

  • Pokud jste přidali vlastní filtrování nebo rozšiřování ve formě vlastního TelemetryProcessor TelemetryInitializernebo , měly by být odebrány. Mohou být nalezeny ve vašem ServiceCollection.

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

    builder.Services.AddApplicationInsightsTelemetryProcessor<MyCustomTelemetryProcessor>();

  • Odebrání fragmentu kódu JavaScriptu

    Pokud jste použili fragment kódu poskytovaný sadou Application Insights .NET SDK, musíte ho také odebrat. Úplné ukázky kódu, které se mají odebrat, najdete v průvodci povolením telemetrie na straně klienta pro webové aplikace.

    Pokud jste přidali sadu JavaScript SDK ke shromažďování telemetrie na straně klienta, můžete ji také odebrat, i když bude i nadále fungovat bez sady .NET SDK. Kompletní ukázky kódu, které se mají odebrat, najdete v průvodci onboardingem pro javascriptovou sadu SDK.

  • Odebrání všech artefaktů sady Visual Studio

    Pokud jste k onboardingu do Application Insights použili Visual Studio, mohli byste v projektu nechat více souborů.

    • Properties/ServiceDependencies Adresář může obsahovat odkaz na prostředek Application Insights.

Tip

Naše produktová skupina aktivně hledá zpětnou vazbu k této dokumentaci. Poskytněte nám svůj názor nebo se podívejte do otel@microsoft.com části Podpora .

Nejčastější dotazy

Tato část je určená pro zákazníky, kteří používají inicializátory telemetrie nebo procesory, nebo zapisují vlastní kód proti klasickému rozhraní API Application Insights k vytvoření vlastní telemetrie.

Jak se mapuje rozhraní API sady SDK na koncepty OpenTelemetry?

OpenTelemetry je architektura neutrální pozorovatelnosti dodavatele. V sadě OpenTelemetry SDK nebo knihovnách nejsou k dispozici žádná rozhraní API Application Insights. Před migrací je důležité pochopit některé koncepty OpenTelemetry.

  • Ve službě Application Insights se veškerá telemetrie spravovala prostřednictvím jediného TelemetryClient objektu a TelemetryConfiguration. V OpenTelemetry má každá ze tří telemetrických signálů (Traces, Metrics a Logs) vlastní konfiguraci. Telemetrii můžete vytvořit ručně prostřednictvím modulu runtime .NET bez externích knihoven. Další informace najdete v průvodcích .NET o distribuovaném trasování, metrikách a protokolování.

  • Application Insights sloužící TelemetryModules k automatickému shromažďování telemetrie pro vaši aplikaci. Místo toho OpenTelemetry využívá knihovny instrumentace ke shromažďování telemetrie z konkrétních komponent (například AspNetCore pro požadavky a HttpClient pro závislosti).

  • Application Insights slouží TelemetryInitializers k obohacení telemetrie o další informace nebo k přepsání vlastností. Pomocí OpenTelemetry můžete napsat procesor pro přizpůsobení konkrétního signálu. Mnoho knihoven Instrumentace OpenTelemetry navíc nabízí metodu Enrich pro přizpůsobení telemetrie vygenerované danou konkrétní komponentou.

  • Application Insights slouží TelemetryProcessors k filtrování telemetrie. Procesor OpenTelemetry lze také použít k použití pravidel filtrování pro konkrétní signál.

Jak se typy telemetrie Application Insights mapují na OpenTelemetry?

Tato tabulka mapuje datové typy Application Insights na koncepty OpenTelemetry a jejich implementace .NET.

Tabulka služby Azure Monitor Datový typ Application Insights Datový typ OpenTelemetry Implementace .NET
customEvents EventTelemetry – N/A
customMetrics MetricTelemetry Metriky System.Diagnostics.Metrics.Meter
závislosti DependencyTelemetry Rozsahy (klient, interní, příjemce) System.Diagnostics.Activity
výjimky ExceptionTelemetry Výjimky System.Exception
žádosti RequestTelemetry Spans (Server, Producer) System.Diagnostics.Activity
trasování TraceTelemetry Protokoly Microsoft.Extensions.Logging.ILogger

Další informace najdete v následujících dokumentech.

Jak se koncepty vzorkování Application Insights mapují na OpenTelemetry?

Application Insights sice nabízí několik možností konfigurace vzorkování, ale exportér služby Azure Monitor nebo distribuce služby Azure Monitor nabízí vzorkování s pevnou rychlostí. Vzorkovat lze pouze požadavky a závislosti (trasování OpenTelemetry).

Ukázky kódu s podrobnými informacemi o konfiguraci vzorkování najdete v našem průvodci povolením vzorkování.

Jak se procesory telemetrie a inicializátory mapují na OpenTelemetry?

V sadě Application Insights .NET SDK použijte procesory telemetrie k filtrování a úpravě nebo zahození telemetrie. Pomocí inicializátorů telemetrie můžete přidat nebo upravit vlastní vlastnosti. Další informace najdete v dokumentaci ke službě Azure Monitor. OpenTelemetry nahrazuje tyto koncepty procesory aktivit nebo protokolů, které vylepšují a filtrují telemetrii.

Filtrování trasování

Pokud chcete filtrovat telemetrická data v OpenTelemetry, můžete implementovat procesor aktivit. Tento příklad je ekvivalentem příkladu Application Insights pro filtrování telemetrických dat, jak je popsáno v dokumentaci ke službě Azure Monitor. Příklad ukazuje, kde jsou neúspěšná volání závislostí filtrována.

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

Chcete-li použít tento procesor, musíte vytvořit TracerProvider a přidat procesor před AddAzureMonitorTraceExporter.

using OpenTelemetry.Trace;

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

Filtrování protokolů

ILogger implementace mají integrovaný mechanismus pro použití filtrování protokolů. Toto filtrování umožňuje řídit protokoly, které se odesílají každému OpenTelemetryLoggerProviderregistrovanému poskytovateli, včetně . "OpenTelemetry" je alias pro OpenTelemetryLoggerProvider, který se používá při konfiguraci pravidel filtrování.

Následující příklad definuje "Error" jako výchozí LogLevel a také definuje "Upozornění" jako minimum LogLevel pro uživatelsky definovanou kategorii. Tato pravidla, jak jsou definována, se vztahují pouze na OpenTelemetryLoggerProvider.

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

Další informace najdete v dokumentaci OpenTelemetry .NET k protokolům.

Přidání vlastních vlastností do trasování

V OpenTelemetry můžete pomocí procesorů aktivit rozšířit telemetrická data o více vlastností. Podobá se použití inicializátorů telemetrie v Application Insights, kde můžete upravit vlastnosti telemetrie.

Ve výchozím nastavení azure Monitor Exportér označí všechny požadavky HTTP kódem odpovědi 400 nebo vyšší, protože selhalo. Pokud ale chcete zacházet s 400 jako s úspěchem, můžete přidat procesor aktivity pro rozšiřování, který nastaví úspěch aktivity a přidá značku, která bude obsahovat více vlastností telemetrie. Podobá se přidání nebo úpravě vlastností pomocí inicializátoru v Application Insights, jak je popsáno v dokumentaci ke službě Azure Monitor.

Tady je příklad přidání vlastních vlastností a přepsání výchozího chování určitých kódů odpovědí:

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

Chcete-li použít tento procesor, musíte vytvořit TracerProvider a přidat procesor před AddAzureMonitorTraceExporter.

using OpenTelemetry.Trace;

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

Návody ručně sledovat telemetrii pomocí OpenTelemetry?

Odesílání trasování – ruční

Trasování ve službě Application Insights se ukládá jako RequestTelemetry a DependencyTelemetry. V OpenTelemetry se trasování modelují jako Span pomocí Activity třídy.

OpenTelemetry .NET využívá ActivitySource a Activity třídy pro trasování, které jsou součástí modulu runtime .NET. Tento přístup je výrazný, protože implementace .NET integruje rozhraní API trasování přímo do samotného modulu runtime. Tento System.Diagnostics.DiagnosticSource balíček umožňuje vývojářům vytvářet ActivitySource a spravovat Activity instance. Tato metoda poskytuje bezproblémový způsob, jak přidat trasování do aplikací .NET bez nutnosti spoléhat se na externí knihovny a používat integrované funkce ekosystému .NET. Podrobnější informace najdete v návodech pro instrumentaci distribuovaného trasování.

Tady je postup migrace ručního trasování:

Poznámka:

V Application Insights může být název role a instance role nastaveny na úrovni telemetrie. S exportérem služby Azure Monitor ale nemůžeme přizpůsobit na úrovni jednotlivých telemetrických dat. Název role a instance role se extrahují z prostředku OpenTelemetry a použijí se napříč všemi telemetrií. Další informace najdete v tomto dokumentu: Nastavte název cloudové role a instanci cloudové role.

DependencyTelemetry

Application Insights DependencyTelemetry se používá k modelování odchozích požadavků. Tady je postup, jak ho převést na OpenTelemetry:

Příklad Application Insights:

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

Příklad OpenTelemetry:

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

Modely Application Insights RequestTelemetry příchozí požadavky Tady je postup, jak ho migrovat na OpenTelemetry:

Příklad Application Insights:

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

Příklad OpenTelemetry:

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

Vlastní sledování operací

V Application Insights sledujte vlastní operace pomocí StartOperation a StopOperation metod. Dosáhnete toho pomocí ActivitySource opentelemetry .NET a Activity v ní. Pro operace s ActivityKind.Server a ActivityKind.Consumer, Azure Monitor Exportér generuje RequestTelemetry. Pro ActivityKind.Client, ActivityKind.Producera ActivityKind.Internal, vygeneruje DependencyTelemetry. Další informace o sledování vlastních operací najdete v dokumentaci ke službě Azure Monitor. Další informace o použití ActivitySource a Activity v .NET najdete v návodech k instrumentaci distribuovaného trasování .NET.

Tady je příklad spuštění a zastavení aktivity pro vlastní operace:

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

Odesílání protokolů

Protokoly ve službě Application Insights se ukládají jako TraceTelemetry a ExceptionTelemetry.

TraceTelemetry

V OpenTelemetry je protokolování integrované prostřednictvím ILogger rozhraní. Tady je postup migrace TraceTelemetry:

Příklad Application Insights:

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

Příklad OpenTelemetry:

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 používá ExceptionTelemetry k protokolování výjimek. Tady je postup migrace na OpenTelemetry:

Příklad Application Insights:

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

Příklad OpenTelemetry:

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

Odesílání metrik

Metriky ve službě Application Insights se ukládají jako MetricTelemetry. V OpenTelemetry se metriky modelují jako Meter z System.Diagnostics.DiagnosticSource balíčku.

Application Insights má agregace () i před agregaceTrackMetric() () i před agregace (GetMetric().TrackValue()) rozhraní API pro metriky. Na rozdíl od OpenTelemetry nemá Application Insights žádnou představu o nástrojích. Application Insights má stejné rozhraní API pro všechny scénáře metrik.

OpenTelemetry na druhé straně vyžaduje, aby uživatelé nejprve vybrali správný nástroj metriky na základě skutečné sémantiky metriky. Pokud například chcete spočítat něco (například celkový počet přijatých požadavků na server atd.), měl by se použít čítač OpenTelemetry. Pokud je záměrem vypočítat různé percentily (například hodnotu P99 latence serveru), měl by se použít nástroj Histogram OpenTelemetry. Vzhledem k tomuto základnímu rozdílu mezi Application Insights a OpenTelemetry se mezi nimi neprovází přímé porovnání.

Na rozdíl od Application Insights OpenTelemetry neposkytuje integrované mechanismy pro rozšiřování nebo filtrování metrik. V Application Insights se k úpravě nebo zahození metrik dají použít procesory telemetrie a inicializátory, ale tato funkce není dostupná v OpenTelemetry.

Kromě toho OpenTelemetry nepodporuje přímé odesílání nezpracovaných metrik, protože neexistuje žádný ekvivalent funkcí TrackMetric() nalezených v Application Insights.

Migrace z Application Insights na OpenTelemetry zahrnuje nahrazení všech využití rozhraní API metrik Application Insights rozhraním API OpenTelemetry. Vyžaduje pochopení různých nástrojů OpenTelemetry a jejich sémantiky.

Tip

Histogram je nejuniverzálnější a nejbližší ekvivalent rozhraní API Application Insights GetMetric().TrackValue() . Rozhraní API metrik Application Insights můžete nahradit histogramem, abyste dosáhli stejného účelu.

Další typy telemetrie

CustomEvents

OpenTelemetry se nepodporuje.

Příklad Application Insights:

TelemetryClient.TrackEvent()
DostupnostTelemetry

OpenTelemetry se nepodporuje.

Příklad Application Insights:

TelemetryClient.TrackAvailability()
PageViewTelemetry

OpenTelemetry se nepodporuje.

Příklad Application Insights:

TelemetryClient.TrackPageView()

Můžu získat živé metriky pro aplikace konzolových a pracovních služeb?

Pro aplikace konzolových a pracovních služeb, které nezahrnují živé metriky, doporučujeme nástroj Azure Monitor OpenTelemetry Exportér pro konzolové a pracovní služby.

Další kroky

Tip

Naše produktová skupina aktivně hledá zpětnou vazbu k této dokumentaci. Poskytněte nám svůj názor nebo se podívejte do otel@microsoft.com části Podpora .

Technická podpora

  • V případě podpora Azure problémů otevřete lístek podpora Azure.
  • V případě problémů s OpenTelemetry se obraťte přímo na komunitu OpenTelemetry .NET.
  • Seznam otevřených problémů souvisejících s exportérem služby Azure Monitor najdete na stránce Problémy GitHubu.