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

  • 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 Azure Monitor OpenTelemetry.

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

  • ASP.NET Migração principal para a Distro OpenTelemetry do Azure Monitor. Azure.Monitor.OpenTelemetry.AspNetCore(pacote NuGet)
  • ASP.NET, console e migração WorkerService para o Azure Monitor OpenTelemetry Exporter. Azure.Monitor.OpenTelemetry.Exporter(pacote NuGet)

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

Pré-requisitos

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

Gorjeta

O nosso grupo de produtos está ativamente à procura de feedback sobre esta documentação. Envie comentários ou otel@microsoft.com consulte a seção Suporte .

Remover o SDK do Application Insights

Nota

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

  1. Remover pacotes NuGet

    Remova a Microsoft.ApplicationInsights.AspNetCore embalagem do arquivo csproj.

    dotnet remove package Microsoft.ApplicationInsights.AspNetCore

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

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

    Gorjeta

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

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

      builder.Services.AddApplicationInsightsTelemetry();

    • Remova a ApplicationInsights secção do ficheiro appsettings.json.

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

  3. Limpar e construir

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

  4. Teste a sua aplicação

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

Gorjeta

O nosso grupo de produtos está ativamente à procura de feedback sobre esta documentação. Envie comentários ou otel@microsoft.com consulte a seção Suporte .

Ativar OpenTelemetry

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

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

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 Distro do Azure Monitor

    Nossa Distro do Azure Monitor habilita 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 Distro 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.

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

Program.cs

O exemplo de código a seguir demonstra o básico.

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.

Gorjeta

O nosso grupo de produtos está ativamente à procura de feedback sobre esta documentação. Envie comentários ou otel@microsoft.com consulte a seção Suporte .

Instalar e configurar bibliotecas de instrumentação

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

As seguintes bibliotecas estão incluídas na Distro.

Personalizando bibliotecas de instrumentação

A Distro do Azure Monitor inclui instrumentação .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

Nós fornecemos a instrumentação SQLClient dentro do nosso pacote enquanto ele ainda está em beta. Quando 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 de OpenTelemetry.Instrumentation.SqlClient pacote 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 via ApplicationInsightsServiceOptions.

Configuração do Application Insights Alternativa OpenTelemetry
AddAutoCollectedMetricExtractor N/A
ApplicationVersion Definir "service.version" no recurso
ConnectionString Consulte as instruções sobre como configurar a Cadeia de Conexão.
DependencyCollectionOptions N/A. Para personalizar dependências, revise as opções de configuração disponíveis para bibliotecas de instrumentação aplicáveis.
DeveloperMode N/A
EnableActiveTelemetryConfigurationSetup N/A
EnableAdaptiveSampling N/A. Apenas a amostragem de taxa fixa é suportada.
EnableAppServicesHeartbeatTelemetryModule N/A
EnableAuthenticationTrackingJavaScript N/A
EnableAzureInstanceMetadataTelemetryModule N/A
EnableDependencyTrackingTelemetryModule Consulte as instruções sobre como filtrar rastreamentos.
EnableDiagnosticsTelemetryModule N/A
EnableEventCounterCollectionModule N/A
EnableHeartbeat N/A
EnablePerformanceCounterCollectionModule N/A
EnableQuickPulseMetricStream AzureMonitorOptions.EnableLiveMetrics
EnableRequestTrackingTelemetryModule Consulte as instruções sobre como filtrar rastreamentos.
Endereço do ponto de extremidade Use ConnectionString.
InstrumentaçãoKey Use ConnectionString.
RequestCollectionOptions N/A. 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 , que poderiam ser usadas para gravar manualmente a TelemetryClienttelemetria, elas devem ser removidas.

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

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

    builder.Services.AddApplicationInsightsTelemetryProcessor<MyCustomTelemetryProcessor>();

  • Remover trecho 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 completo do que remover, revise o guia habilitar telemetria do lado do cliente para aplicativos Web.

    Se você adicionou o JavaScript SDK para coletar telemetria do lado do cliente, ele também pode ser removido, embora continue a funcionar sem o SDK do .NET. Para obter exemplos de código completo do que remover, consulte o guia de integração para o JavaScript SDK.

  • Remova 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 pode ter uma referência ao seu recurso do Application Insights.

Gorjeta

O nosso grupo de produtos está ativamente à procura de feedback sobre esta documentação. Envie comentários ou otel@microsoft.com consulte a seção Suporte .

Perguntas mais 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 da 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 tempo de execução do .NET sem bibliotecas externas. Para obter mais informações, consulte os guias do .NET sobre rastreamento distribuído, métricas e log.

  • Application Insights usado TelemetryModules para coletar telemetria automaticamente 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).

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

  • Application Insights usado TelemetryProcessors para filtrar 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 os conceitos do OpenTelemetry e suas implementações .NET.

Tabela do Azure Monitor Tipo de dados do Application Insights OpenTelemetry DataType Implementação .NET
customEvents Telemetria de Eventos N/A N/A
customMetrics Telemetria Métrica Métricas System.Diagnostics.Metrics.Meter
dependências DependênciaTelemetria Spans (Cliente, Interno, Consumidor) System.Diagnostics.Activity
exceções ExceçãoTelemetria Exceções System.Exception
pedidos RequestTelemetry Spans (Servidor, Produtor) System.Diagnostics.Activity
rastreios TraceTelemetry Registos Microsoft.Extensões.Logging.ILogger

Os documentos seguintes fornecem mais informações.

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

Enquanto o Application Insights oferecia várias opções para configurar a amostragem, o Azure Monitor Exporter ou o Azure Monitor Distro oferece apenas amostragem de taxa fixa. Somente solicitações e dependências (rastreamentos OpenTelemetry Traces) podem ser amostradas.

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 do 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

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

O exemplo a seguir define "Error" como o padrão LogLevel e também define "Warning" como o mínimo LogLevel para uma categoria definida pelo usuário. Estas regras, tal como 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 em logs.

Adicionando propriedades personalizadas a rastreamentos

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

Por padrão, o Exportador do Monitor do Azure sinaliza qualquer solicitação HTTP com um código de resposta igual ou superior a 400 como falha. No entanto, se você quiser tratar 400 como um sucesso, você pode adicionar um processador de atividade enriquecedor que define o sucesso na atividade e adiciona uma tag 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.

Veja 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 OpenTelemetry?

Envio de Rastreios - Manual

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

O OpenTelemetry .NET utiliza as ActivitySource classes e Activity para rastreamento, que fazem parte do tempo de execução do .NET. Essa abordagem é distinta porque a implementação do .NET integra a API de rastreamento diretamente no próprio tempo de execução. O System.Diagnostics.DiagnosticSource pacote permite que os desenvolvedores usem ActivitySource para criar e gerenciar Activity instâncias. 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:

Nota

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 Azure Monitor Exporter, 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 de função de nuvem.

DependênciaTelemetria

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 operações personalizadas usando StartOperation e StopOperation métodos. Conquiste-o usando ActivitySource e Activity no OpenTelemetry .NET. Para operações com ActivityKind.Server e ActivityKind.Consumer, o Azure Monitor Exporter gera RequestTelemetryo . Para ActivityKind.Client, ActivityKind.Producer, e ActivityKind.Internal, 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 .NET.

Veja um exemplo de como iniciar e parar 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.
}

Envio de logs

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

TraceTelemetry

No OpenTelemetry, o registro em log é integrado através da ILogger interface. 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);
}
ExceçãoTelemetria

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 Meter a System.Diagnostics.DiagnosticSource partir do pacote.

O Application Insights tem APIs de métricas não pré-agregantes (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 métricos.

O OpenTelemetry, por outro lado, exige que os usuários primeiro escolham o instrumento métrico certo com base na semântica real da métrica. Por exemplo, se a intenção é contar algo (como o número total de solicitações de servidor recebidas, etc.), OpenTelemetry Counter deve ser usado. Se a intenção for calcular vários percentis (como o valor P99 da latência do servidor), então o instrumento OpenTelemetry Histogram 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, processadores e inicializadores de telemetria podem ser usados para modificar ou descartar métricas, mas esse recurso não está disponível no OpenTelemetry.

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

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

Gorjeta

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

Outros tipos de telemetria

CustomEvents

Não suportado em OpenTelemetry.

Exemplo do Application Insights:

TelemetryClient.TrackEvent()
DisponibilidadeTelemetria

Não suportado em OpenTelemetry.

Exemplo do Application Insights:

TelemetryClient.TrackAvailability()
PageViewTelemetria

Não suportado em OpenTelemetry.

Exemplo do Application Insights:

TelemetryClient.TrackPageView()

Posso obter métricas em tempo real para aplicativos de serviço de console e de trabalho?

Recomendamos o Azure Monitor OpenTelemetry Exporter para aplicativos de serviço de console e de trabalho, que não inclui métricas em tempo real.

Próximos passos

Gorjeta

O nosso grupo de produtos está ativamente à procura de feedback sobre esta documentação. Envie comentários ou otel@microsoft.com consulte a seção Suporte .

Suporte

  • Para problemas de suporte do Azure, abra um tíquete de suporte do Azure.
  • Para problemas de OpenTelemetria, entre em contato diretamente com a comunidade OpenTelemetry .NET.
  • Para obter uma lista de problemas em aberto relacionados ao Azure Monitor Exporter, consulte a página Problemas do GitHub.