Configurar o OpenTelemetry do Azure Monitor

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();
  

• Defina uma variável de ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Adicione a seção a seguir ao arquivo de configuração appsettings.json.

    {
      "AzureMonitor": {
          "ConnectionString": "<YOUR-CONNECTION-STRING>"
      }
    }
  

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>";
          })
          .Build();
  
      // 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>";
          })
          .Build();
  
      // 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(logging =>
          {
              logging.AddAzureMonitorLogExporter(options =>
              {
                  options.ConnectionString = "<YOUR-CONNECTION-STRING>";
              });
          });
      });
  

• Defina uma variável de ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

Para definir a cadeia de conexão, consulte a Cadeia de conexão.

Use uma das duas maneiras a seguir para configurar a cadeia de conexão:

• Defina uma variável de ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Defina uma propriedade.

  applicationinsights.connection.string=<YOUR-CONNECTION-STRING>
  

Use uma das duas maneiras a seguir para configurar a cadeia de conexão:

• Defina uma variável de ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Use um objeto de configuração.

  export class BasicConnectionSample {
    static async run() {
      const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
      const options = {
        azureMonitorExporterOptions: {
          connectionString:
            process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
        },
      };
      const monitor = useAzureMonitor(options);
      console.log("Azure Monitor initialized");
    }
  }
  

Use uma das duas maneiras a seguir para configurar a cadeia de conexão:

• Defina uma variável de ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Usando a função configure_azure_monitor.

  # 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>",
  )
  

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(resourceAttributes));

// 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()
    .Build();

// 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()
    .Build();

// 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(logging =>
    {
        // Set ResourceBuilder on the Logging config.
        logging.SetResourceBuilder(resourceBuilder);
        logging.AddAzureMonitorLogExporter();
    });
});

Para definir o nome da função de nuvem, confira nome da função de nuvem.

Para definir a instância de função de nuvem, confira instância de função de nuvem.

Para definir o nome da função de nuvem:

• Use o spring.application.name para aplicações de imagem nativa do Spring Boot.
• Use o quarkus.application.name para aplicativos de imagem nativa 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.

export class CloudRoleSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { resourceFromAttributes } = await import("@opentelemetry/resources");
    const { ATTR_SERVICE_NAME } = await import("@opentelemetry/semantic-conventions");
    const { ATTR_SERVICE_NAMESPACE, ATTR_SERVICE_INSTANCE_ID } =
      await import("@opentelemetry/semantic-conventions/incubating");

    const customResource = resourceFromAttributes({
      [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "my-service",
      [ATTR_SERVICE_NAMESPACE]: process.env.OTEL_SERVICE_NAMESPACE || "my-namespace",
      [ATTR_SERVICE_INSTANCE_ID]: process.env.OTEL_SERVICE_INSTANCE_ID || "my-instance",
    });

    const options = {
      resource: customResource,
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
    };

    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (custom resource)");
  }
}

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 aceita 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:

export OTEL_RESOURCE_ATTRIBUTES="service.namespace=my-namespace,service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"

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:

export OTEL_RESOURCE_ATTRIBUTES="service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"

Amostragem de porcentagem fixa

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
    o.SamplingRatio = 0.1F; // ~10%
});
var app = builder.Build();
app.Run();

Amostragem limitada por taxa

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
    o.TracesPerSecond = 1.5; // ~1.5 traces/sec
});
var app = builder.Build();
app.Run();

Amostragem de porcentagem fixa

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => o.SamplingRatio = 0.1F)
    .Build();

Amostragem limitada por taxa

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => o.TracesPerSecond = 1.5F)
    .Build();

A partir de 3.4.0, a amostragem limitada por taxa é o padrão. Para obter opções de configuração e exemplos, consulte a amostragem de Java.

Para aplicativos nativos do Spring Boot, as configurações de amostragem do SDK do Java OpenTelemetry são aplicáveis.

Para aplicativos nativos do Quarkus, configure a amostragem usando o guia Quarkus OpenTelemetry e, em seguida, use o Exportador do Quarkus OpenTelemetry para enviar telemetria ao Application Insights.

Amostragem de porcentagem fixa

const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
  samplingRatio: 0.1, // ~10%
  azureMonitorExporterOptions: {
    connectionString:
      process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
  },
});

Amostragem limitada por taxa

const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
  tracesPerSecond: 1.5, // ~1.5 traces/sec
  azureMonitorExporterOptions: {
    connectionString:
      process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
  },
});

Amostragem de porcentagem fixa

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    connection_string="<YOUR-CONNECTION-STRING>",
    sampling_ratio=0.1, # 0.1 = 10% of traces sampled
)

Amostragem limitada por taxa

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    connection_string="<YOUR-CONNECTION-STRING>",
    traces_per_second=1.5, # ~1.5 traces/sec
)

builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
    o.EnableTraceBasedLogsSampler = true;
});

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => o.EnableTraceBasedLogsSampler = true)
    .Build();

Para aplicativos Java, a amostragem baseada em rastreamento é habilitada por padrão.

Para aplicativos nativos do Spring Boot e nativos do Quarkus, a amostragem baseada em rastreamento é habilitada por padrão.

const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
  enableTraceBasedSamplingForLogs: true,
  azureMonitorExporterOptions: {
    connectionString:
      process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
  },
});

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    connection_string="<YOUR-CONNECTION-STRING>",
    enable_trace_based_sampling_for_logs=True,
)

Esse recurso está habilitado por padrão.

Os usuários podem desabilitar Live Metrics ao configurar a Distro.

builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
	// Disable the Live Metrics feature.
    options.EnableLiveMetrics = false;
});

Esse recurso não está disponível no Exportador .NET do Azure Monitor.

A experiência Live Metrics está habilitada por padrão.

Para obter mais informações sobre a configuração Java, veja Opções de configuração: Azure Monitor Application Insights para Java.

As métricas ao vivo não estão disponíveis hoje para aplicativos nativos do GraalVM.

Os usuários podem habilitar/desabilitar Live Metrics ao configurar a Distro usando a propriedade enableLiveMetrics.

export class LiveMetricsSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
      enableLiveMetrics: true, // set to false to disable
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (live metrics enabled)");
  }
}

Você pode habilitar métricas ao vivo usando o monitor do Azure OpenTelemetry Distro para Python da seguinte maneira:

...
configure_azure_monitor(
	enable_live_metrics=True
)
...

Para saber mais informações sobre a configuração de autenticação do Microsoft Entra ID, consulte Autenticação do Microsoft Entra para Application Insights

Para saber mais informações sobre a configuração de autenticação do Microsoft Entra ID, consulte Autenticação do Microsoft Entra para Application Insights

Para saber mais informações sobre a configuração de autenticação do Microsoft Entra ID, consulte Autenticação do Microsoft Entra para Application Insights

A autenticação do Microsoft Entra ID não está disponível para aplicativos GraalVM Native.

Para saber mais informações sobre a configuração de autenticação do Microsoft Entra ID, consulte Autenticação do Microsoft Entra para Application Insights

Para saber mais informações sobre a configuração de autenticação do Microsoft Entra ID, consulte Autenticação do Microsoft Entra para Application Insights

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 can't 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 can't be sent to Azure Monitor immediately.
        options.StorageDirectory = "C:\\SomeDirectory";
        })
        .Build();

// 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 can't be sent to Azure Monitor immediately.
        options.StorageDirectory = "C:\\SomeDirectory";
        })
        .Build();

// 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(logging =>
    {
        logging.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 can't be sent to Azure Monitor immediately.
            options.StorageDirectory = "C:\\SomeDirectory";
        });
    });
});

Para desabilitar esse recurso, você deve definir AzureMonitorExporterOptions.DisableOfflineStorage = true.

Quando o agente não pode enviar telemetria para o Azure Monitor, ele armazena arquivos de telemetria em disco. Os arquivos são salvos em uma telemetry pasta no diretório especificado pela propriedade do java.io.tmpdir sistema. Cada nome de arquivo começa com um carimbo de data/hora e termina com a extensão .trn. Esse mecanismo de armazenamento offline ajuda a garantir que a telemetria seja mantida durante interrupções temporárias de rede ou falhas de ingestão.

O agente armazena até 50 MB de dados de telemetria por padrão e permite a configuração do limite de armazenamento. As tentativas de enviar telemetria armazenada são feitas periodicamente. Arquivos de telemetria com mais de 48 horas são excluídos e os eventos mais antigos são descartados quando o limite de armazenamento é atingido.

Para obter uma lista completa das configurações disponíveis, confira Opções de configuração.

Quando o agente não pode enviar telemetria para o Azure Monitor, ele armazena arquivos de telemetria em disco. Os arquivos são salvos em uma telemetry pasta no diretório especificado pela propriedade do java.io.tmpdir sistema. Cada nome de arquivo começa com um carimbo de data/hora e termina com a extensão .trn. Esse mecanismo de armazenamento offline ajuda a garantir que a telemetria seja mantida durante interrupções temporárias de rede ou falhas de ingestão.

O agente armazena até 50 MB de dados de telemetria por padrão. As tentativas de enviar telemetria armazenada são feitas periodicamente. Arquivos de telemetria com mais de 48 horas são excluídos e os eventos mais antigos são descartados quando o limite de armazenamento é atingido.

Por padrão, o AzureMonitorExporter usa um dos seguintes locais para armazenamento offline.

• Windows

  • %TEMP%\Microsoft\AzureMonitor

• Não relacionado ao Windows

  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor

Para substituir o diretório padrão, você deve definir storageDirectory.

Por exemplo:

export class OfflineStorageSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
        storageDirectory: "C:\\\\SomeDirectory",
        disableOfflineStorage: false, // set to true to disable
      },
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (offline storage configured)");
  }
}

Para desabilitar esse recurso, você deve definir disableOfflineStorage = true.

Por padrão, os exportadores do Azure Monitor usam o seguinte caminho:

<tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>

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. Usa False como padrão.

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,
)
...

1. Instale o pacote OpenTelemetry.Exporter.OpenTelemetryProtocol no seu projeto.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. 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();
   

1. Instale o pacote OpenTelemetry.Exporter.OpenTelemetryProtocol no seu projeto.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. 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()
           .Build();
   
       // 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()
           .Build();
   

O Agente Java do Application Insights não dá suporte ao OTLP. Para obter mais informações sobre configurações com suporte, consulte a documentação complementar do Java.

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.

1. Instale o OpenTelemetry Collector Trace Exporter e outros pacotes OpenTelemetry em seu projeto.

   npm install @opentelemetry/api
   npm install @opentelemetry/exporter-trace-otlp-http
   npm install @opentelemetry/sdk-trace-base
   npm install @opentelemetry/sdk-trace-node
   

2. 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.

   export class OtlpExporterSample {
     static async run() {
       const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
       const { BatchSpanProcessor } = await import("@opentelemetry/sdk-trace-base");
       const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");
   
       // Create an OTLP trace exporter (set 'url' if your collector isn't on the default endpoint).
       const otlpExporter = new OTLPTraceExporter({
         // url: "http://localhost:4318/v1/traces",
       });
   
       // Configure Azure Monitor and add the OTLP exporter as an additional span processor.
       const options = {
         azureMonitorExporterOptions: {
           connectionString:
             process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
         },
         spanProcessors: [new BatchSpanProcessor(otlpExporter)],
       };
   
       const monitor = useAzureMonitor(options);
       console.log("Azure Monitor initialized (OTLP exporter added)");
     }
   }
   

1. Instale o pacote opentelemetry-exporter-otlp.

2. 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!")
   

Para obter mais informações sobre o Java, confira a documentação suplementar do Java.

Para aplicativos nativos do Spring Boot, as configurações do SDK do Java OpenTelemetry estão disponíveis.

Para aplicações nativas Quarkus, revise a documentação da Quarkus OpenTelemetry.

Para obter mais informações sobre a configuração do SDK do OpenTelemetry , confira a documentação do OpenTelemetry .

Para obter mais informações sobre a configuração do SDK do OpenTelemetry, consulte a documentação do OpenTelemetry e o Uso do Azure Monitor Distro.

Ao usar o pacote de distribuição Azure.Monitor.OpenTelemetry.AspNetCore, as bibliotecas de instrumentação ASP.NET Core e HttpClient são incluídas. Nosso pacote de distribuição desativa a Redação de Cadeia de Consulta por padrão.

Para alterar esse comportamento, você deve definir uma variável de ambiente como true ou false.

• Instrumentação do ASP.NET Core: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION A redação da cadeia de caracteres de consulta está desabilitada por padrão. Para habilitar, defina essa variável de ambiente como false.

• Instrumentação do cliente HTTP: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION A redação da cadeia de caracteres de consulta está desabilitada por padrão. Para habilitar, defina essa variável de ambiente como false.

Ao usar o Azure.Monitor.OpenTelemetry.Exporter, você deve incluir manualmente as bibliotecas de instrumentação ASP.NET Core ou HttpClient na sua configuração do OpenTelemetry. Essas bibliotecas de instrumentação têm a Redação de QueryString habilitada por padrão.

Para alterar esse comportamento, você deve definir uma variável de ambiente como true ou false.

• Instrumentação do ASP.NET Core: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION A redação da cadeia de caracteres de consulta é habilitada por padrão. Para desabilitar, defina essa variável de ambiente como true.

• Instrumentação do cliente HTTP: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION A redação da cadeia de caracteres de consulta é habilitada por padrão. Para desabilitar, defina essa variável de ambiente como true.

Adicione o seguinte ao arquivo de configuração applicationinsights.json:

{
  "preview": {
    "processors": [
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.query",
            "pattern": "^.*$",
            "replace": "REDACTED",
            "action": "mask"
          }
        ]
      },
      {
        "type": "attribute",
        "actions": [
          {
            "key": "url.full",
            "pattern": "[?].*$",
            "replace": "?REDACTED",
            "action": "mask"
          }
        ]
      }
    ]
  }
}

Estamos trabalhando ativamente na comunidade OpenTelemetry para dar suporte à redação.

Ao usar o pacote de distribuição do OpenTelemetry do Azure Monitor, as cadeias de consulta podem ser editadas por meio da criação e aplicação de um processador de intervalo à configuração da distribuição.

export class RedactQueryStringsSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_URL } =
      await import("@opentelemetry/semantic-conventions");

    class RedactQueryStringProcessor {
      forceFlush() { return Promise.resolve(); }
      onStart() {}
      shutdown() { return Promise.resolve(); }
      onEnd(span: any) {
        const route = String(span.attributes[SEMATTRS_HTTP_ROUTE] ?? "");
        const url = String(span.attributes[SEMATTRS_HTTP_URL] ?? "");
        const target = String(span.attributes[SEMATTRS_HTTP_TARGET] ?? "");

        const strip = (s: string) => {
          const i = s.indexOf("?");
          return i === -1 ? s : s.substring(0, i);
        };

        if (route) span.attributes[SEMATTRS_HTTP_ROUTE] = strip(route);
        if (url) span.attributes[SEMATTRS_HTTP_URL] = strip(url);
        if (target) span.attributes[SEMATTRS_HTTP_TARGET] = strip(target);
      }
    }

    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
      spanProcessors: [new RedactQueryStringProcessor()],
    };

    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (query strings redacted)");
  }
}

Estamos trabalhando ativamente na comunidade OpenTelemetry para dar suporte à redação.