Adicionar, modificar e filtrar OpenTelemetry

  • Artigo

Este artigo fornece diretrizes sobre como adicionar, modificar e filtrar o OpenTelemetry para aplicativos usando o Application Insights do Azure Monitor.

Para saber mais sobre os conceitos do OpenTelemetry, confira a Visão geral do OpenTelemetry ou as Perguntas frequentes sobre o OpenTelemetry.

Coleta automática de dados

As distribuições coletam dados automaticamente agrupando as bibliotecas de instrumentação do OpenTelemetry.

Bibliotecas de instrumentação incluídas

Requests

Dependências

Registrando em log

  • ILogger

Para obter mais informações sobre o ILogger, confira Registrar em log com C# e .NET e exemplos de código.

Notas de rodapé

  • ¹: dá suporte a relatórios automáticos de exceções não tratadas/não detectadas
  • ²: dá suporte a métricas do OpenTelemetry
  • ³: por padrão, o registro em log só é coletado no nível INFO ou superior. Para alterar essa configuração, consulte as opções de configuração.
  • ⁴: por padrão, o registro em log só é coletado quando esse registro em log é executado no nível WARNING ou superior.

Observação

As Distribuições do OpenTelemetry do Azure Monitor incluem mapeamento personalizado e lógica para emitir automaticamente métricas padrão do Application Insights.

Dica

Todas as métricas do OpenTelemetry, sejam coletadas automaticamente de bibliotecas de instrumentação ou coletadas manualmente da codificação personalizada, atualmente são consideradas "métricas personalizadas" do Application Insights para fins de cobrança. Saiba mais.

Adicionar uma biblioteca de instrumentação da comunidade

Você pode coletar mais dados automaticamente quando incluir as bibliotecas de instrumentação da comunidade OpenTelemetry.

Cuidado

Não damos suporte nem garantimos a qualidade das bibliotecas de instrumentação da comunidade. Para sugerir uma para nossa distribuição, faça uma postagem ou vote a favor em nossa comunidade de comentários. Lembre-se de que algumas são baseadas em especificações experimentais do OpenTelemetry e podem introduzir futuras alterações interruptivas.

Para adicionar uma biblioteca de comunidade, use os métodos ConfigureOpenTelemetryMeterProvider ou ConfigureOpenTelemetryTracerProvider depois de adicionar o pacote nuget à biblioteca.

O exemplo a seguir demonstra como a Instrumentação do Runtime pode ser adicionada para coletar métricas adicionais.

dotnet add package OpenTelemetry.Instrumentation.Runtime 

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add runtime instrumentation.
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddRuntimeInstrumentation());

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

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

Coletar telemetria personalizada

Esta seção explica como coletar telemetria personalizada do aplicativo.

Dependendo do idioma e do tipo de sinal, há diferentes maneiras de coletar telemetria personalizada, incluindo:

  • API do OpenTelemetry
  • Bibliotecas de log/métricas específicas do idioma
  • API Clássica do Application Insights

A seguinte tabela representa os tipos de telemetria personalizada com suporte no momento:

Idioma Eventos personalizados Métricas personalizadas Dependências Exceções Visualizações de página Requests Rastreamentos
ASP.NET Core
   API do OpenTelemetry Sim Sim Sim Yes
   ILogger API Sim
   API clássica de IA
Java
   API do OpenTelemetry Sim Sim Sim Yes
   Logback, Log4j, JUL Sim Sim
   Métricas do Micrometer Sim
   API clássica de IA Yes Sim Sim Sim Sim Sim Sim
Node.js
   API do OpenTelemetry Sim Sim Sim Sim
Python
   API do OpenTelemetry Sim Sim Sim Sim
   Módulo de registro em log do Python Sim
   Extensão de eventos Sim Sim

Observação

O Java 3.x d Application Insights escuta a telemetria enviada para a API Clássica do Application Insights. Da mesma forma, o Node.js 3.x do Application Insights coleta eventos criados com a API Clássica do Application Insights. Isso facilita o upgrade e preenche uma lacuna em nosso suporte de telemetria personalizada até que todos os tipos de telemetria personalizada tenham suporte por meio da API OpenTelemetry.

Adicionar métricas personalizadas

Nesse contexto, as métricas personalizadas referem-se a instrumentar manualmente seu código para coletar métricas adicionais além do que as Bibliotecas de Instrumentação OpenTelemetry coletam automaticamente.

A API do OpenTelemetry oferece seis “instrumentos” métricos para cobrir vários cenários métricos e você precisa escolher o “Tipo de Agregação” correto ao visualizar as métricas no Metrics Explorer. Esse requisito é válido ao usar a API de Métrica do OpenTelemetry para enviar métricas e ao usar uma biblioteca de instrumentação.

A tabela a seguir mostra os tipos de agregação recomendados para cada um dos Instrumentos de Métrica do OpenTelemetry.

Instrumento do OpenTelemetry Tipo de agregação do Azure Monitor
Contador Somar
Contador assíncrono Somar
Histograma Min, Max, Average, Sum e Count
Medidor assíncrono Média
UpDownCounter Somar
UpDownCounter assíncrono Somar

Cuidado

Normalmente, os tipos de agregação além dos mostrados na tabela são irrelevantes.

A Especificação do OpenTelemetry descreve os instrumentos e fornece exemplos de quando usar cada um deles.

Dica

O histograma é o mais versátil e o mais equivalente à API Clássica de GetMetric do Application Insights. Atualmente, o Azure Monitor nivela o instrumento de histograma em nossos cinco tipos de agregação com suporte e o suporte para percentis está em andamento. Embora menos versáteis, outros instrumentos do OpenTelemetry têm um impacto menor no desempenho do aplicativo.

Exemplo de histograma

A inicialização do aplicativo deve assinar um Medidor pelo nome.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

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

O Meter deve ser inicializado usando esse mesmo nome.

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new histogram metric named "FruitSalePrice".
Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

// Create a new Random object.
var rand = new Random();

// Record a few random sale prices for apples and lemons, with different colors.
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "green"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));

Exemplo de contador

A inicialização do aplicativo deve assinar um Medidor pelo nome.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

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

O Meter deve ser inicializado usando esse mesmo nome.

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new counter metric named "MyFruitCounter".
Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

// Record the number of fruits sold, grouped by name and color.
myFruitCounter.Add(1, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(2, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(1, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(2, new("name", "apple"), new("color", "green"));
myFruitCounter.Add(5, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(4, new("name", "lemon"), new("color", "yellow"));

Exemplo de medidor

A inicialização do aplicativo deve assinar um Medidor pelo nome.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

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

O Meter deve ser inicializado usando esse mesmo nome.

// Get the current process.
var process = Process.GetCurrentProcess();

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new observable gauge metric named "Thread.State".
// This metric will track the state of each thread in the current process.
ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

private static IEnumerable<Measurement<int>> GetThreadState(Process process)
{
    // Iterate over all threads in the current process.
    foreach (ProcessThread thread in process.Threads)
    {
        // Create a measurement for each thread, including the thread state, process ID, and thread ID.
        yield return new((int)thread.ThreadState, new("ProcessId", process.Id), new("ThreadId", thread.Id));
    }
}

Adicionar exceções personalizadas

Selecione as bibliotecas de instrumentação para reportar automaticamente as exceções ao Application Insights. No entanto, convém relatar manualmente exceções além daquelas relatadas nas bibliotecas de instrumentação. Por exemplo, as exceções capturadas pelo código não são relatadas normalmente. Talvez você queira relatá-las para chamar a atenção para experiências relevantes, incluindo a seção de falhas e exibições de transação de ponta a ponta.

  • Para registrar uma exceção usando uma atividade: 
    // Start a new activity named "ExceptionExample".
using (var activity = activitySource.StartActivity("ExceptionExample"))
{
    // Try to execute some code.
    try
    {
        throw new Exception("Test exception");
    }
    // If an exception is thrown, catch it and set the activity status to "Error".
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error);
        activity?.RecordException(ex);
    }
}
  • Para registrar uma exceção usando ILogger: 
    // Create a logger using the logger factory. The logger category name is used to filter and route log messages.
var logger = loggerFactory.CreateLogger(logCategoryName);

// Try to execute some code.
try
{
    throw new Exception("Test Exception");
}
catch (Exception ex)
{
    // Log an error message with the exception. The log level is set to "Error" and the event ID is set to 0.
    // The log message includes a template and a parameter. The template will be replaced with the value of the parameter when the log message is written.
    logger.Log(
        logLevel: LogLevel.Error,
        eventId: 0,
        exception: ex,
        message: "Hello {name}.",
        args: new object[] { "World" });
}

Adicionar intervalos personalizados

Talvez você queira adicionar um intervalo personalizado em dois cenários. Primeiro, quando há uma solicitação de dependência que ainda não foi coletada por uma biblioteca de instrumentação. Segundo, quando você deseja modelar um processo de inscrição como uma extensão da exibição de transações de ponta a ponta.

Observação

As classes Activity e ActivitySource do namespace System.Diagnostics representam os conceitos Span e Tracer do OpenTelemetry, respectivamente. Você cria ActivitySource diretamente usando o construtor dele em vez de usar TracerProvider. Cada classe ActivitySource deve ser conectada explicitamente ao TracerProvider usando AddSource(). Isso ocorre porque partes da API de rastreamento do OpenTelemetry são incorporadas diretamente no runtime do .NET. Para saber mais, confira Introdução à API de rastreamento do OpenTelemetry .NET.

// Define an activity source named "ActivitySourceName". This activity source will be used to create activities for all requests to the application.
internal static readonly ActivitySource activitySource = new("ActivitySourceName");

// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a source named "ActivitySourceName". This will ensure that all activities created by the activity source are traced.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

// Map a GET request to the root path ("/") to the specified action.
app.MapGet("/", () =>
{
    // Start a new activity named "CustomActivity". This activity will be traced and the trace data will be sent to Azure Monitor.
    using (var activity = activitySource.StartActivity("CustomActivity"))
    {
        // your code here
    }

    // Return a response message.
    return $"Hello World!";
});

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

StartActivity tem ActivityKind.Internal como padrão, mas você pode fornecer qualquer outro ActivityKind. ActivityKind.Client, ActivityKind.Producer e ActivityKind.Internal são mapeados para o Application Insights dependencies. ActivityKind.Server e ActivityKind.Consumer são mapeados para o Application Insights requests.

Enviar telemetria personalizada usando a API Clássica do Application Insights

Recomendamos que você use as APIs OpenTelemetry sempre que possível, mas pode haver alguns cenários em que você precise usar as API Clássica do Application Insights.

Eventos

  1. Adicione o Microsoft.ApplicationInsights ao seu aplicativo.

  2. Crie uma instância de TelemetryClient.

Observação

É importante criar apenas uma instância do TelemetryClient por aplicativo.

var telemetryConfiguration = new TelemetryConfiguration { ConnectionString = "" };
var telemetryClient = new TelemetryClient(telemetryConfiguration);
  1. Use o cliente para enviar telemetria personalizada.
telemetryClient.TrackEvent("testEvent");

Modificar telemetria

Esta seção explica como modificar a telemetria.

Adicionar atributos de intervalo

Esses atributos podem incluir a adição de uma propriedade personalizada à telemetria. Você também pode usar atributos para definir campos opcionais no esquema do Application Insights, como IP do Cliente.

Adicionar uma propriedade personalizada a um intervalo

Todos os atributos adicionados aos intervalos são exportados como propriedades personalizadas. Elas preenchem o campo customDimensions na tabela de solicitações, dependências, rastreamentos ou exceções.

Adicione atributos de intervalo de uma destas maneiras:

Dica

A vantagem de usar as opções fornecidas pelas bibliotecas de instrumentação, quando disponíveis, é que todo o contexto fica disponível. Assim, os usuários podem optar por adicionar ou filtrar mais atributos. Por exemplo, a opção enriquecer na biblioteca de instrumentação do HttpClient dá aos usuários acesso ao HttpRequestMessage e ao próprio HttpResponseMessage. Eles podem selecionar qualquer coisa nela e armazenar como um atributo.

  1. Muitas bibliotecas de instrumentação fornecem uma opção de enriquecimento. Para obter diretrizes, confira os arquivos Leiame das bibliotecas de instrumentação individuais:

  2. Usar um processador personalizado:

Dica

Adicione o processador mostrado aqui antes de adicionar o Azure Monitor.

// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a new processor named ActivityEnrichingProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityEnrichingProcessor()));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

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

Adicione ActivityEnrichingProcessor.cs ao seu projeto com o seguinte código:

public class ActivityEnrichingProcessor : BaseProcessor<Activity>
{
    public override void OnEnd(Activity activity)
    {
        // The updated activity will be available to all processors which are called after this processor.
        activity.DisplayName = "Updated-" + activity.DisplayName;
        activity.SetTag("CustomDimension1", "Value1");
        activity.SetTag("CustomDimension2", "Value2");
    }
}

Definir o IP do usuário

Você pode popular o campo client_IP para solicitações definindo um atributo no intervalo. A Application Insights usa o endereço IP para gerar atributos de localização do usuário e, em seguida, o descarta por padrão.

Use o exemplo adicionar propriedade personalizada, mas substitua as seguintes linhas de código em ActivityEnrichingProcessor.cs:

// Add the client IP address to the activity as a tag.
// only applicable in case of activity.Kind == Server
activity.SetTag("client.address", "<IP Address>");

Definir a ID do usuário ou a ID do usuário autenticado

Você pode preencher o campo user_Id ou user_AuthenticatedId para solicitações usando as diretrizes a seguir. A ID do usuário é um identificador de usuário anônimo. A ID do usuário autenticado é um identificador de usuário conhecido.

Importante

Veja as leis de privacidade aplicáveis antes de configurar a ID de Usuário autenticado.

Use o exemplo de propriedade personalizada add.

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

Adicionar atributos de log

O OpenTelemetry usa o ILogger do .NET. A anexação de dimensões personalizadas aos registros pode ser realizada usando um modelo de mensagem.

Filtrar telemetria

Use as maneiras a seguir de filtrar a telemetria antes que ela saia do aplicativo.

  1. Muitas bibliotecas de instrumentação fornecem uma opção de filtro. Para obter diretrizes, confira os arquivos Leiame das bibliotecas de instrumentação individuais:

  2. Usar um processador personalizado:

    Dica

    Adicione o processador mostrado aqui antes de adicionar o Azure Monitor.

    // Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a new processor named ActivityFilteringProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityFilteringProcessor()));
// Configure the OpenTelemetry tracer provider to add a new source named "ActivitySourceName".
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));
// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

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

    Adicione ActivityFilteringProcessor.cs ao seu projeto com o seguinte código:

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

  3. Se uma fonte específica não for explicitamente adicionada usando AddSource("ActivitySourceName"), nenhuma das atividades criadas usando essa fonte será exportada.

Obter a ID de rastreamento ou a ID do intervalo

Talvez seja interessante obter a ID do rastreamento ou do intervalo. Se você tiver logs enviados para um destino diferente do Application Insights, considere adicionar a ID de rastreamento ou de intervalo. Isso permite uma melhor correlação ao depurar e diagnosticar problemas.

Observação

As classes Activity e ActivitySource do namespace System.Diagnostics representam os conceitos Span e Tracer do OpenTelemetry, respectivamente. Isso ocorre porque partes da API de rastreamento do OpenTelemetry são incorporadas diretamente no runtime do .NET. Para saber mais, confira Introdução à API de rastreamento do OpenTelemetry .NET.

// Get the current activity.
Activity activity = Activity.Current;
// Get the trace ID of the activity.
string traceId = activity?.TraceId.ToHexString();
// Get the span ID of the activity.
string spanId = activity?.SpanId.ToHexString();

Próximas etapas

Perguntas frequentes

Esta seção fornece respostas para perguntas comuns.

O que é o OpenTelemetry?

É um novo padrão de código aberto para observabilidade. Saiba mais em OpenTelemetry.

Por que o Microsoft Azure Monitor está investindo no OpenTelemetry?

A Microsoft está entre os maiores colaboradores do OpenTelemetry.

As principais propostas de valor do OpenTelemetry são a neutralidade de fornecedor e o fornecimento de APIs/SDKs consistentes em várias linguagens.

Ao longo do tempo, acreditamos que o OpenTelemetry permitirá que os clientes do Azure Monitor observem os aplicativos escritos em linguagens além das nossas linguagens com suporte. Ele também expande os tipos de dados que você pode coletar através de um conjunto avançado de bibliotecas de instrumentação. Além disso, os SDKs do OpenTelemetry tendem a ter mais desempenho em escala do que seus antecessores, os SDKs do Application Insights.

Por fim, o OpenTelemetry se alinha com a estratégia da Microsoft de adoção de código aberto.

Qual é o status do OpenTelemetry?

Confira Status do OpenTelemetry.

O que é a "Distribuição OpenTelemetry do Azure Monitor"?

Você pode pensar nisso como um invólucro fino que reúne todos os componentes do OpenTelemetry para uma experiência de primeira classe no Azure. Esse wrapper também é chamado de distribuição no OpenTelemetry.

Por que devo usar a "Distribuição OpenTelemetry do Azure Monitor"?

Há várias vantagens em usar a Distribuição OpenTelemetry do Azure Monitor em relação ao OpenTelemetry nativo da comunidade:

No espírito do OpenTelemetry, projetamos a distribuição para ser aberta e extensível. Por exemplo, você pode adicionar:

  • Um exportador do Protocolo OpenTelemetry (OTLP) e enviar para um segundo destino simultaneamente
  • Outras bibliotecas de instrumentação não incluídas na distribuição

Como a Distribuição oferece uma distribuição do OpenTelemetry, ela suporta tudo o que é suportado pelo OpenTelemetry. Por exemplo, você pode adicionar mais processadores de telemetria, exportadores ou bibliotecas de instrumentação se o OpenTelemetry der suporte a eles.

Observação

A Distribuição define o amostrador para um amostrador personalizado de taxa fixa para o Application Insights. Você pode alterar isso para um amostrador diferente, mas fazê-lo pode desabilitar alguns dos recursos incluídos na Distribuição. Para obter mais informações sobre o amostrador com suporte, consulte a seção Habilitar Amostragem de Configurar o OpenTelemetry do Azure Monitor.

Para idiomas sem um exportador autônomo do OpenTelemetry com suporte, a Distribuição do OpenTelemetry para Azure Monitor é atualmente a única maneira com suporte para usar o OpenTelemetry com o Azure Monitor. Para idiomas com um exportador autônomo do OpenTelemetry com suporte, você tem a opção de usar tanto a Distribuição do OpenTelemetry do Azure Monitor quanto o exportador autônomo apropriado do OpenTelemetry, dependendo do seu cenário de telemetria. Para obter mais informações, consulte Quando devo usar o exportador do OpenTelemetry do Azure Monitor?.

Como posso testar a Distribuição OpenTelemetry do Azure Monitor?

Confira nossos documentos de ativação para .NET, Java, JavaScript (Node.js) e Python.

Devo usar o OpenTelemetry ou o SDK do Application Insights?

É recomendável usar a Distribuição do OpenTelemetry, a menos que você exija um recurso disponível apenas com suporte formal no SDK do Application Insights.

A adoção do OpenTelemetry agora impede a migração em uma data posterior.

Quando devo usar a o exportador do OpenTelemetry do Azure Monitor?

No caso do ASP.NET Core, do Java, do Node.js e do Python, recomendamos usar a Distribuição do OpenTelemetry para Azure Monitor. Basta uma linha de código para começar.

Para todos os outros cenários do .NET, incluindo o ASP.NET clássico, aplicativos de console, etc., recomendamos usar o exportador do OpenTelemetry do Azure Monitor do .NET: Azure.Monitor.OpenTelemetry.Exporter.

Para cenários de telemetria do Python mais complexos que exigem configuração avançada, recomendamos usar o Exportador OpenTelemetry do Azure Monitor do Python.

Qual é o estado atual da versão dos recursos na Distribuição OpenTelemetry do Azure Monitor?

O gráfico a seguir divide o suporte ao recurso OpenTelemetry para cada idioma.

Recurso .NET Node.js Python Java
Rastreamento distribuído ✅ ✅ ✅ ✅
Métricas personalizadas ✅ ✅ ✅ ✅
Métricas Padrão (precisão atualmente afetada pela amostragem) ✅ ✅ ✅ ✅
Amostragem de taxa fixa ✅ ✅ ✅ ✅
Armazenamento offline e novas tentativas automáticas ✅ ✅ ✅ ✅
Relatório de exceção ✅ ✅ ✅ ✅
Coleção de logs ✅ ⚠️ ✅ ✅
Eventos personalizados ⚠️ ⚠️ ⚠️ ✅
autenticação do Microsoft Entra ✅ ✅ ✅ ✅
Live Metrics ❌ ❌ ❌ ✅
Detectar Contexto do Recurso de VM/VMSS e Serviço de Aplicativo ✅ ❌ ✅ ✅
Detectar o Contexto do Recurso do AKS e das Funções ❌ ❌ ❌ ✅
Filtragem da Extensão do Teste de Disponibilidade ❌ ❌ ❌ ✅
Preenchimento automático da ID de usuário, ID de usuário autenticado e IP do usuário ❌ ❌ ❌ ✅
Substituir/definir manualmente o nome da operação, a ID de usuário ou a ID de usuário autenticado ❌ ❌ ❌ ✅
amostragem adaptável ❌ ❌ ❌ ✅
Profiler ❌ ❌ ❌ ⚠️
Depurador de instantâneo ❌ ❌ ❌ ❌

Chave

O OpenTelemetry pode ser usado para navegadores da Web?

Sim, mas não recomendamos e o Azure não dá suporte a ele. O Javascript do OpenTelemetry é altamente otimizado para Node.js. Nesse caso, recomendamos usar o SDK do JavaScript do Application Insights.

Quando podemos esperar que o SDK do OpenTelemetry esteja disponível para uso em navegadores da Web?

O SDK da Web do OpenTelemetry não tem uma linha do tempo de disponibilidade determinada. Deve demorar alguns anos para algum SDK de navegador ser uma alternativa viável ao SDK do JavaScript do Application Insights.

Posso testar o OpenTelemetry em um navegador da Web hoje?

A área restrita Web do OpenTelemetry é uma bifurcação projetada para fazer o OpenTelemetry funcionar em um navegador. Ainda não é possível enviar telemetria para o Application Insights. O SDK não define eventos gerais do cliente.

Há suporte para a execução do Application Insights junto com agentes concorrentes, como o AppDynamics, DataDog e NewRelic?

Não. Essa prática não é algo que planejamos testar ou oferecer suporte, embora nossas distribuições permitam que você exporte para um ponto de extremidade OTLP junto com o Azure Monitor simultaneamente.

Posso usar versão prévia do recurso em ambientes de produção?

Não recomendamos isso. Consulte os Termos de uso complementares para versões prévias do Microsoft Azure.

Qual é a diferença entre a instrumentação automática e manual?

Consulte a Visão geral do OpenTelemetry.

Posso usar o Coletor do OpenTelemetry?

Alguns clientes usam o Coletor do OpenTelemetry como uma alternativa de agente, embora a Microsoft ainda não dê suporte oficial a uma abordagem baseada em agente para o monitoramento de aplicativos. Enquanto isso, a comunidade de código aberto contribuiu com um Exportador do Azure Monitor para o Coletor do OpenTelemetry, que alguns clientes estão usando para enviar dados para o Application Insights do Azure Monitor. Isso não tem suporte da Microsoft.

Qual é a diferença entre o OpenCensus e o OpenTelemetry?

O OpenCensus é o precursor do OpenTelemetry. A Microsoft ajudou a reunir o OpenTracing e o OpenCensus para criar o OpenTelemetry, um padrão de observabilidade exclusivo para o mundo. O SDK do Python recomendado para produção atual para o Azure Monitor é baseado no OpenCensus. A Microsoft está comprometida em dar suporte ao OpenTelemetry no Azure Monitor.

Solução de problemas

Não está funcionando? Confira a página de solução de problemas do ASP.NET Core.

Suporte

Selecione uma guia para o idioma de sua escolha para descobrir as opções de suporte.

Comentários sobre o OpenTelemetry

Para fornecer comentários: