Konfigurace OpenTelemetry služby Azure Monitor

Tento článek popisuje nastavení konfigurace pro distribuci OpenTelemetry služby Azure Monitor.

Connection string

Připojovací řetězec v aplikaci Přehledy definuje cílové umístění pro odesílání telemetrických dat a zajišťuje, že dosáhne příslušného prostředku pro monitorování a analýzu.

ASP.NET Core

Ke konfiguraci připojovací řetězec použijte jeden z následujících tří způsobů:

• Přidejte UseAzureMonitor() do spuštění aplikace ve třídě 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();
  

• Nastavte proměnnou prostředí.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Do konfiguračního souboru přidejte následující část appsettings.json .

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

Poznámka:

Pokud nastavíte připojovací řetězec na více než jednom místě, dodržujeme následující prioritu:

1. Kód
2. Proměnná prostředí
3. Konfigurační soubor

.NET

Ke konfiguraci připojovací řetězec použijte jeden z následujících dvou způsobů:

• Přidejte exportér Azure Monitoru do každého signálu OpenTelemetry při spuštění aplikace.

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

• Nastavte proměnnou prostředí.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

Poznámka:

Pokud nastavíte připojovací řetězec na více než jednom místě, dodržujeme následující prioritu:

1. Kód
2. Proměnná prostředí

Java

Pokud chcete nastavit připojovací řetězec, přečtěte si Připojení řetězec.

Node.js

Ke konfiguraci připojovací řetězec použijte jeden z následujících dvou způsobů:

• Nastavte proměnnou prostředí.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Použijte objekt konfigurace.

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

Ke konfiguraci připojovací řetězec použijte jeden z následujících dvou způsobů:

• Nastavte proměnnou prostředí.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• configure_azure_monitorPoužijte funkci.

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

Nastavení názvu cloudové role a instance cloudové role

V případě podporovaných jazyků distro Služby Azure Monitor OpenTelemetry automaticky rozpozná kontext prostředku a poskytuje výchozí hodnoty pro název cloudové role a vlastnosti instance cloudové role vaší komponenty. Můžete ale chtít přepsat výchozí hodnoty na něco, co dává vašemu týmu smysl. Hodnota názvu cloudové role se zobrazí v mapě aplikace jako název pod uzlem.

ASP.NET Core

Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá service.namespace a service.name atributy, i když se vrátí zpět, service.name pokud service.namespace není nastavený. Instance cloudové role používá hodnotu atributu service.instance.id . Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence 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

Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá service.namespace a service.name atributy, i když se vrátí zpět, service.name pokud service.namespace není nastavený. Instance cloudové role používá hodnotu atributu service.instance.id . Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence 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

Pokud chcete nastavit název cloudové role, podívejte se na název cloudové role.

Pokud chcete nastavit instanci cloudové role, podívejte se na instanci cloudové role.

Node.js

Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá service.namespace a service.name atributy, i když se vrátí zpět, service.name pokud service.namespace není nastavený. Instance cloudové role používá hodnotu atributu service.instance.id . Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence 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

Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá service.namespace a service.name atributy, i když se vrátí zpět, service.name pokud service.namespace není nastavený. Instance cloudové role používá hodnotu atributu service.instance.id . Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence OpenTelemetry.

Nastavte atributy prostředku pomocí OTEL_RESOURCE_ATTRIBUTES proměnných prostředí a/nebo OTEL_SERVICE_NAME prostředí. OTEL_RESOURCE_ATTRIBUTES přebírá řadu párů klíč-hodnota oddělených čárkami. Pokud například chcete nastavit název cloudové role na my-namespace.my-helloworld-service instanci cloudové role a nastavit na my-instanceji, můžete nastavit OTEL_RESOURCE_ATTRIBUTES a OTEL_SERVICE_NAME například:

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

Pokud atribut Resource nenastavíte service.namespace , můžete případně nastavit název cloudové role pouze s proměnnou prostředí OTEL_SERVICE_NAME nebo atributem service.name Resource. Pokud například chcete nastavit název cloudové role na my-helloworld-service instanci cloudové role a nastavit na my-instanceji, můžete nastavit OTEL_RESOURCE_ATTRIBUTES a OTEL_SERVICE_NAME například:

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

Povolení vzorkování

Můžete chtít povolit vzorkování, abyste snížili objem příjmu dat, což snižuje náklady. Azure Monitor poskytuje vlastní vzorkovací nástroj s pevnou rychlostí, který naplní události poměrem vzorkování, na který aplikace Přehledy převede ItemCount. Vzorkovník s pevnou rychlostí zajišťuje přesné zkušenosti a počty událostí. Sampler je navržený tak, aby zachoval trasování napříč službami a je interoperabilní se staršími sadami Application Přehledy SDK. Další informace najdete v tématu Další informace o vzorkování.

Poznámka:

Na metriky a protokoly nemá vzorkování vliv.

ASP.NET Core

Vzorek očekává vzorkovací frekvenci mezi 0 a 1 včetně. Rychlost 0,1 znamená, že se odesílá přibližně 10 % trasování.

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

Vzorek očekává vzorkovací frekvenci mezi 0 a 1 včetně. Rychlost 0,1 znamená, že se odesílá přibližně 10 % trasování.

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

Od verze 3.4.0 je k dispozici vzorkování s omezením rychlosti a je teď výchozí. Další informace o vzorkování najdete v tématu Vzorkování v Javě.

Node.js

Vzorek očekává vzorkovací frekvenci mezi 0 a 1 včetně. Rychlost 0,1 znamená, že se odesílá přibližně 10 % trasování.

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

Funkce configure_azure_monitor() automaticky využívá Application Přehledy Sampler pro zajištění kompatibility se sadami SDK Přehledy aplikací a ukázkou telemetrie. Proměnnou OTEL_TRACES_SAMPLER_ARG prostředí lze použít k určení vzorkovací frekvence s platným rozsahem 0 až 1, kde 0 je 0 % a 1 je 100 %. Například hodnota 0,1 znamená, že se odešle 10 % trasování.

export OTEL_TRACES_SAMPLER_ARG=0.1

Tip

Pokud používáte vzorkování s pevnou rychlostí nebo procentem a nevíte, jak nastavit vzorkovací frekvenci, začněte na 5 % (tj. poměr vzorkování 0,05) a upravte rychlost na základě přesnosti operací zobrazených v ostřích selhání a výkonu. Vyšší míra obecně vede k vyšší přesnosti. Vzorkování ANY ale bude mít vliv na přesnost, takže doporučujeme upozorňovat na metriky OpenTelemetry, které nejsou ovlivněné vzorkováním.

Povolení ověřování Microsoft Entra ID (dříve Azure AD)

Možná budete chtít povolit ověřování Microsoft Entra pro bezpečnější připojení k Azure, které brání neoprávněné telemetrii v ingestování do vašeho předplatného.

ASP.NET Core

Podporujeme třídy přihlašovacích údajů poskytované službou Azure Identity.

• DefaultAzureCredential Doporučujeme pro místní vývoj.
• Doporučujeme ManagedIdentityCredential pro spravované identity přiřazené systémem a přiřazené uživatelem.
  • Pro přiřazení systému použijte výchozí konstruktor bez parametrů.
  • Pro uživatelem přiřazené zadejte ID klienta konstruktoru.
• Doporučujeme ClientSecretCredential pro instanční objekty.
  • Do konstruktoru zadejte ID tenanta, ID klienta a tajný klíč klienta.

1. Nainstalujte nejnovější balíček Azure.Identity :

   dotnet add package Azure.Identity
   

2. Zadejte požadovanou třídu přihlašovacích údajů:

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

Podporujeme třídy přihlašovacích údajů poskytované službou Azure Identity.

• DefaultAzureCredential Doporučujeme pro místní vývoj.
• Doporučujeme ManagedIdentityCredential pro spravované identity přiřazené systémem a přiřazené uživatelem.
  • Pro přiřazení systému použijte výchozí konstruktor bez parametrů.
  • Pro uživatelem přiřazené zadejte ID klienta konstruktoru.
• Doporučujeme ClientSecretCredential pro instanční objekty.
  • Do konstruktoru zadejte ID tenanta, ID klienta a tajný klíč klienta.

1. Nainstalujte nejnovější balíček Azure.Identity :

   dotnet add package Azure.Identity
   

2. Zadejte požadovanou třídu přihlašovacích údajů:

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

Další informace o Javě najdete v doplňkové dokumentaci k Javě.

Node.js

Podporujeme třídy přihlašovacích údajů poskytované službou Azure Identity.

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

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

// Create a new AzureMonitorOpenTelemetryOptions object and set the credential property to the credential object.
const options: AzureMonitorOpenTelemetryOptions = {
    azureMonitorExporterOptions: {
        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(),
)

Offline úložiště a automatické opakování

Aby se zlepšila spolehlivost a odolnost, nabídky založené na Azure Monitoru OpenTelemetry ve výchozím nastavení zapisují do offline nebo místního úložiště, když aplikace ztratí připojení ke službě Application Přehledy. Ukládá telemetrii aplikace na disk a pravidelně se ji pokouší odeslat až po dobu 48 hodin. V aplikacích s vysokým zatížením se telemetrie občas zahodí ze dvou důvodů. Za prvé, když je překročen povolený čas a druhý, když je překročena maximální velikost souboru nebo sada SDK nemá příležitost soubor vymazat. Pokud si chceme vybrat, produkt uloží novější události oproti starým událostem. Další informace

ASP.NET Core

Balíček Distro obsahuje AzureMonitorExporter, který ve výchozím nastavení používá pro offline úložiště jedno z následujících umístění (v pořadí podle priority):

• Windows:
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Jiné než Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

Pokud chcete přepsat výchozí adresář, měli byste nastavit 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();

Chcete-li tuto funkci zakázat, měli byste nastavit AzureMonitorOptions.DisableOfflineStorage = true.

.NET

AzureMonitorExporter ve výchozím nastavení používá pro offline úložiště jedno z následujících umístění (v pořadí podle priority):

• Windows:
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Jiné než Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

Pokud chcete přepsat výchozí adresář, měli byste nastavit 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";
        });
    });
});

Chcete-li tuto funkci zakázat, měli byste nastavit AzureMonitorExporterOptions.DisableOfflineStorage = true.

Java

Konfigurace offline úložiště a automatických opakování není v Javě dostupná.

Úplný seznam dostupných konfigurací najdete v tématu Možnosti konfigurace.

Node.js

Ve výchozím nastavení azureMonitorExporter používá pro offline úložiště jednu z následujících umístění.

• Windows:
  • %TEMP%\Microsoft\AzureMonitor
• Jiné než Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor

Pokud chcete přepsat výchozí adresář, měli byste nastavit storageDirectory.

Příklad:

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

Chcete-li tuto funkci zakázat, měli byste nastavit disableOfflineStorage = true.

Python

Ve výchozím nastavení používají exportéři služby Azure Monitor následující cestu:

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

Pokud chcete přepsat výchozí adresář, měli byste nastavit storage_directory požadovaný adresář.

Příklad:

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

Chcete-li tuto funkci zakázat, měli byste nastavit disable_offline_storage hodnotu True. Výchozí hodnota Falseje .

Příklad:

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

Povolení vývozce OTLP

Možná budete chtít povolit exportér openTelemetry Protocol (OTLP) společně s exportérem služby Azure Monitor, aby odesílal telemetrická data do dvou umístění.

Poznámka:

Vývozce OTLP se zobrazuje pouze pro usnadnění. Oficiálně nepodporujeme vývozce OTLP ani žádné komponenty ani zkušenosti třetích stran.

ASP.NET Core

1. Do projektu nainstalujte balíček OpenTelemetry.Exporter.OpenTelemetryProtocol.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v příkladu na GitHubu.

   // 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. Do projektu nainstalujte balíček OpenTelemetry.Exporter.OpenTelemetryProtocol.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v příkladu na GitHubu.

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

Další informace o Javě najdete v doplňkové dokumentaci k Javě.

Node.js

1. Nainstalujte v projektu exportér trasování kolektoru OpenTelemetry a další balíčky OpenTelemetry.

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

2. Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v příkladu na GitHubu.

   // 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. Nainstalujte balíček opentelemetry-export-otlp.

2. Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v tomto souboru 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!")
   

Konfigurace OpenTelemetry

K následujícím konfiguracím OpenTelemetry je možné přistupovat prostřednictvím proměnných prostředí při použití distros openTelemetry služby Azure Monitor.

ASP.NET Core

Proměnná prostředí	Popis
APPLICATIONINSIGHTS_CONNECTION_STRING	Nastavte ho na připojovací řetězec pro prostředek Přehledy aplikace.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED	Nastavte ji tak, aby true se odhlásila z interní kolekce metrik.
OTEL_RESOURCE_ATTRIBUTES	Páry klíč-hodnota, které se mají použít jako atributy prostředků. Další informace o atributech prostředků najdete ve specifikaci sady Sdk prostředků.
OTEL_SERVICE_NAME	Nastaví hodnotu atributu service.name prostředku. Pokud service.name je také uveden v OTEL_RESOURCE_ATTRIBUTES, pak OTEL_SERVICE_NAME má přednost.

.NET

Proměnná prostředí	Popis
APPLICATIONINSIGHTS_CONNECTION_STRING	Nastavte ho na připojovací řetězec pro prostředek Přehledy aplikace.
APPLICATIONINSIGHTS_STATSBEAT_DISABLED	Nastavte ji tak, aby true se odhlásila z interní kolekce metrik.
OTEL_RESOURCE_ATTRIBUTES	Páry klíč-hodnota, které se mají použít jako atributy prostředků. Další informace o atributech prostředků najdete ve specifikaci sady Sdk prostředků.
OTEL_SERVICE_NAME	Nastaví hodnotu atributu service.name prostředku. Pokud service.name je také uveden v OTEL_RESOURCE_ATTRIBUTES, pak OTEL_SERVICE_NAME má přednost.

Java

Další informace o Javě najdete v doplňkové dokumentaci k Javě.

Node.js

Další informace o konfiguraci sady OpenTelemetry SDK najdete v dokumentaci k OpenTelemetry.

Python

Další informace o konfiguraci sady OpenTelemetry SDK najdete v dokumentaci k OpenTelemetry a využití distribuce služby Azure Monitor.

Nejčastější dotazy

Tato část obsahuje odpovědi na běžné otázky.

Co je OpenTelemetry?

Jedná se o nový opensourcový standard pro pozorovatelnost. Další informace najdete v OpenTelemetry.

Proč Microsoft Azure Monitor investuje do OpenTelemetry?

Microsoft je mezi největšími přispěvateli OpenTelemetry.

Návrhy klíčových hodnot OpenTelemetry jsou v tom, že jsou neutrální od dodavatele a poskytují konzistentní rozhraní API a sady SDK napříč jazyky.

V průběhu času věříme, že OpenTelemetry umožní zákazníkům služby Azure Monitor sledovat aplikace napsané v jazycích nad rámec našich podporovaných jazyků. Rozšiřuje také typy dat, které můžete shromažďovat prostřednictvím bohaté sady knihoven instrumentace. Sady OpenTelemetry SDK navíc mají tendenci být výkonnější ve velkém měřítku než jejich předchůdci, sada Application Přehledy SDK.

Nakonec OpenTelemetry odpovídá strategii Microsoftu pro přijetí opensourcových řešení.

Jaký je stav OpenTelemetry?

Viz stav OpenTelemetry.

Co je distro "Azure Monitor OpenTelemetry"?

Můžete si ho představit jako tenký obal, který spojuje všechny komponenty OpenTelemetry pro prvotřídní prostředí v Azure. Tento obálka se také nazývá distribuce v OpenTelemetry.

Proč mám používat distro "Azure Monitor OpenTelemetry"?

Použití opentelemetry Azure Monitoru přes nativní OpenTelemetry od komunity má několik výhod:

• Snižuje úsilí o povolení
• Podporováno Microsoftem
• Přináší funkce specifické pro Azure, například:
  • Vzorkování kompatibilní s klasickými sadami SDK Přehledy aplikací
  • Ověřování Microsoft Entra
  • Offline úložiště a automatické opakování
  • Statsbeat
  • Standardní metriky Přehledy aplikací
  • Detekce metadat prostředků pro automatické naplnění názvu cloudové role a instance cloudové role v různých prostředích Azure
  • Live Metrics

V duchu OpenTelemetry jsme navrhli distribuci tak, aby byla otevřená a rozšiřitelná. Můžete například přidat:

• Vývozce protokolu OTLP (OpenTelemetry Protocol) a odeslání do druhého místa určení současně
• Jiné knihovny instrumentace, které nejsou součástí distribuce

Vzhledem k tomu, že distro poskytuje distribuci OpenTelemetry, distro podporuje cokoli, co podporuje OpenTelemetry. Pokud je OpenTelemetry podporuje, můžete například přidat další procesory telemetrie, exportéry nebo knihovny instrumentace.

Poznámka:

Distribuce nastaví vzorkovník na vlastní vzorkovník s pevnou rychlostí pro aplikační Přehledy. Můžete to změnit na jiný sampler, ale můžete to udělat tak, že zakážete některé zahrnuté funkce distribuce. Další informace o podporovaném sampleru najdete v části Povolení vzorkování v části Konfigurace OpenTelemetry služby Azure Monitor.

Pro jazyky bez podporovaného samostatného exportéru OpenTelemetry je jediným aktuálně podporovaným způsobem použití OpenTelemetry se službou Azure Monitor. Pro jazyky s podporovaným samostatným exportérem OpenTelemetry máte možnost použít distro služby Azure Monitor OpenTelemetry nebo příslušný samostatný exportér OpenTelemetry v závislosti na vašem scénáři telemetrie. Další informace najdete v tématu Kdy mám použít exportér OpenTelemetry služby Azure Monitor?.

Jak můžu otestovat distribuci OpenTelemetry služby Azure Monitor?

Projděte si naši dokumentaci k povolení pro .NET, Java, JavaScript (Node.js) a Python.

Mám použít OpenTelemetry nebo sadu Application Přehledy SDK?

Pokud nepotřebujete funkci, která je dostupná pouze s formální podporou v sadě Application Přehledy SDK, doporučujeme používat distro OpenTelemetry.

Přijetí OpenTelemetry teď brání migraci později.

Kdy mám použít exportér OpenTelemetry služby Azure Monitor?

Pro ASP.NET Core, Javu, Node.js a Python doporučujeme použít distro OpenTelemetry služby Azure Monitor. Začněte jedním řádkem kódu.

Pro všechny ostatní scénáře .NET, včetně klasických ASP.NET, konzolových aplikací atd., doporučujeme použít exportér OpenTelemetry pro .NET Azure Monitor: Azure.Monitor.OpenTelemetry.Exporter

Pro složitější scénáře telemetrie Pythonu, které vyžadují pokročilou konfiguraci, doporučujeme použít exportér OpenTelemetry služby Python Azure Monitor.

Jaký je aktuální stav funkcí ve službě Azure Monitor OpenTelemetry Distro?

Následující graf rozebíral podporu funkcí OpenTelemetry pro každý jazyk.

Funkce	.NET	Node.js	Python	Java
Distribuované trasování	✅	✅	✅	✅
Vlastní metrika	✅	✅	✅	✅
Standardní metriky (přesnost aktuálně ovlivněná vzorkováním)	✅	✅	✅	✅
Vzorkování s pevnou frekvencí	✅	✅	✅	✅
Offline úložiště a automatické opakování	✅	✅	✅	✅
Generování sestav výjimek	✅	✅	✅	✅
Shromažďování protokolů	✅	⚠️	✅	✅
Vlastní události	⚠️	⚠️	⚠️	✅
Ověřování Microsoft Entra	✅	✅	✅	✅
Živé metriky	❌	❌	❌	✅
Zjištění kontextu prostředků pro virtuální počítač nebo VMSS a App Service	✅	❌	✅	✅
Zjištění kontextu prostředku pro AKS a funkce	❌	❌	❌	✅
Filtrování rozsahu testování dostupnosti	❌	❌	❌	✅
Automatické naplnění ID uživatele, ověřené ID uživatele a IP adresy uživatele	❌	❌	❌	✅
Ruční přepsání/nastavení názvu operace, ID uživatele nebo ověřeného ID uživatele	❌	❌	❌	✅
Adaptivní vzorkování	❌	❌	❌	✅
Profiler	❌	❌	❌	⚠️
Ladicí program snímků	❌	❌	❌	❌

Klíč

• ✅ Tato funkce je dostupná všem zákazníkům s formální podporou.
• ⚠✔ Tato funkce je k dispozici jako veřejná verze Preview. Přečtěte si doplňkové podmínky použití pro verze Preview Microsoft Azure.
• ❌ Tato funkce není dostupná nebo se nedá použít.

Je možné OpenTelemetry použít pro webové prohlížeče?

Ano, ale nedoporučujeme ho a Azure ho nepodporuje. OpenTelemetry JavaScript je silně optimalizovaný pro Node.js. Místo toho doporučujeme použít sadu Application Přehledy JavaScript SDK.

Kdy můžeme očekávat, že sada OpenTelemetry SDK bude dostupná pro použití ve webových prohlížečích?

Webová sada SDK OpenTelemetry nemá určenou časovou osu dostupnosti. Pravděpodobně jsme několik let daleko od sady SDK prohlížeče, která je možná alternativou k sadě Application Přehledy JavaScript SDK.

Můžu dnes testovat OpenTelemetry ve webovém prohlížeči?

Webový sandbox OpenTelemetry je fork navržený tak, aby openTelemetry fungoval v prohlížeči. Zatím není možné odesílat telemetrii do služby Application Přehledy. Sada SDK nedefinuje obecné události klienta.

Běží aplikace Přehledy společně s agenty konkurentů, jako jsou AppDynamics, DataDog a NewRelic?

Ne. Tento postup není něco, co plánujeme testovat nebo podporovat, i když naše distribuce umožňují exportovat do koncového bodu OTLP společně se službou Azure Monitor současně.

Můžu používat funkce preview v produkčních prostředích?

Nedoporučujeme ho. Přečtěte si doplňkové podmínky použití pro verze Preview Microsoft Azure.

Jaký je rozdíl mezi ručním a automatickým instrumentací?

Viz přehled OpenTelemetry.

Můžu použít kolektor OpenTelemetry?

Někteří zákazníci používají OpenTelemetry Collector jako alternativu agenta, i když Microsoft oficiálně nepodporuje přístup založený na agentech pro monitorování aplikací. Do té doby opensourcová komunita přispěla exportérem Azure Monitoru OpenTelemetry Collector, který někteří zákazníci používají k odesílání dat do aplikačního Přehledy služby Azure Monitor. Microsoft to nepodporuje.

Jaký je rozdíl mezi OpenCensus a OpenTelemetry?

OpenCensus je prekurzorem OpenTelemetry. Microsoft pomohl spojit OpenTracing a OpenCensus k vytvoření OpenTelemetry, jediného pozorovatelného standardu pro svět. Aktuální sada Python SDK doporučená pro produkční prostředí pro Azure Monitor je založená na OpenCensus. Společnost Microsoft se zavázala vytvářet Azure Monitor na základě OpenTelemetry.

Řešení problému

ASP.NET Core

Nefunguje to? Podívejte se na stránku pro řešení potíží pro ASP.NET Core.

.NET

Nefunguje to? Podívejte se na stránku pro řešení potíží pro .NET.

Java

Nefunguje to? Podívejte se na stránku pro řešení potíží pro Javu.

Node.js

Nefunguje to? Podívejte se na stránku pro řešení potíží pro Node.js.

Python

Nefunguje to? Projděte si stránku pro řešení potíží pro Python.

Technická podpora

Vyberte kartu pro jazyk podle vašeho výběru a objevte možnosti podpory.

ASP.NET Core

• V případě podpora Azure problémů otevřete lístek podpora Azure.
• V případě problémů s OpenTelemetry se obraťte přímo na komunitu OpenTelemetry .NET.
• Seznam otevřených problémů souvisejících s exportérem služby Azure Monitor najdete na stránce Problémy GitHubu.

.NET

• V případě podpora Azure problémů otevřete lístek podpora Azure.
• V případě problémů s OpenTelemetry se obraťte přímo na komunitu OpenTelemetry .NET.
• Seznam otevřených problémů souvisejících s exportérem služby Azure Monitor najdete na stránce Problémy GitHubu.

Java

• V případě podpora Azure problémů otevřete lístek podpora Azure.
• Nápovědu k řešení potíží najdete v krocích pro řešení potíží.
• V případě problémů s OpenTelemetry kontaktujte přímo komunitu OpenTelemetry.
• Seznam otevřených problémů souvisejících s autoinstruací Java služby Azure Monitor najdete na stránce s problémy GitHubu.

Node.js

• V případě podpora Azure problémů otevřete lístek podpora Azure.
• V případě problémů s OpenTelemetry se obraťte přímo na komunitu OpenTelemetry JavaScriptu.
• Seznam otevřených problémů souvisejících s exportérem služby Azure Monitor najdete na stránce Problémy GitHubu.

Python

• V případě podpora Azure problémů otevřete lístek podpora Azure.
• V případě problémů s OpenTelemetry se obraťte přímo na komunitu Pythonu OpenTelemetry.
• Seznam otevřených problémů souvisejících s distribucí služby Azure Monitor najdete na stránce Problémy GitHubu.

Zpětná vazba k OpenTelemetry

Poskytnutí zpětné vazby:

• Vyplňte průzkum názorů zákazníků komunity OpenTelemetry.
• Řekněte Microsoftu o sobě tím, že se připojíte ke komunitě OpenTelemetry Early Adopter.
• Spojte se s dalšími uživateli služby Azure Monitor v technické komunitě Microsoftu.
• Vytvořte žádost o funkci na fóru Azure Feedback.