Adicionar, modificar e filtrar OpenTelemetry

  • Artigo

Este artigo fornece orientação sobre como adicionar, modificar e filtrar o OpenTelemetry para aplicativos que usam o Azure Monitor Application Insights.

Para saber mais sobre os conceitos do OpenTelemetria, consulte a visão geral do OpenTelemetry ou as Perguntas frequentes do OpenTelemetry .

Recolha de dados automática

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

Bibliotecas de instrumentação incluídas

Pedidos do

Dependências

Registo

  • ILogger

Para obter mais informações sobre ILoggero , consulte Registro em log em C# e .NET e exemplos de código.

Notas de rodapé

  • ¹: Suporta a comunicação automática de exceções não tratadas/não detetadas
  • ²: Suporta métricas OpenTelemetry
  • ³: Por padrão, o registro em log é coletado apenas 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 é executado no nível de AVISO ou superior.

Nota

As Distros OpenTelemetry do Azure Monitor incluem mapeamento e lógica personalizados para emitir automaticamente métricas padrão do Application Insights.

Gorjeta

Todas as métricas OpenTelemetry coletadas automaticamente de bibliotecas de instrumentação ou manuais coletadas de codificação personalizada são atualmente consideradas "métricas personalizadas" do Application Insights para fins de faturamento. Saiba mais.

Adicionar uma biblioteca de instrumentação da comunidade

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

Atenção

Não apoiamos nem garantimos a qualidade das bibliotecas de instrumentação comunitárias. Para sugerir um para a nossa distro, publique ou vote na nossa comunidade de feedback. Esteja ciente, alguns são baseados em especificações experimentais OpenTelemetry e podem introduzir futuras mudanças de rutura.

Para adicionar uma biblioteca comunitária, use os ConfigureOpenTelemetryMeterProvider métodos ou ConfigureOpenTelemetryTracerProvider depois de adicionar o pacote nuget para a biblioteca.

O exemplo a seguir demonstra como a instrumentação de tempo de execução pode ser adicionada para coletar métricas extras.

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 seu aplicativo.

Dependendo do seu idioma e tipo de sinal, existem diferentes maneiras de coletar telemetria personalizada, incluindo:

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

A tabela a seguir representa os tipos de telemetria personalizada atualmente suportados:

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

Nota

O Java 3.x do Application Insights escuta a telemetria enviada para a API do Application Insights Classic. Da mesma forma, o Application Insights Node.js 3.x coleta eventos criados com a API do Application Insights Classic. Isso facilita a atualização e preenche uma lacuna em nosso suporte de telemetria personalizada até que todos os tipos de telemetria personalizada sejam suportados por meio da API OpenTelemetria.

Adicionar métricas personalizadas

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

A API 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 métricas no Metrics Explorer. Esse requisito é verdadeiro ao usar a API de métrica 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 OpenTelemetry Metric Instruments.

Instrumento OpenTelemetry Tipo de agregação do Azure Monitor
Contador Soma
Contador assíncrono Soma
Histograma Mín, Máx, Média, Soma e Contagem
Medidor assíncrono Média
UpDownCounter Soma
UpDownCounter assíncrono Soma

Atenção

Os tipos de agregação além do que é mostrado na tabela normalmente não são significativos.

A especificação OpenTelemetry descreve os instrumentos e fornece exemplos de quando você pode usar cada um.

Gorjeta

O histograma é o mais versátil e mais próximo da API GetMetric Classic 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 OpenTelemetry têm um impacto menor no desempenho do seu aplicativo.

Exemplo de histograma

A inicialização do aplicativo deve se inscrever em 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"));

Contraexemplo

A inicialização do aplicativo deve se inscrever em 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 se inscrever em 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 bibliotecas de instrumentação que reportam automaticamente exceções ao Application Insights. No entanto, convém relatar manualmente exceções além do que as bibliotecas de instrumentação relatam. Por exemplo, as exceções detetadas pelo seu código normalmente não são relatadas. Você pode relatá-los para chamar a atenção em experiências relevantes, incluindo a seção de falhas e visualizações de transações 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 extensões personalizadas

Talvez você queira adicionar uma extensão personalizada em dois cenários. Primeiro, quando há uma solicitação de dependência ainda não coletada por uma biblioteca de instrumentação. Em segundo lugar, quando você deseja modelar um processo de aplicativo como uma extensão na visualização de transação de ponta a ponta.

Nota

As Activity classes e ActivitySource do System.Diagnostics namespace representam os conceitos OpenTelemetry de Span e Tracer, respectivamente. Você cria ActivitySource diretamente usando seu construtor em vez de usar TracerProvider. Cada ActivitySource classe deve ser explicitamente conectada usando AddSource()TracerProvider . Isso ocorre porque partes da API de rastreamento OpenTelemetry são incorporadas diretamente ao tempo de execução do .NET. Para saber mais, consulte 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 padrão para ActivityKind.Internal, mas você pode fornecer qualquer outro ActivityKind. ActivityKind.Client, ActivityKind.Producere 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 do OpenTelemetry sempre que possível, mas pode haver alguns cenários em que você precisa usar a API do Application Insights Classic.

evento

  1. Adicione Microsoft.ApplicationInsights à sua aplicação.

  2. Crie uma TelemetryClient instância.

Nota

É 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 span

Esses atributos podem incluir a adição de uma propriedade personalizada à sua 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 Span

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

Para adicionar atributos span, use uma das duas maneiras a seguir:

  • Use as opções fornecidas pelas bibliotecas de instrumentação.
  • Adicione um processador span personalizado.

Gorjeta

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

  1. Muitas bibliotecas de instrumentação oferecem uma opção enriquecedora. Para obter orientação, consulte os arquivos readme de bibliotecas de instrumentação individuais:

  2. Use um processador personalizado:

Gorjeta

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 preencher o campo client_IP para solicitações definindo um atributo na extensão. O Application Insights usa o endereço IP para gerar atributos de localização do usuário e, em seguida, descarta-o por padrão.

Use o exemplo de 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 o ID de usuário ou o ID de usuário autenticado

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

Importante

Consulte as leis de privacidade aplicáveis antes de definir o ID de Usuário Autenticado.

Use o exemplo de adicionar propriedade personalizada.

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

OpenTelemetry usa . NET's ILogger. A anexação de dimensões personalizadas aos logs pode ser realizada usando um modelo de mensagem.

Filtrar telemetria

Você pode usar as seguintes maneiras de filtrar a telemetria antes que ela saia do seu aplicativo.

  1. Muitas bibliotecas de instrumentação fornecem uma opção de filtro. Para obter orientação, consulte os arquivos readme de bibliotecas de instrumentação individuais:

  2. Use um processador personalizado:

    Gorjeta

    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 determinada fonte não for adicionada explicitamente usando AddSource("ActivitySourceName")o , nenhuma das atividades criadas usando essa fonte será exportada.

Obter o ID de rastreamento ou o ID de extensão

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

Nota

As Activity classes e ActivitySource do System.Diagnostics namespace representam os conceitos OpenTelemetry de Span e Tracer, respectivamente. Isso ocorre porque partes da API de rastreamento OpenTelemetry são incorporadas diretamente ao tempo de execução do .NET. Para saber mais, consulte 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óximos passos

  • Para configurar ainda mais a distro OpenTelemetria, consulte Configuração do Azure Monitor OpenTelemetry
  • Para revisar o código-fonte, consulte o repositório GitHub do Azure Monitor AspNetCore.
  • Para instalar o pacote NuGet, verificar se há atualizações ou exibir notas de versão, consulte a página Pacote NuGet do Azure Monitor AspNetCore.
  • Para se familiarizar com o Azure Monitor e o OpenTelemetry, consulte o Aplicativo de exemplo do Azure Monitor.
  • Para saber mais sobre o OpenTelemetry e sua comunidade, consulte o repositório OpenTelemetry .NET GitHub.
  • Para habilitar experiências de uso, habilite o monitoramento de usuários da Web ou do navegador.

Perguntas mais frequentes

Esta secção fornece respostas a perguntas comuns.

O que é OpenTelemetry?

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

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

A Microsoft está entre os maiores contribuintes para o OpenTelemetry.

As principais propostas de valor do OpenTelemetry são que ele é neutro em relação ao fornecedor e fornece APIs/SDKs consistentes entre idiomas.

Com o tempo, acreditamos que o OpenTelemetry permitirá que os clientes do Azure Monitor observem aplicativos escritos em idiomas além dos nossos idiomas suportados. Ele também expande os tipos de dados que você pode coletar por meio de um rico conjunto de bibliotecas de instrumentação. Além disso, os SDKs OpenTelemetry tendem a ter mais desempenho em escala do que seus antecessores, os SDKs do Application Insights.

Finalmente, o OpenTelemetry está alinhado com a estratégia da Microsoft de adotar o código aberto.

Qual é o status do OpenTelemetry?

Consulte Status do OpenTelemetry .

O que é a "Distro OpenTelemetry do Azure Monitor"?

Você pode pensar nele como um wrapper fino que agrupa todos os componentes do OpenTelemetry para uma experiência de primeira classe no Azure. Este wrapper também é chamado de distribuição em OpenTelemetry.

Por que devo usar a "Distro OpenTelemetry do Azure Monitor"?

Há várias vantagens em usar a Distro OpenTelemetry do Azure Monitor em relação à OpenTelemetry nativa da comunidade:

No espírito da OpenTelemetry, projetamos a distro para ser aberta e extensível. Por exemplo, você pode adicionar:

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

Como a Distro fornece uma distribuição OpenTelemetria, a Distro suporta qualquer coisa suportada pela OpenTelemetry. Por exemplo, você pode adicionar mais processadores de telemetria, exportadores ou bibliotecas de instrumentação, se o OpenTelemetry oferecer suporte a eles.

Nota

A Distro define o amostrador como um amostrador personalizado de taxa fixa para o Application Insights. Você pode alterar isso para um amostrador diferente, mas isso pode desativar alguns dos recursos incluídos da distro. Para obter mais informações sobre o amostrador suportado, consulte a seção Habilitar amostragem de Configurar o Azure Monitor OpenTelemetry.

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

Como posso testar a Distro 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?

Recomendamos o uso da Distro OpenTelemetry a menos que você precise de um recurso que só esteja disponível com suporte formal no SDK do Application Insights.

A adoção do OpenTelemetry agora evita a necessidade de migrar posteriormente.

Quando devo usar o exportador OpenTelemetry do Azure Monitor?

Para ASP.NET Core, Java, Node.js e Python, recomendamos o uso da Distro OpenTelemetry do Azure Monitor. É uma linha de código para começar.

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

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

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

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

Caraterística .NET Node.js Python Java
Rastreio distribuído ✅ ✅ ✅ ✅
Métricas personalizadas ✅ ✅ ✅ ✅
Métricas padrão (precisão atualmente afetada pela amostragem) ✅ ✅ ✅ ✅
Amostragem de taxa fixa ✅ ✅ ✅ ✅
Armazenamento offline e repetições automáticas ✅ ✅ ✅ ✅
Relatório de exceções ✅ ✅ ✅ ✅
Recolha de registos ✅ ⚠️ ✅ ✅
Eventos personalizados ⚠️ ⚠️ ⚠️ ✅
Autenticação do Microsoft Entra ✅ ✅ ✅ ✅
Métricas em tempo real ❌ ❌ ❌ ✅
Detetar contexto de recursos para VM/VMSS e Serviço de Aplicativo ✅ ❌ ✅ ✅
Detetar contexto de recursos para AKS e funções ❌ ❌ ❌ ✅
Filtragem de extensão de teste de disponibilidade ❌ ❌ ❌ ✅
Preenchimento automático de ID de usuário, ID de usuário autenticado e IP de usuário ❌ ❌ ❌ ✅
Substituir/definir manualmente o nome da operação, o ID do usuário ou o ID do usuário autenticado ❌ ❌ ❌ ✅
Amostragem adaptável ❌ ❌ ❌ ✅
Gerador de perfis ❌ ❌ ❌ ⚠️
Depurador de Instantâneos ❌ ❌ ❌ ❌

Chave

  • ✅ Este recurso está disponível para todos os clientes com suporte formal.
  • ⚠️ Esta funcionalidade está disponível como pré-visualização pública. Consulte Termos de utilização suplementares para pré-visualizações do Microsoft Azure.
  • ❌ Este recurso não está disponível ou não é aplicável.

O OpenTelemetry pode ser usado para navegadores da web?

Sim, mas não o recomendamos e o Azure não o suporta. OpenTelemetry JavaScript é altamente otimizado para Node.js. Em vez disso, recomendamos o uso do SDK JavaScript do Application Insights.

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

O SDK da Web OpenTelemetry não tem um cronograma de disponibilidade determinado. É provável que estejamos a vários anos de distância de um SDK de navegador que seja uma alternativa viável ao SDK JavaScript do Application Insights.

Posso testar o OpenTelemetry em um navegador da Web hoje?

A área restrita da Web 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.

A execução do Application Insights ao lado de agentes concorrentes como AppDynamics, DataDog e NewRelic é suportada?

N.º Essa prática não é algo que planejamos testar ou suportar, embora nossas Distros permitam que você exporte para um ponto de extremidade OTLP ao lado do Azure Monitor simultaneamente.

Posso usar recursos de visualização em ambientes de produção?

Nós não recomendamos. Consulte Termos de utilização suplementares para pré-visualizações do Microsoft Azure.

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

Consulte a Visão geral do OpenTelemetry .

Posso usar o OpenTelemetry Collector?

Alguns clientes usam o OpenTelemetry Collector como uma alternativa de agente, embora a Microsoft ainda não ofereça suporte oficial a uma abordagem baseada em agente para monitoramento de aplicativos. Enquanto isso, a comunidade de código aberto contribuiu com um OpenTelemetry Collector Azure Monitor Exporter que alguns clientes estão usando para enviar dados para o Azure Monitor Application Insights. Isso não é suportado pela Microsoft.

Qual é a diferença entre OpenCensus e OpenTelemetry?

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

Resolução de Problemas

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

Suporte

Selecione uma guia para o idioma de sua escolha para descobrir opções de 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.

Comentários do OpenTelemetry

Para fornecer comentários: