Configurer OpenTelemetry pour Azure Monitor

Cet article décrit les paramètres de configuration de la distribution Azure Monitor OpenTelemetry.

Chaîne de connexion

Dans Application Insights, une chaîne de connexion définit l’emplacement cible pour l’envoi de données de télémétrie, ce qui permet de s’assurer qu’elles atteignent la ressource appropriée pour la surveillance et l’analyse.

ASP.NET Core

Utilisez l’une des trois méthodes suivantes pour configurer la chaîne de connexion :

• Ajoutez UseAzureMonitor() au démarrage de votre application, dans votre classe program.cs.

  // Create a new ASP.NET Core web application builder.    
  var builder = WebApplication.CreateBuilder(args);
  
  // Add the OpenTelemetry telemetry service to the application.
  // This service will collect and send telemetry data to Azure Monitor.
  builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
      options.ConnectionString = "<Your Connection String>";
  });
  
  // Build the ASP.NET Core web application.
  var app = builder.Build();
  
  // Start the ASP.NET Core web application.    
  app.Run();
  

• Définissez une variable d’environnement.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Ajoutez la section suivante au fichier config appsettings.json.

  {
    "AzureMonitor": {
        "ConnectionString": "<Your Connection String>"
    }
  }
  

Remarque

Si vous définissez la chaîne de connexion à plusieurs emplacements, nous respectons la précédence suivante :

1. Code
2. Variable d’environnement
3. Fichier de configuration

.NET

Utilisez l’une des deux méthodes suivantes pour configurer la chaîne de connexion :

• Ajoutez l’exportateur Azure Monitor à chaque signal OpenTelemetry au démarrage de l’application.

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

• Définissez une variable d’environnement.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

Remarque

Si vous définissez la chaîne de connexion à plusieurs emplacements, nous respectons la précédence suivante :

1. Code
2. Variable d’environnement

Java

Pour définir la chaîne de connexion, consultez Chaîne de connexion.

Node.JS

Utilisez l’une des deux méthodes suivantes pour configurer la chaîne de connexion :

• Définissez une variable d’environnement.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Utilisez l’objet de configuration.

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

Python

Utilisez l’une des deux méthodes suivantes pour configurer la chaîne de connexion :

• Définissez une variable d’environnement.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Utiliser la fonction 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>",
)

Définir le nom du rôle cloud et l’instance de rôle cloud

Pour les langues prises en charge, Azure Monitor OpenTelemetry Distro détecte automatiquement le contexte de ressource et fournit des valeurs par défaut pour les propriétés Nom de rôle cloud et Instance de rôle cloud de votre composant. Toutefois, vous pouvez remplacer les valeurs par défaut par un élément logique pour votre équipe. La valeur du nom du rôle cloud s’affiche sur la cartographie d’applications en tant que nom sous un nœud.

ASP.NET Core

Définissez le nom du rôle cloud et l’instance de rôle cloud via les attributs Ressource. Le nom du rôle cloud utilise les attributs service.namespace et service.name, mais il retourne à la valeur service.name si service.namespace n’est pas défini. L’instance de rôle cloud utilise la valeur d’attribut service.instance.id. Pour plus d’informations sur les attributs standard pour les ressources, consultez Conventions sémantiques 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 OpenTelemetry tracer provider to add the resource attributes to all traces.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => 
    builder.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();

.NET

Définissez le nom du rôle cloud et l’instance de rôle cloud via les attributs Ressource. Le nom du rôle cloud utilise les attributs service.namespace et service.name, mais il retourne à la valeur service.name si service.namespace n’est pas défini. L’instance de rôle cloud utilise la valeur d’attribut service.instance.id. Pour plus d’informations sur les attributs standard pour les ressources, consultez Conventions sémantiques 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();
    });
});

Java

Pour définir le nom du rôle cloud, consultez Nom du rôle cloud.

Pour définir l’instance de rôle cloud, consultez Instance de rôle cloud.

Node.JS

Définissez le nom du rôle cloud et l’instance de rôle cloud via les attributs Ressource. Le nom du rôle cloud utilise les attributs service.namespace et service.name, mais il retourne à la valeur service.name si service.namespace n’est pas défini. L’instance de rôle cloud utilise la valeur d’attribut service.instance.id. Pour plus d’informations sur les attributs standard pour les ressources, consultez Conventions sémantiques 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);

Python

Définissez le nom du rôle cloud et l’instance de rôle cloud via les attributs Ressource. Le nom du rôle cloud utilise les attributs service.namespace et service.name, mais il retourne à la valeur service.name si service.namespace n’est pas défini. L’instance de rôle cloud utilise la valeur d’attribut service.instance.id. Pour plus d’informations sur les attributs standard pour les ressources, consultez Conventions sémantiques OpenTelemetry.

Définissez les attributs des ressources à l’aide des variables d’environnement OTEL_RESOURCE_ATTRIBUTES et/ou OTEL_SERVICE_NAME. OTEL_RESOURCE_ATTRIBUTES prend des séries de paires clé-valeur séparées par des virgules. Par exemple, pour définir le nom du rôle cloud sur my-namespace.my-helloworld-service et définir l’instance de rôle cloud sur my-instance, vous pouvez définir OTEL_RESOURCE_ATTRIBUTES et OTEL_SERVICE_NAME comme suit :

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

Si vous ne définissez pas l’attribut de la ressource service.namespace, vous pouvez également définir le nom du rôle cloud avec uniquement la variable d’environnement OTEL_SERVICE_NAME ou l’attribut de la ressource service.name. Par exemple, pour définir le nom du rôle cloud sur my-helloworld-service et définir l’instance de rôle cloud sur my-instance, vous pouvez définir OTEL_RESOURCE_ATTRIBUTES et OTEL_SERVICE_NAME comme suit :

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

Activer l’échantillonnage

Vous pouvez activer l’échantillonnage pour réduire votre volume d’ingestion de données, ce qui réduit vos coûts. Azure Monitor fournit un échantillonneur à taux fixe personnalisé qui remplit les événements avec un « ratio d’échantillonnage » qu’Application Insights convertit en ItemCount. L’échantillonneur à taux fixe garantit des expériences et des comptes d’événements précis. L’échantillonneur est conçu pour préserver vos traces entre les services, et il est interopérable avec des Kits de développement logiciel (SDK) Application Insights plus anciens. Pour plus d’informations, consultez En savoir plus sur l’échantillonnage.

Notes

Les métriques et journaux ne sont pas affectés par l’échantillonnage.

ASP.NET Core

L’échantillonneur s’attend à un taux d’échantillonnage compris entre 0 et 1 inclus. Un taux de 0,1 signifie qu’environ 10 % de vos traces sont envoyées.

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

.NET

L’échantillonneur s’attend à un taux d’échantillonnage compris entre 0 et 1 inclus. Un taux de 0,1 signifie qu’environ 10 % de vos traces sont envoyées.

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

Java

À partir de la version 3.4.0, l’échantillonnage à fréquence limitée est disponible et constitue désormais le réglage par défaut. Pour plus d’informations sur l’échantillonnage, consultez Échantillonnage de Java.

Node.JS

L’échantillonneur s’attend à un taux d’échantillonnage compris entre 0 et 1 inclus. Un taux de 0,1 signifie qu’environ 10 % de vos traces sont envoyées.

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

Python

La fonction configure_azure_monitor() utilise automatiquement ApplicationInsightsSampler pour assurer la compatibilité avec les kits de développement logiciel (SDK) Application Insights et pour échantillonner vos données de télémétrie. La variable d’environnement OTEL_TRACES_SAMPLER_ARG peut servir à spécifier le taux d’échantillonnage, avec une plage valide de 0 à 1, dans laquelle 0 est 0 % et 1 est 100 %. Une valeur de 0,1 signifie par exemple que 10 % de vos traces sont envoyées.

export OTEL_TRACES_SAMPLER_ARG=0.1

Conseil

Lorsque vous utilisez un échantillonnage à taux/pourcentage fixe et que vous ne savez pas quelle valeur donner au taux d’échantillonnage, commencez à 5 % (c’est-à-dire 0,05 du taux d’échantillonnage) et ajustez le taux en fonction de la précision des opérations affichées dans les panneaux d’échecs et de performances.When using fixed-rate/percentage sampling and you aren't sure what to set the sampling rate as, Un taux plus élevé entraîne généralement une plus grande précision. Toutefois, l’échantillonnage ANY affecte la précision. Nous vous recommandons donc de générer des alertes sur les métriques OpenTelemetry, lesquelles ne sont pas affectées par l’échantillonnage.

Activer l’authentification Microsoft Entra ID (anciennement Azure AD)

Vous pouvez activer l’authentification Microsoft Entra pour une connexion plus sécurisée à Azure, ce qui empêche l’ingestion de données de télémétrie non autorisées dans votre abonnement.

ASP.NET Core

Nous prenons en charge les classes d’informations d’identification fournies par Identité Azure.

• Nous vous recommandons DefaultAzureCredential pour le développement local.
• Nous vous recommandons ManagedIdentityCredential pour les identités managées attribuées par le système et par l'utilisateur.
  • Pour l’affectation par le système, utilisez le constructeur par défaut sans paramètres.
  • Pour la valeur assignée à l’utilisateur, fournissez l’ID client au constructeur.
• Nous vous recommandons ClientSecretCredential pour les principaux de service.
  • Indiquez l’ID de locataire, l’ID client et la clé secrète client au constructeur.

1. Installez le dernier package Azure.Identity :

   dotnet add package Azure.Identity
   

2. Fournissez la classe d’informations d’identification souhaitée :

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

.NET

Nous prenons en charge les classes d’informations d’identification fournies par Identité Azure.

• Nous vous recommandons DefaultAzureCredential pour le développement local.
• Nous vous recommandons ManagedIdentityCredential pour les identités managées attribuées par le système et par l'utilisateur.
  • Pour l’affectation par le système, utilisez le constructeur par défaut sans paramètres.
  • Pour la valeur assignée à l’utilisateur, fournissez l’ID client au constructeur.
• Nous vous recommandons ClientSecretCredential pour les principaux de service.
  • Indiquez l’ID de locataire, l’ID client et la clé secrète client au constructeur.

1. Installez le dernier package Azure.Identity :

   dotnet add package Azure.Identity
   

2. Fournissez la classe d’informations d’identification souhaitée :

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

Java

Pour plus d’informations sur Java, consultez la documentation supplémentaire relative à Java.

Node.JS

Nous prenons en charge les classes d’informations d’identification fournies par Identité Azure.

// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, and the ManagedIdentityCredential class from the @azure/monitor-opentelemetry and @azure/identity packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { ManagedIdentityCredential } = require("@azure/identity");

// Create a new ManagedIdentityCredential object.
const credential = new ManagedIdentityCredential();

// Create a new AzureMonitorOpenTelemetryOptions object and set the credential property to the credential object.
const options: AzureMonitorOpenTelemetryOptions = {
    azureMonitorExporterOptions: {
        credential: credential
    }
};

// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);

Python

# Import the `ManagedIdentityCredential` class from the `azure.identity` package.
from azure.identity import ManagedIdentityCredential
# Import the `configure_azure_monitor()` function from the `azure.monitor.opentelemetry` package.
from azure.monitor.opentelemetry import configure_azure_monitor

# Configure OpenTelemetry to use Azure Monitor with a managed identity credential.
# This will allow OpenTelemetry to authenticate to Azure Monitor without requiring you to provide a connection string.
configure_azure_monitor(
    credential=ManagedIdentityCredential(),
)

Stockage hors connexion et nouvelles tentatives automatiques

Pour améliorer la fiabilité et la résilience, les offres Azure Monitor basées sur OpenTelemetry écrivent dans un stockage hors connexion/local par défaut lorsqu’une application perd sa connexion avec Application Insights. Il enregistre la télémétrie de l’application pendant 48 heures et tente régulièrement de l’envoyer à nouveau. Dans les applications à charge élevée, la télémétrie est parfois supprimée pour deux raisons. Tout d’abord, lorsque la durée autorisée est dépassée, et ensuite, lorsque la taille maximale du fichier est dépassée ou que le kit de développement logiciel (SDK) n’a pas la possibilité d’effacer le fichier. Si nous devons choisir, le produit enregistre les événements les plus récents sur les anciens. En savoir plus

ASP.NET Core

Le package Distro inclus AzureMonitorExporter qui utilise l’un des emplacements suivants par défaut pour le stockage hors connexion (répertorié dans l’ordre de priorité) :

• Windows
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Non-Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

Pour remplacer le répertoire par défaut, vous devez définir 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();

Pour désactiver cette fonctionnalité, vous devez définir AzureMonitorOptions.DisableOfflineStorage = true.

.NET

Par défaut, AzureMonitorExporter utilise l’un des emplacements suivants pour le stockage hors connexion (répertorié dans l’ordre de priorité) :

• Windows
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Non-Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

Pour remplacer le répertoire par défaut, vous devez définir 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";
        });
    });
});

Pour désactiver cette fonctionnalité, vous devez définir AzureMonitorExporterOptions.DisableOfflineStorage = true.

Java

La configuration du stockage hors connexion et des nouvelles tentatives automatiques n’est pas disponible dans Java.

Pour obtenir la liste complète des configurations disponibles, consultez Options de configuration.

Node.JS

Par défaut, AzureMonitorExporter utilise l’un des emplacements suivants pour le stockage hors connexion.

• Windows
  • %TEMP%\Microsoft\AzureMonitor
• Non-Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor

Pour remplacer le répertoire par défaut, vous devez définir storageDirectory.

Par exemple :

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

Pour désactiver cette fonctionnalité, vous devez définir disableOfflineStorage = true.

Python

Par défaut, les exportateurs Azure Monitor utilisent le chemin d’accès suivant :

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

Pour remplacer le répertoire par défaut, vous devez définir storage_directory sur le répertoire souhaité.

Par exemple :

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

Pour désactiver cette fonctionnalité, vous devez définir disable_offline_storage sur True. La valeur par défaut est False.

Par exemple :

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

Activer l’exportateur OTLP

Vous pouvez activer OpenTelemetry Protocol (OTLP) Exporter en plus du Azure Monitor Exporter pour envoyer vos données de télémétrie à deux emplacements.

Notes

OTLP Exporter est illustré pour des raisons pratiques uniquement. Nous ne prenons pas officiellement en charge OTLP Exporter ni les composants ou les expériences tierces qui en découlent.

ASP.NET Core

1. Installez le package OpenTelemetry.Exporter.OpenTelemetryProtocol dans votre projet.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Ajoutez l’extrait de code suivant : Cet exemple suppose que vous disposez d’un OpenTelemetry Collector avec un récepteur OTLP en cours d’exécution. Pour plus d’informations, consultez l' exemple relatif à 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();
   

.NET

1. Installez le package OpenTelemetry.Exporter.OpenTelemetryProtocol dans votre projet.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Ajoutez l’extrait de code suivant : Cet exemple suppose que vous disposez d’un OpenTelemetry Collector avec un récepteur OTLP en cours d’exécution. Pour plus d’informations, consultez l' exemple relatif à 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();
   

Java

Pour plus d’informations sur Java, consultez la documentation supplémentaire relative à Java.

Node.JS

1. Installez Exportateur de traces du collecteur OpenTelemetry et d’autres packages OpenTelemetry dans votre projet.

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

2. Ajoutez l’extrait de code suivant : Cet exemple suppose que vous disposez d’un OpenTelemetry Collector avec un récepteur OTLP en cours d’exécution. Pour plus d’informations, consultez l' exemple relatif à 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);
   

Python

1. Installez le package opentelemetry-exporter-otlp.

2. Ajoutez l’extrait de code suivant : Cet exemple suppose que vous disposez d’un OpenTelemetry Collector avec un récepteur OTLP en cours d’exécution. Pour plus d’informations, consultez ce fichier Lisez-moi.

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

Configurations OpenTelemetry

Les configurations OpenTelemetry suivantes sont accessibles via des variables d’environnement lors de l’utilisation des distributions Azure Monitor OpenTelemetry.

ASP.NET Core

Variable d’environnement	Description
APPLICATIONINSIGHTS_CONNECTION_STRING	Copiez-le dans la chaîne de connexion à partir de votre ressource Application Insights.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED	Définissez-le sur true pour refuser la collecte de métriques interne.
OTEL_RESOURCE_ATTRIBUTES	Paires clé-valeur à utiliser comme attributs de ressource. Pour plus d’informations sur les attributs de ressource, consultez la spécification du SDK de ressources.
OTEL_SERVICE_NAME	Définit la valeur de l’attribut de ressource service.name. Si la valeur service.name est également fournie dans OTEL_RESOURCE_ATTRIBUTES, OTEL_SERVICE_NAME est alors prioritaire.

.NET

Variable d’environnement	Description
APPLICATIONINSIGHTS_CONNECTION_STRING	Copiez-le dans la chaîne de connexion à partir de votre ressource Application Insights.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED	Définissez-le sur true pour refuser la collecte de métriques interne.
OTEL_RESOURCE_ATTRIBUTES	Paires clé-valeur à utiliser comme attributs de ressource. Pour plus d’informations sur les attributs de ressource, consultez la spécification du SDK de ressources.
OTEL_SERVICE_NAME	Définit la valeur de l’attribut de ressource service.name. Si la valeur service.name est également fournie dans OTEL_RESOURCE_ATTRIBUTES, OTEL_SERVICE_NAME est alors prioritaire.

Java

Pour plus d’informations sur Java, consultez la documentation supplémentaire relative à Java.

Node.JS

Pour plus d’informations sur la configuration du kit de développement logiciel (SDK) OpenTelemetry, consultez la documentation relative à OpenTelemetry.

Python

Pour plus d’informations sur la configuration du SDK OpenTelemetry, consultez la documentation relative à OpenTelemetry et Utilisation d’Azure Monitor Distro.

Forum aux questions

Cette section fournit des réponses aux questions fréquentes.

Qu’est-ce qu’OpenTelemetry ?

C’est une nouvelle norme open source pour l’observabilité. Pour en savoir plus, rendez-vous sur OpenTelemetry.

Pourquoi Microsoft Azure Monitor investit-il dans OpenTelemetry ?

Microsoft fait partie des plus importants contributeurs d’OpenTelemetry.

Les principales propositions de valeur d’OpenTelemetry reposent sur le fait qu’elles sont indépendantes du fournisseur et qu’elles offrent des API/kits SDK cohérents dans tous les langages.

Au fil du temps, nous pensons qu’OpenTelemetry permettra aux clients d’Azure Monitor d’observer des applications écrites dans des langages autres que nos langages pris en charge. Il étend également les types de données que vous pouvez collecter via un ensemble complet de bibliothèques d’instrumentation. En outre, les kits de développement logiciel (SDK) OpenTelemetry ont tendance à être plus performants à grande échelle que leurs prédécesseurs, les kits de développement logiciel (SDK) Application Insights.

Enfin, OpenTelemetry est en phase avec la stratégie de Microsoft qui vise à adopter l’open source.

Quel est l’état d’OpenTelemetry ?

Consultez l’état d’OpenTelemetry.

Qu’est-ce que la « distribution Azure Monitor OpenTelemetry » ?

Vous pouvez le considérer comme un wrapper mince qui regroupe tous les composants OpenTelemetry pour une expérience de première classe sur Azure. Ce wrapper est également appelé une distribution dans OpenTelemetry.

Pourquoi utiliser la « distribution Azure Monitor OpenTelemetry » ?

Il existe plusieurs avantages à utiliser la distribution Azure Monitor OpenTelemetry par rapport à OpenTelemetry natif de la communauté :

• Réduit l’effort d’activation
• Prise en charge par Microsoft
• Intègre des fonctionnalités spécifiques à Azure, telles que :
  • L’échantillonnage compatible avec les kits SDK Application Insights classiques
  • Authentification Microsoft Entra
  • Stockage hors connexion et nouvelles tentatives automatiques
  • Statsbeat
  • Métriques standard sur Application Insights
  • La détection des métadonnées de ressource pour remplir automatiquement Nom de rôle cloud et Instance de rôle cloud sur différents environnements Azure
  • Métriques temps réel

Dans l’esprit d’OpenTelemetry, nous avons conçu la distribution pour qu’elle soit ouverte et extensible. Par exemple, vous pouvez ajouter :

• Un exportateur OTLP (OpenTelemetry Protocol) et l’envoi vers une seconde destination simultanément
• Autres bibliothèques d’instrumentation non incluses dans la distribution

Étant donné que la distribution fournit une distribution OpenTelemetry, la distribution prend en charge tout ce qui est pris en charge par OpenTelemetry. Par exemple, vous pouvez ajouter d’autres processeurs de télémétrie, exportateurs ou bibliothèques d’instrumentation si OpenTelemetry les prend en charge.

Remarque

La distribution définit l’échantillonneur sur un échantillonneur personnalisé à taux fixe pour Application Insights. Vous pouvez le modifier pour un autre échantillonneur, mais cela peut désactiver certaines des fonctionnalités incluses de la distribution. Pour plus d’informations sur l’échantillonneur pris en charge, consultez la section Activer l’échantillonnage de Configurer Azure Monitor OpenTelemetry.

Pour les langues sans exportateur OpenTelemetry autonome pris en charge, la distribution OpenTelemetry d’Azure Monitor est la seule façon actuellement prise en charge d’utiliser OpenTelemetry avec Azure Monitor. Pour les langues avec un exportateur OpenTelemetry autonome pris en charge, vous avez la possibilité d’utiliser la distribution OpenTelemetry Azure Monitor ou l’exportateur OpenTelemetry autonome approprié en fonction de votre scénario de télémétrie. Pour plus d’informations, consultez Quand dois-je utiliser l’exportateur Azure Monitor OpenTelemetry ?.

Comment tester la distribution Azure Monitor OpenTelemetry ?

Consultez notre documentation sur l’activation pour .NET, Java, JavaScript (Node.js) et Python.

Dois-je utiliser le kit de développement logiciel (SDK) OpenTelemetry ou Application Insights ?

Nous vous recommandons d’utiliser la distribution OpenTelemetry, sauf si vous avez besoin d’une fonctionnalité disponible uniquement avec une prise en charge officielle dans le kit SDK Application Insights.

L’adoption d’OpenTelemetry empêche désormais la migration à une date ultérieure.

Quand utiliser l’exportateur OpenTelemetry Azure Monitor ?

Pour ASP.NET Core, Java, Node.js et Python, nous vous recommandons d’utiliser la distribution OpenTelemetry Azure Monitor. Il s’agit d’une ligne de code pour démarrer.

Pour tous les autres scénarios .NET, comme les applications ASP.NET classiques, Console, etc., nous vous recommandons d’utiliser l’exportateur OpenTelemetry Azure Monitor .NET : Azure.Monitor.OpenTelemetry.Exporter.

Pour les scénarios de télémétrie Python plus complexes nécessitant une configuration avancée, nous vous recommandons utiliser l’Exportateur Azure Monitor OpenTelemetry.

Quel est l’état de publication actuel des fonctionnalités de la distribution Azure Monitor OpenTelemetry ?

Le graphique suivant présente la prise en charge des fonctionnalités OpenTelemetry pour chaque langage.

Fonctionnalité	.NET	Node.js	Python	Java
Traçage distribué	✅	✅	✅	✅
Métriques personnalisées	✅	✅	✅	✅
Métriques standard (précision affectée par l’échantillonnage)	✅	✅	✅	✅
Échantillonnage à fréquence fixe	✅	✅	✅	✅
Stockage hors connexion et nouvelles tentatives automatiques	✅	✅	✅	✅
Rapports d’exceptions	✅	✅	✅	✅
Collection de journaux	✅	⚠️	✅	✅
Événements personnalisés	⚠️	⚠️	⚠️	✅
Authentification Microsoft Entra	✅	✅	✅	✅
Métriques temps réel	❌	❌	❌	✅
Détecter le contexte de ressource pour les VM/VMSS et App Service	✅	❌	✅	✅
Détecter le contexte de ressource pour AKS et les fonctions	❌	❌	❌	✅
Filtrage de l’étendue des tests de disponibilité	❌	❌	❌	✅
Remplissage automatique de l’identifiant utilisateur, de l’identifiant utilisateur authentifié et de l’IP utilisateur	❌	❌	❌	✅
Remplacer/définir manuellement le nom de l’opération, l’ID utilisateur ou l’ID utilisateur authentifié	❌	❌	❌	✅
échantillonnage adaptatif	❌	❌	❌	✅
Profiler	❌	❌	❌	⚠️
Débogueur de capture instantanée	❌	❌	❌	❌

Clé

• ✅ Cette fonctionnalité est disponible pour tous les clients bénéficiant d’un support formel.
• ⚠ Cette fonctionnalité est disponible en préversion publique. Consultez Conditions d’utilisation supplémentaires des Préversions Microsoft Azure.
• ❌ Cette fonctionnalité n’est pas disponible ou n’est pas applicable.

OpenTelemetry peut-il être utilisé pour les navigateurs web ?

Oui, mais cela n’est pas recommandé ou pris en charge par Azure. OpenTelemetry JavaScript est fortement optimisé pour Node.js. Au lieu de cela, nous vous recommandons d’utiliser le Kit de développement logiciel (SDK) JavaScript Application Insights.

Quand pouvons-nous nous attendre à ce que le Kit de développement logiciel (SDK) OpenTelemetry soit disponible pour être utilisé dans les navigateurs web ?

Le SDK web OpenTelemetry n’a pas de planning de disponibilité défini. Il faudra probablement attendre encore plusieurs années avant qu’un SDK pour navigateur ne constitue une alternative viable au SDK JavaScript d’Application Insights.

Puis-je tester OpenTelemetry dans un navigateur web aujourd’hui ?

Le bac à sable web OpenTelemetry est une duplication (fork) conçue pour permettre à OpenTelemetry de fonctionner dans un navigateur. Il n’est pas encore possible d’envoyer des données de télémétrie à Application Insights. Le SDK ne définit pas d’événements clients d’ordre général.

L’exécution d’Application Insights avec les agents concurrents tels que AppDynamics, DataDog et NewRelic est-elle prise en charge ?

Nombre Bien que nos distributions vous permettent d’exporter simultanément vers un point de terminaison OTLP et Azure Monitor, nous ne prévoyons pas de tester ou de prendre en charge cette pratique.

Puis-je utiliser les fonctionnalités d’évaluation dans les environnements de production ?

Nous ne le recommandons pas. Consultez Conditions d’utilisation supplémentaires des Préversions Microsoft Azure.

Quelle est la différence entre une instrumentation manuelle et automatique ?

Consultez la rubrique Présentation d’OpenTelemetry.

Est-il possible d’utiliser le collecteur OpenTelemetry ?

Certains clients utilisent le collecteur OpenTelemetry comme agent de substitution, même si Microsoft ne prend pas encore officiellement en charge une approche basée sur un agent pour la surveillance d’applications. En attendant, la communauté open source a contribué à créer un exportateur Azure Monitor de collecteur OpenTelemetry que certains clients utilisent pour envoyer des données à Azure Monitor Application Insights. Ce n’est pas pris en charge par Microsoft.

Quelle est la différence entre OpenCensus et OpenTelemetry ?

OpenCensus est le précurseur d’OpenTelemetry. Microsoft a contribué à réunir OpenTracing et OpenCensus pour créer OpenTelemetry, une norme d’observabilité unique et disponible à l’échelle mondiale. Le Kit de développement logiciel (SDK) Python actuellement recommandé en production pour Azure Monitor est basé sur OpenCensus. Microsoft s’engage à baser Azure Monitor sur OpenTelemetry.

Dépannage

ASP.NET Core

Cela ne fonctionne pas ? Consultez la page de résolution des problèmes pour ASP.NET Core.

.NET

Cela ne fonctionne pas ? Consultez la page de résolution des problèmes pour .NET.

Java

Cela ne fonctionne pas ? Consultez la page de résolution des problèmes pour Java.

Node.JS

Cela ne fonctionne pas ? Consultez la page de résolution des problèmes pour Node.js.

Python

Cela ne fonctionne pas ? Consultez la page de résolution des problèmes pour Python.

Support

Sélectionnez un onglet correspondant à la langue de votre choix pour découvrir les options de support.

ASP.NET Core

• Pour les problèmes de support Azure, ouvrez un ticket de support Azure.
• Pour les problèmes OpenTelemetry, contactez directement la communauté OpenTelemetry .NET.
• Pour obtenir la liste des problèmes ouverts liés à Azure Monitor Exporter, consultez la page Problèmes GitHub.

.NET

• Pour les problèmes de support Azure, ouvrez un ticket de support Azure.
• Pour les problèmes OpenTelemetry, contactez directement la communauté OpenTelemetry .NET.
• Pour obtenir la liste des problèmes ouverts liés à Azure Monitor Exporter, consultez la page Problèmes GitHub.

Java

• Pour les problèmes de support Azure, ouvrez un ticket de support Azure.
• Pour obtenir de l’aide pour la résolution des problèmes, consultez les étapes de résolution des problèmes.
• Pour les problèmes OpenTelemetry, contactez directement la communauté OpenTelemetry.
• Pour obtenir la liste des problèmes ouverts liés à l’instrumentation automatique Azure Monitor Java, consultez la page Problèmes GitHub.

Node.JS

• Pour les problèmes de support Azure, ouvrez un ticket de support Azure.
• Pour les problèmes OpenTelemetry, contactez directement la communauté OpenTelemetry JavaScript.
• Pour obtenir la liste des problèmes ouverts liés à Azure Monitor Exporter, consultez la page Problèmes GitHub.

Python

• Pour les problèmes de support Azure, ouvrez un ticket de support Azure.
• Pour les problèmes OpenTelemetry, contactez directement la communauté OpenTelemetry Python.
• Pour obtenir la liste des problèmes ouverts liés à Azure Monitor Distro, consultez la page Problèmes GitHub.

Commentaires OpenTelemetry

Pour fournir des commentaires :

• Remplissez l’enquête sur les commentaires des clients de la communauté OpenTelemetry.
• Parlez de vous à Microsoft en rejoignant la communauté d’utilisateurs précoces d’OpenTelemetry.
• Discutez avec d’autres utilisateurs d’Azure Monitor au sein de la communauté Microsoft Tech.
• Formulez une demande de fonctionnalité sur le Forum de commentaires Azure.