Use uma das três maneiras a seguir para configurar a cadeia de conexão:
Adicione UseAzureMonitor() ao arquivo program.cs:
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>";
});
var app = builder.Build();
app.Run();
Se você definir a cadeia de conexão em mais de um local, seguiremos 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 do 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 com suporte, a distribuição OpenTelemetry do Azure Monitor detecta automaticamente o contexto do recurso e fornece valores padrão para o Nome da função de nuvem e as propriedades da Instância da função de nuvem do componente. No entanto, talvez você queira substituir os valores padrão para algo que faça sentido para a 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 de atributos de Recurso. O Nome da Função de Nuvem usa os atributos service.namespace e service.name, embora ele volte para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do atributo service.instance.id. Para obter informações sobre atributos padrão para recursos, confira Convenções semânticas do 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 de atributos de Recurso. O Nome da Função de Nuvem usa os atributos service.namespace e service.name, embora ele volte para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do atributo service.instance.id. Para obter informações sobre atributos padrão para recursos, confira Convenções semânticas do 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();
});
});
Use o spring.application.name para aplicativos de imagem nativos do Spring Boot
Use o quarkus.application.name para aplicativos de imagem nativos do Quarkus
Defina o Nome da Função de Nuvem e a Instância de Função de Nuvem por meio de atributos de Recurso. O Nome da Função de Nuvem usa os atributos service.namespace e service.name, embora ele volte para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do atributo service.instance.id. Para obter informações sobre atributos padrão para recursos, confira Convenções semânticas do 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 de atributos de Recurso. O Nome da Função de Nuvem usa os atributos service.namespace e service.name, embora ele volte para service.name se service.namespace não estiver definido. A Instância de Função de Nuvem usa o valor do atributo service.instance.id. Para obter informações sobre atributos padrão para recursos, confira Convenções semânticas do OpenTelemetry.
Defina os atributos do Recursos usando as variáveis de ambiente OTEL_RESOURCE_ATTRIBUTES e/ou OTEL_SERVICE_NAME. OTEL_RESOURCE_ATTRIBUTES pega uma série de pares de chave-valor separados por vírgula. Por exemplo, para definir o Nome da Função de Nuvem como my-namespace.my-helloworld-service e definir a Instância de Função de Nuvem como my-instance, você pode definir OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME da seguinte maneira:
Se você não definir o atributo de Recurso service.namespace, poderá definir o Nome da Função de Nuvem apenas com a variável de ambiente OTEL_SERVICE_NAME ou com o Atributo de Recurso service.name. Por exemplo, para definir o Nome da Função de Nuvem como my-helloworld-service e definir a Instância de Função de Nuvem como my-instance, você pode definir OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME da seguinte maneira:
Talvez você queira habilitar a amostragem para reduzir o volume de ingestão de dados, o que reduz o custo. O Azure Monitor fornece uma amostra de taxa fixa personalizada que preenche eventos com uma "taxa de amostragem" e o Application Insights a converte em ItemCount. A amostra de taxa fixa garante contagens precisas de experiências e eventos. O amostrador foi projetado para preservar seus rastreamentos entre serviços e é interoperável com kits de desenvolvimento de software (SDKs) mais antigos do Application Insights. Para obter mais informações, confira Saiba mais sobre amostragem.
A amostra espera uma taxa de amostra entre 0 e 1 inclusiva. Uma taxa de 0,1 significa que aproximadamente 10% dos seus rastreamentos foram 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();
A amostra espera uma taxa de amostra entre 0 e 1 inclusiva. Uma taxa de 0,1 significa que aproximadamente 10% dos seus rastreamentos foram 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 3.4.0, a amostragem limitada por taxa está disponível e agora é o padrão. Para obter mais informações sobre amostragem, confira amostragem do Java.
A amostra espera uma taxa de amostra entre 0 e 1 inclusiva. Uma taxa de 0,1 significa que aproximadamente 10% dos seus rastreamentos foram 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 função configure_azure_monitor() utiliza automaticamente o ApplicationInsightsSampler para compatibilidade com os SDKs do Application Insights e para amostras da sua telemetria. A variável de ambiente OTEL_TRACES_SAMPLER_ARG 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% de seus rastreamentos foram enviados.
export OTEL_TRACES_SAMPLER_ARG=0.1
Dica
Ao usar a amostragem de taxa fixa/porcentagem e você não tiver certeza de como definir a taxa de amostragem, comece em 5% (ou seja, taxa 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. Geralmente, uma taxa mais alta resulta em precisão maior. No entanto, TODA amostragem afetará a precisão, sendo assim, é recomendável alertar sobre as Métricas do OpenTelemetry, que não são afetadas pela amostragem.
Live Metrics
Métricas ao vivo 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 (antigo Azure AD)
Talvez você queira habilitar a autenticação do Microsoft Entra para ter uma conexão mais segura com o Azure, o que impede que dados telemétricos não autorizados sejam ingeridos 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();
Oferecemos suporte às classes de credenciais fornecidas pelo Azure Identity.
Recomendamos DefaultAzureCredential para o desenvolvimento local.
ManagedIdentityCredential é recomendado para identidades gerenciadas atribuídas pelo usuário e atribuídas pelo sistema.
Para atribuído pelo sistema, use o construtor padrão sem parâmetros.
Para atribuído pelo usuário, 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;
});
});
});
A autenticação do Microsoft Entra ID não está disponível para aplicativos nativos do GraalVM.
Oferecemos suporte às classes de credenciais fornecidas pelo Azure Identity.
// 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: {
connectionString:
process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
credential: credential
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
A Distribuição OpenTelemetry do Azure Monitor para Python dá suporte às classes de credencial fornecidas pela Identidade do Azure.
Recomendamos DefaultAzureCredential para o desenvolvimento local.
ManagedIdentityCredential é recomendado para identidades gerenciadas atribuídas pelo usuário e atribuídas pelo sistema.
Para atribuído pelo sistema, use o construtor padrão sem parâmetros.
Para o usuário atribuído, forneça o client_id ao 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.
Se estiver usando ManagedIdentityCredential
# 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
from opentelemetry import trace
# Configure the Distro to authenticate with Azure Monitor using a managed identity credential.
credential = ManagedIdentityCredential(client_id="<client_id>")
configure_azure_monitor(
connection_string="your-connection-string",
credential=credential,
)
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("hello with aad managed identity"):
print("Hello, World!")
Se estiver usando ClientSecretCredential
# Import the `ClientSecretCredential` class from the `azure.identity` package.
from azure.identity import ClientSecretCredential
# Import the `configure_azure_monitor()` function from the `azure.monitor.opentelemetry` package.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace
# Configure the Distro to authenticate with Azure Monitor using a client secret credential.
credential = ClientSecretCredential(
tenant_id="<tenant_id",
client_id="<client_id>",
client_secret="<client_secret>",
)
configure_azure_monitor(
connection_string="your-connection-string",
credential=credential,
)
with tracer.start_as_current_span("hello with aad client secret identity"):
print("Hello, World!")
Armazenamento offline e novas tentativas automáticas
Para melhorar a confiabilidade e a resiliência, as ofertas baseadas em OpenTelemetry do Azure Monitor são gravadas 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 tenta enviá-la outra vez periodicamente por até 48 horas. Em aplicações de alta carga, a telemetria é ocasionalmente descartada por dois motivos. Primeiro, quando o tempo permitido for excedido e, segundo, quando o tamanho máximo do arquivo for excedido ou o SDK não tiver a oportunidade de limpar o arquivo. Se precisarmos escolher, o produto salva os eventos mais recentes em relação aos antigos. Saiba mais
O pacote Distro inclui o AzureMonitorExporter que, por padrão, 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 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 desabilitar 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 desabilitar esse recurso, você deve definir AzureMonitorExporterOptions.DisableOfflineStorage = true.
A configuração do Armazenamento Offline e das Repetições Automáticas não está disponível no Java.
Para obter uma lista completa das configurações disponíveis, confira 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 do 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 desabilitar 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 como 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 desabilitar esse recurso, você deve definir disable_offline_storage como True. Assume o padrão de 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 do protocolo OpenTelemetry (OTLP) junto com o exportador do Azure Monitor para enviar os seus dados telemétricos para dois locais.
Observação
O Exportador OTLP é mostrado apenas para fins de conveniência. Nós não damos suporte oficialmente ao Exportador OTLP nem a qualquer componente ou experiência de terceiros downstream.
Adicione o trecho de código a seguir. Este exemplo pressupõe que você tenha um coletor de OpenTelemetry com um receptor OTLP em execução. Para obter detalhes, confira o exemplo do 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 trecho de código a seguir. Este exemplo pressupõe que você tenha um coletor de OpenTelemetry com um receptor OTLP em execução. Para obter detalhes, confira o exemplo do 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();
Você não pode habilitar o Exportador do Protocolo OpenTelemetry (OTLP) ao lado do Exportador do Azure Monitor para enviar dados telemétricos para dois locais.
Adicione o trecho de código a seguir. Este exemplo pressupõe que você tenha um coletor de OpenTelemetry com um receptor OTLP em execução. Para obter detalhes, confira o exemplo do 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 trecho de código a seguir. Este exemplo pressupõe que você tenha um coletor de OpenTelemetry com um receptor OTLP em execução. Para obter detalhes, confira este LEIAME.
# 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 do OpenTelemetry
As seguintes configurações do OpenTelemetry podem ser acessadas por meio de variáveis de ambiente ao usar as Distros do OpenTelemetry do Azure Monitor.
Defina isso como a cadeia de conexão do seu recurso do Application Insights.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED
Defina como true para recusar a coleta de métricas internas.
OTEL_RESOURCE_ATTRIBUTES
Pares de chave-valor usados como atributos de recursos. Para obter mais informações sobre atributos de recurso, consulte a especificação do SDK de Recurso.
OTEL_SERVICE_NAME
Defina o valor do atributo de recurso service.name. Se service.name também for fornecido em OTEL_RESOURCE_ATTRIBUTES, então OTEL_SERVICE_NAME terá precedência.
Variável de ambiente
Descrição
APPLICATIONINSIGHTS_CONNECTION_STRING
Defina isso como a cadeia de conexão do seu recurso do Application Insights.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED
Defina como true para recusar a coleta de métricas internas.
OTEL_RESOURCE_ATTRIBUTES
Pares de chave-valor usados como atributos de recursos. Para obter mais informações sobre atributos de recurso, consulte a especificação do SDK de Recurso.
OTEL_SERVICE_NAME
Defina o valor do atributo de recurso service.name. Se service.name também for fornecido em OTEL_RESOURCE_ATTRIBUTES, então OTEL_SERVICE_NAME terá precedência.
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á investindo no OpenTelemetry pelos seguintes motivos:
É neutro em relação a fornecedores e fornece APIs/SDKs consistentes entre diferentes 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 expande os tipos de dados que podem ser coletados por meio de um conjunto avançado de bibliotecas de instrumentação.
Os Kits de Desenvolvimento de Software (SDKs) do OpenTelemetry tendem a ser mais eficientes em grande escala do que seus predecessores, os SDKs do Application Insights.
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:
Reduz o esforço da habilitação
Compatível com a Microsoft
Inclui recursos específicos do Azure, como:
Amostragem compatível com os SDKs clássicos do Application Insights
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?
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 de .NET, incluindo ASP.NET clássico, aplicativos de console, Windows Forms (WinForms) etc., recomendamos o uso do exportador OpenTelemetry do Azure Monitor para .NET: Azure.Monitor.OpenTelemetry.Exporter.
❌ Esse recurso não está disponível ou não é aplicável.
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?
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?
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.
No Grafana, por que estou vendo Status: 500. Can't visualize trace events using the trace visualizer?
Você pode estar tentando visualizar logs de texto bruto em vez de rastreamentos do OpenTelemetry.
No Application Insights, a tabela "Traces" 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 "Traces" não contribui diretamente para a visualização da 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 e na terminologia de telemetria. OpenTelemetry tornou-se um padrão para coleta e instrumentação de dados de telemetria. Nesse contexto, o termo "Traços" ganhou um novo significado. Em vez de logs brutos, 'Traces' no OpenTelemetry referem-se a uma forma de telemetria mais rica e estruturada que inclui spans, que representam unidades individuais de trabalho. Esses intervalos são cruciais para a construção de visualizações detalhadas de transações, permitindo 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 aceitando a origem chamada OpenTelemetry-AzureMonitor-Exporter. Para obter 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
Os 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 servidor Web ou do computador host do 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 Application Insights do Azure Monitor.
Problemas conhecidos
Os seguintes itens são problemas conhecidos para os exportadores do 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 do 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 aceitando a origem chamada OpenTelemetry-AzureMonitor-Exporter. Para obter 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
Os 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 servidor Web ou do computador host do 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 Application Insights do Azure Monitor.
Problemas conhecidos
Os seguintes itens são problemas conhecidos para os exportadores do 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 do 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
Os 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 servidor Web ou do computador host do 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 Application Insights do Azure Monitor.
Problemas conhecidos
Se você baixar a biblioteca de clientes do Application Insights para instalação de um navegador, às vezes o arquivo JAR baixado está corrompido e tem cerca de metade do tamanho do arquivo de origem. Se você tiver esse problema, baixe o arquivo JAR executando o comando curl ou wget, conforme mostrado nas chamadas de comando de exemplo a seguir:
As chamadas de comando de exemplo se aplicam ao Application Insights para Java versão 3.4.11. Para encontrar o número da versão e o endereço de URL da versão atual do Application Insights para 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 observar 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 Spring Boot starter.
Etapa 2: Ativar o autodiagnóstico
Se algo não funcionar conforme o esperado, você poderá habilitar o autodiagnóstico no nível DEBUG para obter alguns insights. Para fazer isso, defina o nível de autodiagnóstico como ERROR, WARN, INFO, DEBUG ou TRACE usando a variável de ambiente APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL.
Para habilitar o autodiagnóstico no nível DEBUG ao executar um contêiner do docker, execute o seguinte comando:
docker run -e APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL=DEBUG <image-name>
Observação
Substitua <image-name> pelo nome da imagem do docker de acordo.
Aviso de isenção de responsabilidade para informações de terceiros
Os produtos de terceiros mencionados neste artigo são produzidos por empresas independentes da Microsoft. A Microsoft não oferece nenhuma garantia, implícita ou não, do desempenho ou da confiabilidade desses produtos.
Etapa 1: Habilitar o log de diagnóstico
O Exportador do Azure Monitor usa o agente da API OpenTelemetry para logs internos. Para habilitar o agente, execute o seguinte snippet de código:
Etapa 2: Testar a conectividade entre o host do aplicativo e o serviço de ingestão
Os 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 servidor Web ou do computador host do 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 Application Insights do Azure Monitor.
Problemas conhecidos
Os seguintes itens são problemas conhecidos para os exportadores do 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 do 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 do OpenTelemetry agregam incorretamente tabelas que têm o mesmo nome em servidores diferentes.
Etapa 1: Habilitar o log de diagnóstico
O Exportador do Microsoft Azure Monitor usa a biblioteca de log padrão do Python para seu log interno. Os logs da API do OpenTelemetry e do Exportador do Azure Monitor recebem um nível de gravidade de WARNING ou ERROR para atividades irregulares. O nível de gravidade INFO é usado para atividades regulares ou bem-sucedidas.
Por padrão, a biblioteca de log do Python define o nível de gravidade como WARNING. Portanto, você deve alterar o nível de gravidade para ver os logs nessa configuração de gravidade. O código de exemplo a seguir mostra como gerar 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
Os 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 servidor Web ou do computador host do 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 Application Insights do Azure Monitor.
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 por 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.
Logs de rastreamento duplicados 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 instrumentação de log azure-monitor-opentelemetry dentro da distribuição
Para evitar a 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 variável de ambiente OTEL_LOGS_EXPORTER como None.
Telemetria duplicada no Azure Functions "Always On"
Se a configuração Always On no Azure Functions estiver definida como On, 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ê poderá 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 Off ou tente desligar manualmente os provedores entre cada chamada configure_azure_monitor. Para desligar cada provedor, execute chamadas de desligamento para cada provedor de medidor, rastreador e agente atual, conforme mostrado no código a seguir:
As pastas de trabalho do Azure e os Jupyter Notebooks podem manter os processos do exportador em execução em segundo plano. Para evitar telemetria duplicada, limpe o cache antes de fazer mais chamadas para configure_azure_monitor.
Etapa 4: Verificar se os dados de solicitação do Flask foram coletados
Se você implementar um aplicativo Flask, poderá descobrir que não pode coletar dados da tabela Requests do Application Insights enquanto usa a biblioteca de clientes Azure Monitor OpenTelemetry Distro para Python. Esse problema pode ocorrer se você não estruturar suas declarações de import corretamente. Você pode estar importando a estrutura do aplicativo Web flask.Flask antes de chamar a função configure_azure_monitor para instrumentar a biblioteca do 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 flask como um todo e, em seguida, chame configure_azure_monitor para configurar o OpenTelemetry para usar o Azure Monitor antes de acessar flask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
import flask
configure_azure_monitor()
app = flask.Flask(__name__)
Como alternativa, você pode chamar 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 as opções de suporte.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.