Configurare OpenTelemetry di Monitoraggio di Azure

Adottare uno dei tre modi seguenti per configurare la stringa di connessione:

• Aggiungere UseAzureMonitor() nel program.cs file.

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

• Impostare una variabile di ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Aggiungere la sezione seguente al file di configurazione appsettings.json.

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

Adottare uno dei due modi seguenti per configurare la stringa di connessione:

• All'avvio dell'applicazione, aggiungere l'utilità di esportazione di Monitoraggio di Azure a ogni segnale OpenTelemetry.

      // 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>";
              });
          });
      });
  

• Impostare una variabile di ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

Per impostare la stringa di connessione, vedere Stringa di connessione.

Adottare uno dei due modi seguenti per configurare la stringa di connessione:

• Impostare una variabile di ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Impostare una proprietà.

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

Adottare uno dei due modi seguenti per configurare la stringa di connessione:

• Impostare una variabile di ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Usare un oggetto di configurazione.

  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");
    }
  }
  

Adottare uno dei due modi seguenti per configurare la stringa di connessione:

• Impostare una variabile di ambiente.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
  

• Usare la configure_azure_monitor funzione .

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

Imposta il Cloud Role Name e il Cloud Role Instance tramite gli attributi Resource. Il nome del ruolo cloud usa gli attributi service.namespace e service.name ma, se service.name non è impostato, esegue il fallback a service.namespace. L'istanza del ruolo cloud usa il valore di attributo service.instance.id. Per informazioni sugli attributi standard per le risorse, vedere Convenzioni semantiche 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();

Imposta il Cloud Role Name e il Cloud Role Instance tramite gli attributi Resource. Il nome del ruolo cloud usa gli attributi service.namespace e service.name ma, se service.name non è impostato, esegue il fallback a service.namespace. L'istanza del ruolo cloud usa il valore di attributo service.instance.id. Per informazioni sugli attributi standard per le risorse, vedere Convenzioni semantiche 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();
    });
});

Per impostare il nome del ruolo cloud, vedere Nome del ruolo cloud.

Per impostare l'istanza del ruolo cloud, vedere istanza del ruolo cloud.

Per impostare il nome del ruolo cloud:

• Usare il spring.application.name per le applicazioni di immagini native Spring Boot.
• Usare il quarkus.application.name per le applicazioni di immagini native di Quarkus.

Imposta il Cloud Role Name e il Cloud Role Instance tramite gli attributi Resource. Il nome del ruolo cloud usa gli attributi service.namespace e service.name ma, se service.name non è impostato, esegue il fallback a service.namespace. L'istanza del ruolo cloud usa il valore di attributo service.instance.id. Per informazioni sugli attributi standard per le risorse, vedere Convenzioni semantiche 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)");
  }
}

Imposta il Cloud Role Name e il Cloud Role Instance tramite gli attributi Resource. Il nome del ruolo cloud usa gli attributi service.namespace e service.name ma, se service.name non è impostato, esegue il fallback a service.namespace. L'istanza del ruolo cloud usa il valore di attributo service.instance.id. Per informazioni sugli attributi standard per le risorse, vedere Convenzioni semantiche OpenTelemetry.

Impostare gli attributi di risorsa usando le variabili di ambiente OTEL_RESOURCE_ATTRIBUTES e/o OTEL_SERVICE_NAME. OTEL_RESOURCE_ATTRIBUTES accetta serie di coppie chiave-valore separate da virgole. Per impostare il nome del ruolo cloud su my-namespace.my-helloworld-service e l'istanza del ruolo cloud su my-instance, ad esempio, è possibile impostare OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME come segue:

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

Se l'attributo di risorsa service.namespace non è impostato, è comunque possibile impostare il nome del ruolo cloud solo con la variabile di ambiente OTEL_SERVICE_NAME o con l'attributo di risorsa service.name. Per impostare il nome del ruolo cloud su my-helloworld-service e l'istanza del ruolo cloud su my-instance, ad esempio, è possibile impostare OTEL_RESOURCE_ATTRIBUTES e OTEL_SERVICE_NAME come segue:

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

Campionamento percentuale fisso

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

Campionamento con frequenza limitata

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

Campionamento percentuale fisso

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

Campionamento con frequenza limitata

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

A partire dalla versione 3.4.0, il campionamento con frequenza limitata è l'impostazione predefinita. Per informazioni sulle opzioni di configurazione ed esempi, vedere Campionamento Java.

Per le applicazioni native Spring Boot, sono applicabili le configurazioni di campionamento di OpenTelemetry Java SDK.

Per le applicazioni native Quarkus, configurare il campionamento usando la guida a Quarkus OpenTelemetry e quindi usare Quarkus OpenTelemetry Exporter per inviare dati di telemetria ad Application Insights.

Campionamento percentuale fisso

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

Campionamento con frequenza limitata

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>",
  },
});

Campionamento percentuale fisso

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
)

Campionamento con frequenza limitata

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

Per le applicazioni Java, il campionamento basato su traccia è abilitato per impostazione predefinita.

Per le applicazioni native Spring Boot e Quarkus, il campionamento basato su traccia è abilitato per impostazione predefinita.

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

Questa funzionalità è abilitata per impostazione predefinita.

Gli utenti possono disabilitare le metriche in tempo reale durante la configurazione della distribuzione.

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

Questa funzionalità non è disponibile nell'utilità di esportazione .NET di Monitoraggio di Azure.

L'esperienza offerta dalle metriche in tempo reale è abilitata per impostazione predefinita.

Per ulteriori informazioni sulla configurazione di Java, vedere Opzioni di configurazione: Azure Monitor Application Insights per Java.

Le metriche attive non sono attualmente disponibili per le applicazioni native GraalVM.

Gli utenti possono abilitare/disabilitare le metriche in tempo reale durante la configurazione della distribuzione usando la proprietà 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)");
  }
}

È possibile abilitare le metriche in tempo reale usando la distribuzione OpenTelemetry di Monitoraggio di Azure per Python, come indicato di seguito:

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

Per informazioni sulla configurazione dell'autenticazione di Entra ID, vedere Autenticazione di Microsoft Entra per Application Insights

Per informazioni sulla configurazione dell'autenticazione di Entra ID, vedere Autenticazione di Microsoft Entra per Application Insights

Per informazioni sulla configurazione dell'autenticazione di Entra ID, vedere Autenticazione di Microsoft Entra per Application Insights

L'autenticazione di Microsoft Entra ID non è disponibile per le applicazioni GraalVM Native.

Per informazioni sulla configurazione dell'autenticazione di Entra ID, vedere Autenticazione di Microsoft Entra per Application Insights

Per informazioni sulla configurazione dell'autenticazione di Entra ID, vedere Autenticazione di Microsoft Entra per Application Insights

Il pacchetto di distribuzione include AzureMonitorExporter, che per impostazione predefinita usa uno dei percorsi seguenti per la risorsa di archiviazione offline (elencati in ordine di precedenza):

• Windows

  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor

• Non-Windows

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

Per eseguire l'override della directory predefinita, impostare 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();

Per disabilitare questa funzionalità, impostare AzureMonitorOptions.DisableOfflineStorage = true.

Per impostazione predefinita, AzureMonitorExporter usa uno dei percorsi seguenti per la risorsa di archiviazione offline (elencati in ordine di precedenza):

• Windows

  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor

• Non-Windows

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

Per eseguire l'override della directory predefinita, impostare 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";
        });
    });
});

Per disabilitare questa funzionalità, impostare AzureMonitorExporterOptions.DisableOfflineStorage = true.

Quando l'agente non può inviare dati di telemetria a Monitoraggio di Azure, archivia i file di telemetria su disco. I file vengono salvati in una telemetry cartella nella directory specificata dalla proprietà di java.io.tmpdir sistema. Ogni nome di file inizia con un timestamp e termina con l'estensione .trn . Questo meccanismo di archiviazione offline consente di garantire che i dati di telemetria vengano conservati durante interruzioni temporanee della rete o errori di inserimento.

L'agente archivia fino a 50 MB di dati di telemetria per impostazione predefinita e consente la configurazione del limite di archiviazione. I tentativi di invio di dati di telemetria archiviati vengono eseguiti periodicamente. I file di telemetria precedenti a 48 ore vengono eliminati e gli eventi meno recenti vengono eliminati quando viene raggiunto il limite di archiviazione.

Per un elenco completo delle configurazioni disponibili, vedere Opzioni di configurazione.

Quando l'agente non può inviare dati di telemetria a Monitoraggio di Azure, archivia i file di telemetria su disco. I file vengono salvati in una telemetry cartella nella directory specificata dalla proprietà di java.io.tmpdir sistema. Ogni nome di file inizia con un timestamp e termina con l'estensione .trn . Questo meccanismo di archiviazione offline consente di garantire che i dati di telemetria vengano conservati durante interruzioni temporanee della rete o errori di inserimento.

L'agente archivia fino a 50 MB di dati di telemetria per impostazione predefinita. I tentativi di invio di dati di telemetria archiviati vengono eseguiti periodicamente. I file di telemetria precedenti a 48 ore vengono eliminati e gli eventi meno recenti vengono eliminati quando viene raggiunto il limite di archiviazione.

Per impostazione predefinita, AzureMonitorExporter usa uno dei percorsi seguenti per la risorsa di archiviazione offline.

• Windows

  • %TEMP%\Microsoft\AzureMonitor

• Non-Windows

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

Per eseguire l'override della directory predefinita, impostare storageDirectory.

Ad esempio:

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)");
  }
}

Per disabilitare questa funzionalità, impostare disableOfflineStorage = true.

Per impostazione predefinita, le utilità di esportazione di Monitoraggio di Azure usano il percorso seguente:

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

Per eseguire l'override della directory predefinita, impostare storage_directory sulla directory desiderata.

Ad esempio:

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

Per disabilitare questa funzionalità, impostare disable_offline_storage su True. L'impostazione predefinita è False.

Ad esempio:

...
# 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. Installare il pacchetto OpenTelemetry.Exporter.OpenTelemetryProtocol nel progetto.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Aggiungere il frammento di codice seguente. In questo esempio si presuppone che sia presente un agente di raccolta OpenTelemetry con un ricevitore OTLP in esecuzione. Per informazioni dettagliate, vedere l'esempio in 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. Installare il pacchetto OpenTelemetry.Exporter.OpenTelemetryProtocol nel progetto.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Aggiungere il frammento di codice seguente. In questo esempio si presuppone che sia presente un agente di raccolta OpenTelemetry con un ricevitore OTLP in esecuzione. Per informazioni dettagliate, vedere l'esempio in 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();
   

L'agente Java di Application Insights non supporta OTLP. Per altre informazioni sulle configurazioni supportate, vedere la documentazione supplementare di Java.

Non è possibile abilitare l'utilità di esportazione OTLP (OpenTelemetry Protocol) contestualmente all'utilità di esportazione di Monitoraggio di Azure per salvare i dati di telemetria su due percorsi diversi.

1. Installare OpenTelemetry Collector Trace Exporter e altri pacchetti OpenTelemetry nel progetto.

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

2. Aggiungere il frammento di codice seguente. In questo esempio si presuppone che sia presente un agente di raccolta OpenTelemetry con un ricevitore OTLP in esecuzione. Per informazioni dettagliate, vedere l'esempio in 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. Installare il pacchetto opentelemetry-exporter-otlp .

2. Aggiungere il frammento di codice seguente. In questo esempio si presuppone che sia presente un agente di raccolta OpenTelemetry con un ricevitore OTLP in esecuzione. Per informazioni dettagliate, vedere questo file README.

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

Per altre informazioni su Java, vedere la documentazione supplementare di Java.

Per le applicazioni native Spring Boot, sono disponibili le configurazioni di OpenTelemetry Java SDK .

Per le applicazioni native Quarkus, vedere la documentazione relativa a Quarkus OpenTelemetry.

Per altre informazioni sulla configurazione di OpenTelemetry SDK, vedere la documentazione di OpenTelemetry.

Per ulteriori informazioni sulla configurazione di OpenTelemetry SDK, vedere la documentazione di OpenTelemetry e Azure Monitor Distro Usage.

Quando si usa il pacchetto di distribuzione Azure.Monitor.OpenTelemetry.AspNetCore , sono incluse entrambe le librerie di strumentazione Core e HttpClient ASP.NET. Il pacchetto di distribuzione disattiva la redazione delle stringhe di query per impostazione predefinita.

Per modificare questo comportamento, è necessario impostare una variabile di ambiente su true o false.

• Strumentazione ASP.NET Core: la redazione delle stringhe di query OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION è disabilitata per impostazione predefinita. Per abilitarla, impostare questa variabile di ambiente su false.

• Strumentazione client HTTP: la redazione delle stringhe di query OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION è disabilitata per impostazione predefinita. Per abilitarla, impostare questa variabile di ambiente su false.

Quando si usa Azure.Monitor.OpenTelemetry.Exporter, è necessario includere manualmente le librerie ASP.NET Core o HttpClient Instrumentation nella configurazione openTelemetry. L'opzione di redazione QueryString è abilitata per impostazione predefinita in queste librerie di strumentazione.

Per modificare questo comportamento, è necessario impostare una variabile di ambiente su true o false.

• Strumentazione ASP.NET Core: la redazione delle stringhe di query OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION è abilitata per impostazione predefinita. Per disabilitarla, impostare questa variabile di ambiente su true.

• Strumentazione client HTTP: la redazione delle stringhe di query OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION è abilitata per impostazione predefinita. Per disabilitarla, impostare questa variabile di ambiente su true.

Aggiungere quanto segue al file di configurazione 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"
          }
        ]
      }
    ]
  }
}

Stiamo lavorando attivamente nella community OpenTelemetry per supportare la redazione.

Quando si usa il pacchetto di distribuzione OpenTelemetry di Monitoraggio di Azure, è possibile redigere stringhe di query tramite la creazione e l'applicazione di un processore span alla configurazione della distribuzione.

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)");
  }
}

Stiamo lavorando attivamente nella community OpenTelemetry per supportare la redazione.