Compartilhar via

Migrar de SDKs do .NET Application Insights para o OpenTelemetry do Azure Monitor

  • Artigo

Este guia fornece instruções passo a passo para migrar vários aplicativos .NET do uso de SDKs (kits de desenvolvimento de software) do Application Insights para o OpenTelemetry do Azure Monitor.

Espere uma experiência semelhante com a instrumentação do OpenTelemetry do Azure Monitor e com os SDKs do Application Insights. Para obter mais informações e uma comparação de recursos por recursos, consulte estado de lançamento dos recursos.

Se você estiver começando a usar o Application Insights e não precisar migrar da API Clássica, consulte Habilitar o OpenTelemetry do Azure Monitor.

Pré-requisitos

  • Um aplicativo Web ASP.NET Core já instrumentado com o Application Insights sem personalizações
  • Uma versão com suporte ativo do .NET

Dica

Nosso grupo de produtos está buscando ativamente feedback sobre esta documentação. Forneça comentários para otel@microsoft.com ou consulte a seção Suporte.

Remover o SDK do Application Insights

Observação

Antes de continuar com essas etapas, você deve confirmar se tem um backup atual do seu aplicativo.

  1. Remover pacotes NuGet

    Remova a embalagem Microsoft.ApplicationInsights.AspNetCore do csproj.

    dotnet remove package Microsoft.ApplicationInsights.AspNetCore

  2. Remover código de inicialização e personalizações

    Remova todas as referências a tipos do Application Insights em sua base de código.

    Dica

    Depois de remover o pacote do Application Insights, você pode recompilar seu aplicativo para obter uma lista de referências que precisam ser removidas.

    • Remova o Application Insights do ServiceCollection excluindo a seguinte linha:

      builder.Services.AddApplicationInsightsTelemetry();

    • Remova a seção ApplicationInsights do seu appsettings.json.

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

  3. Limpar e construir

    Inspecione o diretório bin para validar se todas as referências a Microsoft.ApplicationInsights.* foram removidas.

  4. Teste seu aplicativo

    Verifique se seu aplicativo não tem consequências inesperadas.

Dica

Nosso grupo de produtos está buscando ativamente feedback sobre esta documentação. Forneça comentários para otel@microsoft.com ou consulte a seção Suporte.

Habilitar OpenTelemetry

Recomendamos criar um recurso de desenvolvimento e usar sua cadeia de conexão ao seguir estas instruções.

Captura de tela exibindo a visão geral e a cadeia de conexão do Application Insights.

Planeje atualizar a cadeia de conexão para enviar telemetria ao recurso original depois de confirmar que a migração foi bem-sucedida.

  1. Instalar a distribuição do Azure Monitor

    Nossa distribuição do Azure Monitor permite a telemetria automática incluindo bibliotecas de instrumentação OpenTelemetry para coletar rastreamentos, métricas, logs e exceções, e permite coletar telemetria personalizada.

    A instalação da distribuição do Azure Monitor traz o SDK do OpenTelemetry como uma dependência.

    dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore

  2. Adicionar e configurar o OpenTelemetry e o Azure Monitor

    O SDK do OpenTelemery deve ser configurado na inicialização do aplicativo como parte do seu ServiceCollection, normalmente no Program.cs.

    O OpenTelemetry tem um conceito de três sinais; Rastreamentos, métricas e logs. A distribuição do Azure Monitor configura cada um desses sinais.

Module.vb

O exemplo de código a seguir demonstra as noções básicas.

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

Recomendamos definir sua cadeia de conexão em uma variável de ambiente:

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Mais opções para configurar a cadeia de conexão são detalhadas aqui: Configurar a cadeia de conexão do Application Insights.

Dica

Nosso grupo de produtos está buscando ativamente feedback sobre esta documentação. Forneça comentários para otel@microsoft.com ou consulte a seção Suporte.

Instalar e configurar bibliotecas de instrumentação

Bibliotecas de instrumentação podem ser adicionadas ao seu projeto para coletar automaticamente a telemetria sobre componentes ou dependências específicos.

As bibliotecas a seguir são incluídas na Distribuição.

Personalizando bibliotecas de instrumentação

A distribuição do Azure Monitor inclui instrumentação do .NET OpenTelemetry para ASP.NET Core, HttpClient e SQLClient. Você pode personalizar essas instrumentações incluídas ou adicionar manualmente instrumentação extra por conta própria usando a API OpenTelemetry.

Aqui estão alguns exemplos de como personalizar a instrumentação:

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

Fornecemos a instrumentação SQLClient em nosso pacote enquanto ele ainda está em beta. Quando ele atinge uma versão estável, nós o incluímos como uma referência de pacote padrão. Até lá, para personalizar a instrumentação SQLClient, adicione a referência do pacote OpenTelemetry.Instrumentation.SqlClient ao seu projeto e use sua API pública.

dotnet add package --prerelease OpenTelemetry.Instrumentation.SqlClient

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

Configurar o Azure Monitor

O Application Insights oferecia muito mais opções de configuração por meio do ApplicationInsightsServiceOptions.

Configuração do Application Insights Alternativa ao OpenTelemetry
AddAutoCollectedMetricExtractor N/D
ApplicationVersion Definir "service.version" em Recurso
ConnectionString Consulte instruções sobre como configurar a cadeia de conexão.
DependencyCollectionOptions N/D Para personalizar dependências, examine as opções de configuração disponíveis para bibliotecas de instrumentação aplicáveis.
DeveloperMode N/D
EnableActiveTelemetryConfigurationSetup N/D
EnableAdaptiveSampling N/D Há suporte apenas para amostragem de taxa fixa.
EnableAppServicesHeartbeatTelemetryModule N/D
EnableAuthenticationTrackingJavaScript N/D
EnableAzureInstanceMetadataTelemetryModule N/D
EnableDependencyTrackingTelemetryModule Consulte as instruções sobre como filtrar rastreamentos.
EnableDiagnosticsTelemetryModule N/D
EnableEventCounterCollectionModule N/D
EnableHeartbeat N/D
EnablePerformanceCounterCollectionModule N/D
EnableQuickPulseMetricStream AzureMonitorOptions.EnableLiveMetrics
EnableRequestTrackingTelemetryModule Consulte as instruções sobre como filtrar rastreamentos.
EndpointAddress Use ConnectionString.
InstrumentationKey Use ConnectionString.
RequestCollectionOptions N/D Consulte Opções OpenTelemetry.Instrumentation.AspNetCore.

Remover configurações personalizadas

Os cenários a seguir são opcionais e se aplicam apenas a usuários avançados.

  • Se você tiver mais referências ao TelemetryClient, que pode ser usado para registrar manualmente a telemetria, elas devem ser removidas.

  • Se você adicionou qualquer filtragem ou enriquecimento personalizado na forma de um TelemetryProcessor ou TelemetryInitializer personalizado, eles devem ser removidos. Eles podem ser encontrados em seu ServiceCollection.

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

    builder.Services.AddApplicationInsightsTelemetryProcessor<MyCustomTelemetryProcessor>();

  • Remover snippet de JavaScript

    Se você usou o Snippet fornecido pelo SDK do .NET do Application Insights, ele também deverá ser removido. Para obter exemplos de código completos sobre o que remover, examine o guia habilitar a telemetria do lado do cliente para aplicativos Web.

    Se você adicionou o SDK do JavaScript para coletar a telemetria do lado do cliente, ele também poderá ser removido, embora continue funcionando sem o SDK do .NET. Para obter exemplos de código completos sobre o que remover, examine o guia de integração do SDK do JavaScript.

  • Remover todos os artefatos do Visual Studio

    Se você usou o Visual Studio para integrar ao Application Insights, poderá ter mais arquivos restantes em seu projeto.

    • Properties/ServiceDependencies diretório pode ter uma referência ao recurso do Application Insights.

Dica

Nosso grupo de produtos está buscando ativamente feedback sobre esta documentação. Forneça comentários para otel@microsoft.com ou consulte a seção Suporte.

Perguntas frequentes

Esta seção é para clientes que usam inicializadores ou processadores de telemetria ou escrevem código personalizado na API clássica do Application Insights para criar telemetria personalizada.

Como a API do SDK é mapeada para os conceitos do OpenTelemetry?

OpenTelemetry é uma estrutura de observabilidade neutra do fornecedor. Não há APIs do Application Insights no SDK ou nas bibliotecas do OpenTelemetry. Antes de migrar, é importante entender alguns dos conceitos do OpenTelemetry.

  • No Application Insights, toda a telemetria era gerenciada por meio de um único TelemetryClient e TelemetryConfiguration. No OpenTelemetry, cada um dos três sinais de telemetria (Traces, Metrics e Logs) tem sua própria configuração. Você pode criar telemetria manualmente por meio do runtime do .NET sem bibliotecas externas. Para obter mais informações, consulte os guias do .NET sobre rastreamento distribuído, métricas e registro em log.

  • O Application Insights usou TelemetryModules para coletar automaticamente a telemetria para seu aplicativo. Em vez disso, o OpenTelemetry usa bibliotecas de instrumentação para coletar telemetria de componentes específicos (como AspNetCore para solicitações e HttpClient para dependências).

  • O Application Insights usou TelemetryInitializers para enriquecer a telemetria com informações adicionais ou para substituir propriedades. Com o OpenTelemetry, você pode escrever um Processador para personalizar um sinal específico. Além disso, muitas bibliotecas do OpenTelemetry Instrumentation oferecem um método Enrich para personalizar a telemetria gerada por esse componente específico.

  • O Application Insights usou TelemetryProcessors para filtrar a telemetria. Um Processador OpenTelemetry também pode ser usado para aplicar regras de filtragem em um sinal específico.

Como os tipos de telemetria do Application Insights são mapeados para o OpenTelemetry?

Esta tabela mapeia os tipos de dados do Application Insights para conceitos do OpenTelemetry e suas implementações do .NET.

Tabela do Azure Monitor DataType do Application Insights DataType do OpenTelemetry Implementação do .NET
customEvents EventTelemetry N/D N/D
customMetrics MetricTelemetry Métricas System.Diagnostics.Metrics.Meter
dependencies DependencyTelemetry Intervalos (Cliente, Interno, Consumidor) System.Diagnostics.Activity
exceptions ExceptionTelemetry Exceções System.Exception
solicitações RequestTelemetry Intervalos (Servidor, Produtor) System.Diagnostics.Activity
traces TraceTelemetry Logs Microsoft.Extensions.Logging.ILogger

Os documentos a seguir fornecem mais informações.

Como os conceitos de amostragem do Application Insights são mapeados para o OpenTelemetry?

Embora o Application Insights ofereça várias opções para configurar a amostragem, o Exportador do Azure Monitor ou a Distribuição do Azure Monitor oferece apenas amostragem de taxa fixa. Somente Solicitações e Dependências (Rastreamentos de OpenTelemetry) podem ser amostrados.

Para obter exemplos de código detalhando como configurar a amostragem, consulte nosso guia Habilitar amostragem

Como os processadores e inicializadores de telemetria são mapeados para o OpenTelemetry?

No SDK do .NET do Application Insights, use processadores de telemetria para filtrar e modificar ou descartar a telemetria. Use inicializadores de telemetria para adicionar ou modificar propriedades personalizadas. Para obter mais informações, consulte a documentação Azure Monitor. O OpenTelemetry substitui esses conceitos por processadores de atividade ou log, que enriquecem e filtram a telemetria.

Filtrando rastreamentos

Para filtrar dados de telemetria no OpenTelemetry, você pode implementar um processador de atividade. Este exemplo é equivalente ao exemplo do Application Insights para filtrar dados de telemetria, conforme descrito na documentação do Azure Monitor. O exemplo ilustra onde as chamadas de dependência malsucedidas são filtradas.

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

Para usar este processador, você precisa criar um TracerProvider e adicionar o processador antes de AddAzureMonitorTraceExporter.

using OpenTelemetry.Trace;

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

Filtrando logs

Implementações ILogger tem um mecanismo interno para aplicar a filtragem de log. Essa filtragem permite controlar os logs enviados para cada provedor registrado, incluindo o OpenTelemetryLoggerProvider. "OpenTelemetry" é o alias para OpenTelemetryLoggerProvider, usado na configuração de regras de filtragem.

O exemplo a seguir define "Erro" como o LogLevel padrão e também define "Aviso" como o LogLevel mínimo para uma categoria definida pelo usuário. Essas regras, conforme definidas, aplicam-se apenas ao OpenTelemetryLoggerProvider.

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

Para obter mais informações, leia a documentação do OpenTelemetry .NET sobre logs.

Adicionando propriedades personalizadas a rastreamentos

No OpenTelemetry, você pode usar processadores de atividade para enriquecer os dados de telemetria com mais propriedades. É semelhante ao uso de inicializadores de telemetria no Application Insights, em que você pode modificar as propriedades de telemetria.

Por padrão, o Exportador do Azure Monitor sinaliza qualquer solicitação HTTP com um código de resposta de 400 ou superior como falha. No entanto, se você quiser tratar 400 como um sucesso, poderá adicionar um processador de atividade enriquecedor que define o sucesso na atividade e adiciona uma marca para incluir mais propriedades de telemetria. É semelhante a adicionar ou modificar propriedades usando um inicializador no Application Insights, conforme descrito na documentação do Azure Monitor.

Aqui está um exemplo de como adicionar propriedades personalizadas e substituir o comportamento padrão para determinados códigos de resposta:

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

Para usar este processador, você precisa criar um TracerProvider e adicionar o processador antes de AddAzureMonitorTraceExporter.

using OpenTelemetry.Trace;

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

Como faço para rastrear manualmente a telemetria usando o OpenTelemetry?

Envio de rastreamentos - Manual

Os rastreamentos no Application Insights são armazenados como RequestTelemetry e DependencyTelemetry. No OpenTelemetry, os rastreamentos são modelados como Span usando a classe Activity.

O OpenTelemetry .NET utiliza as classes ActivitySource e Activity para rastreamento, que fazem parte do runtime do .NET. Essa abordagem é distinta porque a implementação do .NET integra a API de rastreamento diretamente ao próprio runtime. O pacote System.Diagnostics.DiagnosticSource permite que os desenvolvedores usem ActivitySource para criar e gerenciar instâncias Activity. Esse método fornece uma maneira perfeita de adicionar rastreamento a aplicativos .NET sem depender de bibliotecas externas, aplicando os recursos internos do ecossistema .NET. Para obter informações mais detalhadas, consulte as instruções passo a passo da instrumentação de rastreamento distribuído.

Veja como migrar o rastreamento manual:

Observação

No Application Insights, o nome da função e a instância da função podem ser definidos em um nível por telemetria. No entanto, com o Exportador do Azure Monitor, não podemos personalizar em um nível por telemetria. O nome da função e a instância da função são extraídos do recurso OpenTelemetry e aplicados em toda a telemetria. Leia este documento para obter mais informações: Defina o nome da função de nuvem e a instância da função de nuvem.

DependencyTelemetry

O Application Insights DependencyTelemetry é usado para modelar solicitações de saída. Veja como convertê-lo para OpenTelemetry:

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

Exemplo de 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

O Application Insights RequestTelemetry modela as solicitações de entrada. Veja como migrá-lo para o OpenTelemetry:

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

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

Acompanhamento de operações personalizadas

No Application Insights, acompanhe as operações personalizadas usando os métodos StartOperation e StopOperation. Consiga isso usando ActivitySource e Activity no OpenTelemetry .NET. Para operações com ActivityKind.Server e ActivityKind.Consumer, o Exportador do Azure Monitor gera RequestTelemetry. Para ActivityKind.Client, ActivityKind.Producer e ActivityKind.Internal, ele gera DependencyTelemetry. Para obter mais informações sobre o acompanhamento de operações personalizadas, consulte a documentação do Azure Monitor. Para obter mais informações sobre como usar ActivitySource e Activity no .NET, consulte as instruções passo a passo da instrumentação de rastreamento distribuído do ..

Veja um exemplo de como iniciar e interromper uma atividade para operações personalizadas:

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

Enviando logs

Os logs no Application Insights são armazenados como TraceTelemetry e ExceptionTelemetry.

TraceTelemetry

No OpenTelemetry, o registro é integrado por meio da interface ILogger. Veja como migrar TraceTelemetry:

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

Exemplo de 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

O Application Insights usa ExceptionTelemetry para registrar exceções. Veja como migrar para o OpenTelemetry:

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

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

Métricas de envio

As métricas no Application Insights são armazenadas como MetricTelemetry. No OpenTelemetry, as métricas são modeladas como Meter do pacote System.Diagnostics.DiagnosticSource.

O Application Insights tem APIs de métrica não pré-agregadas (TrackMetric()) e pré-agregadas (GetMetric().TrackValue()). Ao contrário do OpenTelemetry, o Application Insights não tem noção de Instrumentos. O Application Insights tem a mesma API para todos os cenários de métrica.

O OpenTelemetry, por outro lado, exige que os usuários primeiro escolham o instrumento de métrica certo com base na semântica real da métrica. Por exemplo, se a intenção for contar algo (como o número total de solicitações de servidor recebidas etc.), Contador OpenTelemetry deverá ser usado. Se a intenção for calcular vários percentis (como o valor P99 da latência do servidor), então OpenTelemetry Histogram instrumento deve ser usado. Devido a essa diferença fundamental entre o Application Insights e o OpenTelemetry, nenhuma comparação direta é feita entre eles.

Ao contrário do Application Insights, o OpenTelemetry não fornece mecanismos internos para enriquecer ou filtrar métricas. No Application Insights, os processadores e inicializadores de telemetria podem ser usados para modificar ou descartar métricas, mas essa funcionalidade não está disponível no OpenTelemetry.

Além disso, o OpenTelemetry não dá suporte ao envio direto de métricas brutas, pois não há equivalente à funcionalidade TrackMetric() encontrada no Application Insights.

A migração do Application Insights para o OpenTelemetry envolve a substituição de todos os usos da API de Métrica do Application Insights pela API do OpenTelemetry. Requer a compreensão dos vários instrumentos OpenTelemetry e sua semântica.

Dica

O histograma é o mais versátil e o equivalente mais próximo da API do Application Insights GetMetric().TrackValue(). Você pode substituir as APIs de Métrica do Application Insights pelo Histograma para atingir a mesma finalidade.

Outros tipos de telemetria

CustomEvents

Não suportado no OpenTelemetry.

Exemplo do Application Insights:

TelemetryClient.TrackEvent()
AvailabilityTelemetry

Não suportado no OpenTelemetry.

Exemplo do Application Insights:

TelemetryClient.TrackAvailability()
PageViewTelemetry

Não suportado no OpenTelemetry.

Exemplo do Application Insights:

TelemetryClient.TrackPageView()

Posso obter métricas dinâmicas para aplicativos de console e serviços de trabalho?

Recomendamos o Exportador de OpenTelemetry do Azure Monitor para os aplicativos de console e serviços de trabalho, o que não inclui métricas dinâmicas.

Próximas etapas

Dica

Nosso grupo de produtos está buscando ativamente feedback sobre esta documentação. Forneça comentários para otel@microsoft.com ou consulte a seção Suporte.

Suporte