Este artigo aborda as definições de configuração para a distro OpenTelemetry do Azure Monitor.
Connection string
Uma cadeia de conexão no Application Insights define o local de destino para o envio de dados de telemetria, garantindo que eles atinjam o recurso apropriado para monitoramento e análise.
Use uma das três maneiras a seguir para configurar a cadeia de conexão:
Adicione UseAzureMonitor() à inicialização do seu aplicativo, em sua program.cs classe.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
options.ConnectionString = "<Your Connection String>";
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Se você definir a cadeia de conexão em mais de um lugar, respeitaremos a seguinte precedência:
Código
Variável de Ambiente
Arquivo de configuração
Use uma das duas maneiras a seguir para configurar a cadeia de conexão:
Adicione o Exportador do Azure Monitor a cada sinal OpenTelemetry na inicialização do aplicativo.
// Create a new OpenTelemetry tracer provider.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(options =>
{
options.ConnectionString = "<Your Connection String>";
});
// Create a new OpenTelemetry meter provider.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter(options =>
{
options.ConnectionString = "<Your Connection String>";
});
// Create a new logger factory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddAzureMonitorLogExporter(options =>
{
options.ConnectionString = "<Your Connection String>";
});
});
});
// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
// Create a new AzureMonitorOpenTelemetryOptions object.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString: "<your connection string>"
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
Use uma das duas maneiras a seguir para configurar a cadeia de conexão:
# Import the `configure_azure_monitor()` function from the `azure.monitor.opentelemetry` package.
from azure.monitor.opentelemetry import configure_azure_monitor
# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<your-connection-string>` with the connection string of your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="<your-connection-string>",
)
Definir o nome da função de nuvem e a instância de função de nuvem
Para idiomas suportados, a Distro OpenTelemetry do Azure Monitor deteta automaticamente o contexto do recurso e fornece valores padrão para as propriedades Nome da Função de Nuvem e Instância de Função de Nuvem do seu componente. No entanto, talvez você queira substituir os valores padrão por algo que faça sentido para sua equipe. O valor do nome da função de nuvem aparece no Mapa do Aplicativo como o nome abaixo de um nó.
Defina o Nome da Função de Nuvem e a Instância de Função de Nuvem por meio dos atributos de Recurso . O Nome da Função de Nuvem usa service.namespace e service.name atributa, embora caia para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do service.instance.id atributo. Para obter informações sobre atributos padrão para recursos, consulte Convenções semânticas OpenTelemetry .
// Setting role name and role instance
// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
{ "service.name", "my-service" },
{ "service.namespace", "my-namespace" },
{ "service.instance.id", "my-instance" }};
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry()
.UseAzureMonitor()
// Configure the ResourceBuilder to add the custom resource attributes to all signals.
// Custom resource attributes should be added AFTER AzureMonitor to override the default ResourceDetectors.
.ConfigureResource(resourceBuilder => resourceBuilder.AddAttributes(_testResourceAttributes));
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Defina o Nome da Função de Nuvem e a Instância de Função de Nuvem por meio dos atributos de Recurso . O Nome da Função de Nuvem usa service.namespace e service.name atributa, embora caia para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do service.instance.id atributo. Para obter informações sobre atributos padrão para recursos, consulte Convenções semânticas OpenTelemetry .
// Setting role name and role instance
// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
{ "service.name", "my-service" },
{ "service.namespace", "my-namespace" },
{ "service.instance.id", "my-instance" }};
// Create a resource builder.
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);
// Create a new OpenTelemetry tracer provider and set the resource builder.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
// Set ResourceBuilder on the TracerProvider.
.SetResourceBuilder(resourceBuilder)
.AddAzureMonitorTraceExporter();
// Create a new OpenTelemetry meter provider and set the resource builder.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
// Set ResourceBuilder on the MeterProvider.
.SetResourceBuilder(resourceBuilder)
.AddAzureMonitorMetricExporter();
// Create a new logger factory and add the OpenTelemetry logger provider with the resource builder.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
// Set ResourceBuilder on the Logging config.
options.SetResourceBuilder(resourceBuilder);
options.AddAzureMonitorLogExporter();
});
});
Para definir o nome da função de nuvem, consulte Nome da função de nuvem.
Para definir a instância de função de nuvem, consulte Instância de função de nuvem.
Para definir o nome da função de nuvem:
Use o para aplicativos de imagem nativos do spring.application.name Spring Boot
Use o para aplicativos de imagem nativa do quarkus.application.name Quarkus
Defina o Nome da Função de Nuvem e a Instância de Função de Nuvem por meio dos atributos de Recurso . O Nome da Função de Nuvem usa service.namespace e service.name atributa, embora caia para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do service.instance.id atributo. Para obter informações sobre atributos padrão para recursos, consulte Convenções semânticas OpenTelemetry .
// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, the Resource class, and the SemanticResourceAttributes class from the @azure/monitor-opentelemetry, @opentelemetry/resources, and @opentelemetry/semantic-conventions packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { Resource } = require("@opentelemetry/resources");
const { SemanticResourceAttributes } = require("@opentelemetry/semantic-conventions");
// Create a new Resource object with the following custom resource attributes:
//
// * service_name: my-service
// * service_namespace: my-namespace
// * service_instance_id: my-instance
const customResource = new Resource({
[SemanticResourceAttributes.SERVICE_NAME]: "my-service",
[SemanticResourceAttributes.SERVICE_NAMESPACE]: "my-namespace",
[SemanticResourceAttributes.SERVICE_INSTANCE_ID]: "my-instance",
});
// Create a new AzureMonitorOpenTelemetryOptions object and set the resource property to the customResource object.
const options: AzureMonitorOpenTelemetryOptions = {
resource: customResource
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
Defina o Nome da Função de Nuvem e a Instância de Função de Nuvem por meio dos atributos de Recurso . O Nome da Função de Nuvem usa service.namespace e service.name atributa, embora caia para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do service.instance.id atributo. Para obter informações sobre atributos padrão para recursos, consulte Convenções semânticas OpenTelemetry .
Defina atributos de recurso usando as variáveis e OTEL_RESOURCE_ATTRIBUTES /ou OTEL_SERVICE_NAME de ambiente. OTEL_RESOURCE_ATTRIBUTES usa uma série de pares chave-valor separados por vírgula. Por exemplo, para definir o Nome da Função de Nuvem como my-namespace.my-helloworld-service e a Instância de Função de Nuvem como my-instance, você pode definir OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME , como tal:
Se você não definir o service.namespace atributo Resource, poderá alternativamente definir o Nome da Função de Nuvem apenas com a variável de ambiente OTEL_SERVICE_NAME ou o service.name atributo Resource. Por exemplo, para definir o Nome da Função de Nuvem como my-helloworld-service e a Instância de Função de Nuvem como my-instance, você pode definir OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME , como tal:
Talvez você queira habilitar a amostragem para reduzir o volume de ingestão de dados, o que reduz o custo. O Azure Monitor fornece um amostrador de taxa fixa personalizado que preenche eventos com uma taxa de amostragem, que o Application Insights converte em ItemCount. O amostrador de taxa fixa garante experiências precisas e contagens de eventos. O amostrador foi projetado para preservar seus rastreamentos entre serviços e é interoperável com SDKs (Software Development Kits) mais antigos do Application Insights. Para obter mais informações, consulte Saiba mais sobre amostragem.
Nota
As métricas e os logs não são afetados pela amostragem.
O amostrador espera uma taxa de amostragem entre 0 e 1, inclusive. Uma taxa de 0,1 significa que aproximadamente 10% dos seus vestígios são enviados.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
// Set the sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
o.SamplingRatio = 0.1F;
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
O amostrador espera uma taxa de amostragem entre 0 e 1, inclusive. Uma taxa de 0,1 significa que aproximadamente 10% dos seus vestígios são enviados.
// Create a new OpenTelemetry tracer provider.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(options =>
{
// Set the sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
options.SamplingRatio = 0.1F;
});
A partir da versão 3.4.0, a amostragem com taxa limitada está disponível e agora é o padrão. Para obter mais informações sobre amostragem, consulte Amostragem Java.
Para aplicativos nativos do Quarkus, consulte a documentação do Quarkus OpenTelemetry .
O amostrador espera uma taxa de amostragem entre 0 e 1, inclusive. Uma taxa de 0,1 significa que aproximadamente 10% dos seus vestígios são enviados.
// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
// Create a new AzureMonitorOpenTelemetryOptions object and set the samplingRatio property to 0.1.
const options: AzureMonitorOpenTelemetryOptions = {
samplingRatio: 0.1
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
A configure_azure_monitor() função utiliza automaticamente o ApplicationInsightsSampler para compatibilidade com SDKs do Application Insights e para obter amostras de sua telemetria. A OTEL_TRACES_SAMPLER_ARG variável ambiente pode ser usada para especificar a taxa de amostragem, com um intervalo válido de 0 a 1, onde 0 é 0% e 1 é 100%.
Por exemplo, um valor de 0,1 significa que 10% dos seus rastreamentos são enviados.
export OTEL_TRACES_SAMPLER_ARG=0.1
Gorjeta
Ao usar amostragem de taxa fixa/porcentagem e você não tiver certeza do que definir a taxa de amostragem, comece em 5% (ou seja, razão de amostragem de 0,05) e ajuste a taxa com base na precisão das operações mostradas nos painéis de falhas e desempenho. Uma taxa mais alta geralmente resulta em maior precisão. No entanto, QUALQUER amostragem afetará a precisão, por isso recomendamos alertar sobre as métricas OpenTelemetry que não são afetadas pela amostragem.
Métricas em tempo real
As métricas em tempo real fornecem um painel de análise em tempo real para obter informações sobre a atividade e o desempenho do aplicativo.
Habilitar a autenticação do Microsoft Entra ID (anteriormente Azure AD)
Talvez você queira habilitar a autenticação do Microsoft Entra para uma conexão mais segura com o Azure, o que impede que a telemetria não autorizada seja ingerida em sua assinatura.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
// Set the Azure Monitor credential to the DefaultAzureCredential.
// This credential will use the Azure identity of the current user or
// the service principal that the application is running as to authenticate
// to Azure Monitor.
options.Credential = new DefaultAzureCredential();
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Damos suporte às classes de credenciais fornecidas pela Identidade do Azure.
Recomendamos para o DefaultAzureCredential desenvolvimento local.
Recomendamos ManagedIdentityCredential para identidades gerenciadas atribuídas pelo sistema e pelo usuário.
Para system-assigned, use o construtor padrão sem parâmetros.
Para o usuário atribuído, forneça o ID do cliente para o construtor.
Recomendamos ClientSecretCredential para entidades de serviço.
Forneça a ID do locatário, a ID do cliente e o segredo do cliente para o construtor.
// Create a DefaultAzureCredential.
var credential = new DefaultAzureCredential();
// Create a new OpenTelemetry tracer provider and set the credential.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(options =>
{
options.Credential = credential;
});
// Create a new OpenTelemetry meter provider and set the credential.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter(options =>
{
options.Credential = credential;
});
// Create a new logger factory and add the OpenTelemetry logger provider with the credential.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddAzureMonitorLogExporter(options =>
{
options.Credential = credential;
});
});
});
Para obter mais informações sobre Java, consulte a documentação suplementar do Java.
A autenticação Microsoft Entra ID não está disponível para aplicativos nativos GraalVM.
Damos suporte às classes de credenciais fornecidas pela Identidade do Azure.
// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, and the ManagedIdentityCredential class from the @azure/monitor-opentelemetry and @azure/identity packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { ManagedIdentityCredential } = require("@azure/identity");
// Create a new ManagedIdentityCredential object.
const credential = new ManagedIdentityCredential();
// Create a new AzureMonitorOpenTelemetryOptions object and set the credential property to the credential object.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
credential: credential
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
# Import the `ManagedIdentityCredential` class from the `azure.identity` package.
from azure.identity import ManagedIdentityCredential
# Import the `configure_azure_monitor()` function from the `azure.monitor.opentelemetry` package.
from azure.monitor.opentelemetry import configure_azure_monitor
# Configure OpenTelemetry to use Azure Monitor with a managed identity credential.
# This will allow OpenTelemetry to authenticate to Azure Monitor without requiring you to provide a connection string.
configure_azure_monitor(
credential=ManagedIdentityCredential(),
)
Armazenamento off-line e novas tentativas automáticas
Para melhorar a confiabilidade e a resiliência, as ofertas baseadas em OpenTelemetria do Azure Monitor gravam no armazenamento offline/local por padrão quando um aplicativo perde sua conexão com o Application Insights. Ele salva a telemetria do aplicativo no disco e periodicamente tenta enviá-lo novamente por até 48 horas. Em aplicações de alta carga, a telemetria é ocasionalmente descartada por dois motivos. Primeiro, quando o tempo permitido é excedido e, segundo, quando o tamanho máximo do arquivo é excedido ou o SDK não tem a oportunidade de limpar o arquivo. Se precisarmos escolher, o produto salva eventos mais recentes do que os antigos. Saiba Mais
O pacote Distro inclui o AzureMonitorExporter, que por padrão usa um dos seguintes locais para armazenamento offline (listados em ordem de precedência):
Windows
%LOCALAPPDATA%\Microsoft\AzureMonitor
%TEMP%\Microsoft\AzureMonitor
Não-Windows
%TMPDIR%/Microsoft/AzureMonitor
/var/tmp/Microsoft/AzureMonitor
/tmp/Microsoft/AzureMonitor
Para substituir o diretório padrão, você deve definir AzureMonitorOptions.StorageDirectory.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any telemetry data that cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Para desativar esse recurso, você deve definir AzureMonitorOptions.DisableOfflineStorage = true.
Por padrão, o AzureMonitorExporter usa um dos seguintes locais para armazenamento offline (listado em ordem de precedência):
Windows
%LOCALAPPDATA%\Microsoft\AzureMonitor
%TEMP%\Microsoft\AzureMonitor
Não-Windows
%TMPDIR%/Microsoft/AzureMonitor
/var/tmp/Microsoft/AzureMonitor
/tmp/Microsoft/AzureMonitor
Para substituir o diretório padrão, você deve definir AzureMonitorExporterOptions.StorageDirectory.
// Create a new OpenTelemetry tracer provider and set the storage directory.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any trace data that cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
// Create a new OpenTelemetry meter provider and set the storage directory.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any metric data that cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
// Create a new logger factory and add the OpenTelemetry logger provider with the storage directory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddAzureMonitorLogExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any log data that cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
});
});
Para desativar esse recurso, você deve definir AzureMonitorExporterOptions.DisableOfflineStorage = true.
Configurar o armazenamento offline e as repetições automáticas não está disponível em Java.
Para obter uma lista completa das configurações disponíveis, consulte Opções de configuração.
A configuração do armazenamento offline e das repetições automáticas não está disponível em aplicativos de imagem nativa Java.
Por padrão, o AzureMonitorExporter usa um dos seguintes locais para armazenamento offline.
Windows
%TEMP%\Microsoft\AzureMonitor
Não-Windows
%TMPDIR%/Microsoft/AzureMonitor
/var/tmp/Microsoft/AzureMonitor
Para substituir o diretório padrão, você deve definir storageDirectory.
Por exemplo:
// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
// Create a new AzureMonitorOpenTelemetryOptions object and set the azureMonitorExporterOptions property to an object with the following properties:
//
// * connectionString: The connection string for your Azure Monitor Application Insights resource.
// * storageDirectory: The directory where the Azure Monitor OpenTelemetry exporter will store telemetry data when it is offline.
// * disableOfflineStorage: A boolean value that specifies whether to disable offline storage.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString: "<Your Connection String>",
storageDirectory: "C:\\SomeDirectory",
disableOfflineStorage: false
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
Para desativar esse recurso, você deve definir disableOfflineStorage = true.
Por padrão, os exportadores do Azure Monitor usam o seguinte caminho:
Para substituir o diretório padrão, você deve definir storage_directory para o diretório desejado.
Por exemplo:
...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and storage directory.
# Replace `your-connection-string` with the connection string to your Azure Monitor Application Insights resource.
# Replace `C:\\SomeDirectory` with the directory where you want to store the telemetry data before it is sent to Azure Monitor.
configure_azure_monitor(
connection_string="your-connection-string",
storage_directory="C:\\SomeDirectory",
)
...
Para desativar esse recurso, você deve definir disable_offline_storage como True. O padrão é False.
Por exemplo:
...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and disable offline storage.
# Replace `your-connection-string` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="your-connection-string",
disable_offline_storage=True,
)
...
Habilitar o Exportador OTLP
Talvez você queira habilitar o Exportador de Protocolo de Telemetria Aberta (OTLP) junto com o Exportador do Azure Monitor para enviar sua telemetria para dois locais.
Nota
O Exportador OTLP é mostrado apenas por conveniência. Não suportamos oficialmente o Exportador OTLP ou quaisquer componentes ou experiências de terceiros a jusante do mesmo.
Adicione o seguinte trecho de código. Este exemplo pressupõe que você tenha um OpenTelemetry Collector com um recetor OTLP em execução. Para obter detalhes, consulte o exemplo no GitHub.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();
// Add the OpenTelemetry OTLP exporter to the application.
// This exporter will send telemetry data to an OTLP receiver, such as Prometheus
builder.Services.AddOpenTelemetry().WithTracing(builder => builder.AddOtlpExporter());
builder.Services.AddOpenTelemetry().WithMetrics(builder => builder.AddOtlpExporter());
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Adicione o seguinte trecho de código. Este exemplo pressupõe que você tenha um OpenTelemetry Collector com um recetor OTLP em execução. Para obter detalhes, consulte o exemplo no GitHub.
// Create a new OpenTelemetry tracer provider and add the Azure Monitor trace exporter and the OTLP trace exporter.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter()
.AddOtlpExporter();
// Create a new OpenTelemetry meter provider and add the Azure Monitor metric exporter and the OTLP metric exporter.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter()
.AddOtlpExporter();
Para obter mais informações sobre Java, consulte a documentação suplementar do Java.
Não é possível habilitar o Exportador de Protocolo de Telemetria Aberta (OTLP) junto com o Exportador do Azure Monitor para enviar sua telemetria para dois locais.
Adicione o seguinte trecho de código. Este exemplo pressupõe que você tenha um OpenTelemetry Collector com um recetor OTLP em execução. Para obter detalhes, consulte o exemplo no GitHub.
// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, the trace module, the ProxyTracerProvider class, the BatchSpanProcessor class, the NodeTracerProvider class, and the OTLPTraceExporter class from the @azure/monitor-opentelemetry, @opentelemetry/api, @opentelemetry/sdk-trace-base, @opentelemetry/sdk-trace-node, and @opentelemetry/exporter-trace-otlp-http packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
// Create a new OTLPTraceExporter object.
const otlpExporter = new OTLPTraceExporter();
// Enable Azure Monitor integration.
const options: AzureMonitorOpenTelemetryOptions = {
// Add the SpanEnrichingProcessor
spanProcessors: [new BatchSpanProcessor(otlpExporter)]
}
useAzureMonitor(options);
Adicione o seguinte trecho de código. Este exemplo pressupõe que você tenha um OpenTelemetry Collector com um recetor OTLP em execução. Para obter detalhes, consulte este LEIA-ME.
# Import the `configure_azure_monitor()`, `trace`, `OTLPSpanExporter`, and `BatchSpanProcessor` classes from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor
# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<your-connection-string>` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="<your-connection-string>",
)
# Get the tracer for the current module.
tracer = trace.get_tracer(__name__)
# Create an OTLP span exporter that sends spans to the specified endpoint.
# Replace `http://localhost:4317` with the endpoint of your OTLP collector.
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317")
# Create a batch span processor that uses the OTLP span exporter.
span_processor = BatchSpanProcessor(otlp_exporter)
# Add the batch span processor to the tracer provider.
trace.get_tracer_provider().add_span_processor(span_processor)
# Start a new span with the name "test".
with tracer.start_as_current_span("test"):
print("Hello world!")
Configurações OpenTelemetry
As seguintes configurações do OpenTelemetry podem ser acessadas por meio de variáveis de ambiente ao usar as Distros OpenTelemetry do Azure Monitor.
Defina-o como a cadeia de conexão do recurso do Application Insights.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED
Defina-o como true para desativar a coleta de métricas internas.
OTEL_RESOURCE_ATTRIBUTES
Pares chave-valor a serem usados como atributos de recurso. Para obter mais informações sobre atributos de recursos, consulte a especificação do SDK de recursos.
OTEL_SERVICE_NAME
Define o service.name valor do atributo de recurso. Se service.name também for fornecido em OTEL_RESOURCE_ATTRIBUTES, então OTEL_SERVICE_NAME tem precedência.
Variável de ambiente
Description
APPLICATIONINSIGHTS_CONNECTION_STRING
Defina-o como a cadeia de conexão do recurso do Application Insights.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED
Defina-o como true para desativar a coleta de métricas internas.
OTEL_RESOURCE_ATTRIBUTES
Pares chave-valor a serem usados como atributos de recurso. Para obter mais informações sobre atributos de recursos, consulte a especificação do SDK de recursos.
OTEL_SERVICE_NAME
Define o service.name valor do atributo de recurso. Se service.name também for fornecido em OTEL_RESOURCE_ATTRIBUTES, então OTEL_SERVICE_NAME tem precedência.
Para obter mais informações sobre Java, consulte a documentação suplementar do Java.
Variável de ambiente
Description
APPLICATIONINSIGHTS_CONNECTION_STRING
Defina-o como a cadeia de conexão do recurso do Application Insights.
Para aplicativos nativos do Spring Boot, as configurações do OpenTelemetry Java SDK estão disponíveis.
Para aplicativos nativos do Quarkus, consulte a documentação do Quarkus OpenTelemetry .
Para obter mais informações sobre a configuração do OpenTelemetry SDK, consulte a documentação do OpenTelemetry .
Para obter mais informações sobre a configuração do OpenTelemetry SDK, consulte a documentação do OpenTelemetry e o Azure monitor Distro Usage.
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 (Software Development Kits) OpenTelemetry tendem a ter um desempenho mais eficiente 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.
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:
Reduz o esforço de habilitação
Suportado pela Microsoft
Traz recursos específicos do Azure, como:
Amostragem compatível com SDKs clássicos do Application Insights
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?
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, Windows Forms (WinForms), etc., recomendamos o uso do 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.
❌ 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?
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?
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.
Em Grafana, por que eu vejo Status: 500. Can't visualize trace events using the trace visualizer?
Você pode estar tentando visualizar logs de texto bruto em vez de rastreamentos OpenTelemetry .
No Application Insights, a tabela 'Rastreamentos' armazena logs de texto bruto para fins de diagnóstico. Eles ajudam a identificar e correlacionar rastreamentos associados a solicitações de usuários, outros eventos e relatórios de exceções. No entanto, a tabela 'Rastreamentos' não contribui diretamente para a visualização de transação de ponta a ponta (gráfico em cascata) em ferramentas de visualização como o Grafana.
Com a crescente adoção de práticas nativas da nuvem, há uma evolução na coleta de telemetria e na terminologia. OpenTelemetry tornou-se um padrão para coletar e instrumentar dados de telemetria. Neste contexto, o termo «vestígios» adquiriu um novo significado. Em vez de logs brutos, 'Traces' no OpenTelemetry referem-se a uma forma mais rica e estruturada de telemetria que inclui vãos, que representam unidades individuais de trabalho. Essas extensões são cruciais para construir visualizações detalhadas de transações, permitindo um melhor monitoramento e diagnóstico de aplicativos nativos da nuvem.
O Exportador do Azure Monitor usa EventSource para seu log interno. Os logs do exportador estão disponíveis para qualquer EventListener ao aceitar a fonte nomeada OpenTelemetry-AzureMonitor-Exporter. Para conhecer as etapas de solução de problemas, consulte Solução de problemas do OpenTelemetry no GitHub.
Etapa 2: Testar a conectividade entre o host do aplicativo e o serviço de ingestão
SDKs e agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST em nossos pontos de extremidade de ingestão. Para testar a conectividade do seu servidor Web ou computador host de aplicativo com os pontos de extremidade do serviço de ingestão, use comandos cURL ou solicitações REST brutas do PowerShell. Para obter mais informações, consulte Solucionar problemas de telemetria de aplicativo ausente no Azure Monitor Application Insights.
Problemas conhecidos
Os seguintes itens são problemas conhecidos para os Exportadores OpenTelemetry do Azure Monitor:
O nome da operação está ausente da telemetria de dependência. O nome da operação ausente causa falhas e afeta negativamente a experiência da guia de desempenho.
O modelo de dispositivo está ausente da telemetria de solicitação e dependência. O modelo de dispositivo ausente afeta negativamente a análise de coorte de dispositivos.
Etapa 1: Habilitar o log de diagnóstico
O Exportador do Azure Monitor usa EventSource para seu log interno. Os logs do exportador estão disponíveis para qualquer EventListener ao aceitar a fonte nomeada OpenTelemetry-AzureMonitor-Exporter. Para conhecer as etapas de solução de problemas, consulte Solução de problemas do OpenTelemetry no GitHub.
Etapa 2: Testar a conectividade entre o host do aplicativo e o serviço de ingestão
SDKs e agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST em nossos pontos de extremidade de ingestão. Para testar a conectividade do seu servidor Web ou computador host de aplicativo com os pontos de extremidade do serviço de ingestão, use comandos cURL ou solicitações REST brutas do PowerShell. Para obter mais informações, consulte Solucionar problemas de telemetria de aplicativo ausente no Azure Monitor Application Insights.
Problemas conhecidos
Os seguintes itens são problemas conhecidos para os Exportadores OpenTelemetry do Azure Monitor:
O nome da operação está ausente da telemetria de dependência. O nome da operação ausente causa falhas e afeta negativamente a experiência da guia de desempenho.
O modelo de dispositivo está ausente da telemetria de solicitação e dependência. O modelo de dispositivo ausente afeta negativamente a análise de coorte de dispositivos.
Etapa 2: Testar a conectividade entre o host do aplicativo e o serviço de ingestão
SDKs e agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST em nossos pontos de extremidade de ingestão. Para testar a conectividade do seu servidor Web ou computador host de aplicativo com os pontos de extremidade do serviço de ingestão, use comandos cURL ou solicitações REST brutas do PowerShell. Para obter mais informações, consulte Solucionar problemas de telemetria de aplicativo ausente no Azure Monitor Application Insights.
Problemas conhecidos
Se você baixar a biblioteca de cliente do Application Insights para instalação a partir de um navegador, às vezes o arquivo JAR baixado está corrompido e tem cerca de metade do tamanho do arquivo de origem. Se você enfrentar esse problema, baixe o arquivo JAR executando o comando curl ou wget , conforme mostrado nas seguintes chamadas de comando de exemplo:
As chamadas de comando de exemplo aplicam-se ao Application Insights for Java versão 3.4.11. Para encontrar o número da versão e o endereço URL da versão atual do Application Insights for Java, consulte https://github.com/microsoft/ApplicationInsights-Java/releases.
As etapas a seguir são aplicáveis a aplicativos nativos do Spring Boot.
Etapa 1: Verificar a versão do OpenTelemetry
Você pode notar a seguinte mensagem durante a inicialização do aplicativo:
WARN c.a.m.a.s.OpenTelemetryVersionCheckRunner - The OpenTelemetry version is not compatible with the spring-cloud-azure-starter-monitor dependency.
The OpenTelemetry version should be <version>
Nesse caso, você precisa importar as listas de materiais do OpenTelemetry seguindo a documentação do OpenTelemetry no iniciador do Spring Boot.
Etapa 2: Habilitar o autodiagnóstico
Se algo não funcionar como esperado, você pode habilitar o DEBUG autodiagnóstico no nível para obter alguns insights. Para fazer isso, defina o nível de autodiagnóstico como ERROR, WARN, INFO, DEBUG, ou TRACE usando a APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL variável de ambiente.
Para habilitar o autodiagnóstico no nível ao DEBUG executar um contêiner do docker, execute o seguinte comando:
docker run -e APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL=DEBUG <image-name>
Nota
Substitua <image-name> pelo nome da imagem do docker de acordo.
Exclusão de responsabilidade de informações de terceiros
Os produtos de terceiros que este artigo aborda são fabricados por empresas independentes à Microsoft. A Microsoft não garante, de forma implícita ou de outra forma, o desempenho ou a fiabilidade destes produtos.
Etapa 1: Habilitar o log de diagnóstico
O Azure Monitor Exporter usa o logger da API OpenTelemetry para logs internos. Para habilitar o registrador, execute o seguinte trecho de código:
Etapa 2: Testar a conectividade entre o host do aplicativo e o serviço de ingestão
SDKs e agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST em nossos pontos de extremidade de ingestão. Para testar a conectividade do seu servidor Web ou computador host de aplicativo com os pontos de extremidade do serviço de ingestão, use comandos cURL ou solicitações REST brutas do PowerShell. Para obter mais informações, consulte Solucionar problemas de telemetria de aplicativo ausente no Azure Monitor Application Insights.
Problemas conhecidos
Os seguintes itens são problemas conhecidos para os Exportadores OpenTelemetry do Azure Monitor:
O nome da operação está ausente da telemetria de dependência. O nome da operação ausente causa falhas e afeta negativamente a experiência da guia de desempenho.
O modelo de dispositivo está ausente da telemetria de solicitação e dependência. O modelo de dispositivo ausente afeta negativamente a análise de coorte de dispositivos.
O nome do servidor de banco de dados está ausente do nome da dependência. Como o nome do servidor de banco de dados não está incluído, os Exportadores OpenTelemetry agregam incorretamente tabelas que têm o mesmo nome em servidores diferentes.
Etapa 1: Habilitar o log de diagnóstico
O Microsoft Azure Monitor Exporter usa a biblioteca de log padrão Python para seu log interno. A API OpenTelemetry e os logs do Exportador do Azure Monitor recebem um nível de gravidade de WARNING ou ERROR para atividade irregular. O INFO nível de gravidade é usado para atividade regular ou bem-sucedida.
Por padrão, a biblioteca de log Python define o nível de gravidade como WARNING. Portanto, você deve alterar o nível de gravidade para ver os logs sob essa configuração de gravidade. O código de exemplo a seguir mostra como exportar logs de todos os níveis de gravidade para o console e um arquivo:
Etapa 2: Testar a conectividade entre o host do aplicativo e o serviço de ingestão
SDKs e agentes do Application Insights enviam telemetria para serem ingeridos como chamadas REST em nossos pontos de extremidade de ingestão. Para testar a conectividade do seu servidor Web ou computador host de aplicativo com os pontos de extremidade do serviço de ingestão, use comandos cURL ou solicitações REST brutas do PowerShell. Para obter mais informações, consulte Solucionar problemas de telemetria de aplicativo ausente no Azure Monitor Application Insights.
Etapa 3: Evitar telemetria duplicada
A telemetria duplicada geralmente é causada se você criar várias instâncias de processadores ou exportadores. Certifique-se de executar apenas um exportador e processador de cada vez para cada pilar de telemetria (logs, métricas e rastreamento distribuído).
As seções a seguir descrevem cenários que podem causar telemetria duplicada.
Duplicar logs de rastreamento no Azure Functions
Se você vir um par de entradas para cada log de rastreamento no Application Insights, provavelmente habilitou os seguintes tipos de instrumentação de log:
A instrumentação de log nativa no Azure Functions
A azure-monitor-opentelemetry instrumentação de registro na distribuição
Para evitar duplicação, você pode desabilitar o log da distribuição, mas deixar a instrumentação de log nativa no Azure Functions habilitada. Para fazer isso, defina a OTEL_LOGS_EXPORTER variável de ambiente como None.
Telemetria duplicada no Azure Functions "Always On"
Se a configuração Always On no Azure Functions estiver definida como Ativado, o Azure Functions manterá alguns processos em execução em segundo plano após a conclusão de cada execução. Por exemplo, suponha que você tenha uma função de temporizador de cinco minutos que chama configure_azure_monitor cada vez. Após 20 minutos, você pode ter quatro exportadores de métricas em execução ao mesmo tempo. Essa situação pode ser a origem da telemetria de métricas duplicadas.
Nessa situação, defina a configuração Always On como Desativado ou tente desligar manualmente os provedores entre cada configure_azure_monitor chamada. Para desligar cada provedor, execute chamadas de desligamento para cada provedor de medidor, rastreador e registrador atual, conforme mostrado no código a seguir:
Pastas de trabalho do Azure e blocos de anotações do Jupyter
As Pastas de Trabalho do Azure e os Blocos de Anotações do Jupyter podem manter os processos de exportação em execução em segundo plano. Para evitar telemetria duplicada, limpe o cache antes de fazer mais chamadas para configure_azure_monitoro .
Passo 4: Certifique-se de que os dados de solicitação do Flask são coletados
Se você implementar um aplicativo Flask, poderá descobrir que não pode coletar dados da tabela de Solicitações do Application Insights enquanto usa a biblioteca de cliente do Azure Monitor OpenTelemetry Distro para Python. Esse problema pode ocorrer se você não estruturar suas import declarações corretamente. Você pode estar importando a estrutura da flask.Flask aplicação Web antes de chamar a configure_azure_monitor função para instrumentar a biblioteca Flask. Por exemplo, o código a seguir não instrumenta com êxito o aplicativo Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
from flask import Flask
configure_azure_monitor()
app = Flask(__name__)
Em vez disso, recomendamos que você importe o módulo como um todo e, em seguida, chame configure_azure_monitor para configurar o OpenTelemetry para usar o flask Azure Monitor antes de acessarflask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
import flask
configure_azure_monitor()
app = flask.Flask(__name__)
Como alternativa, você pode ligar configure_azure_monitor antes de importar flask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor()
from flask import Flask
app = Flask(__name__)
Suporte
Selecione uma guia para o idioma de sua escolha para descobrir opções de suporte.
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.