Azure Monitor OpenTelemetry konfigurieren

Verwenden Sie eine der folgenden drei Möglichkeiten, um die Verbindungszeichenfolge zu konfigurieren:

• Fügen Sie der Datei program.cs UseAzureMonitor() hinzu:

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

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Fügen Sie den folgenden Abschnitt in Ihrer Konfigurationsdatei appsettings.json hinzu.

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

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Fügen Sie jedem OpenTelemetry-Signal beim Anwendungsstart den Azure Monitor Exporter hinzu.

  // 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(logging =>
      {
          logging.AddAzureMonitorLogExporter(options =>
          {
              options.ConnectionString = "<Your Connection String>";
          });
      });
  });
  

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

Lesen Sie zum Festlegen der Verbindungszeichenfolge die Informationen unter Verbindungszeichenfolge.

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Legen Sie eine Eigenschaft fest.

  applicationinsights.connection.string=<Your Connection String>
  

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Verwend Sie ein Konfigurationsobjekt.

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

Verwenden Sie eine der folgenden beiden Methoden zum Konfigurieren der Verbindungszeichenfolge:

• Legen Sie eine Umgebungsvariable fest.

  APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
  

• Sie verwenden die Funktion 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>",
)

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

// Setting role name and role instance

// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
    { "service.name", "my-service" },
    { "service.namespace", "my-namespace" },
    { "service.instance.id", "my-instance" }};

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry()
    .UseAzureMonitor()
    // Configure the ResourceBuilder to add the custom resource attributes to all signals.
    // Custom resource attributes should be added AFTER AzureMonitor to override the default ResourceDetectors.
    .ConfigureResource(resourceBuilder => resourceBuilder.AddAttributes(_testResourceAttributes));

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

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

Informationen zum Festlegen des Cloudrollennamens finden Sie unter Name der Cloudrolle.

Informationen zum Festlegen der Cloudrolleninstanz finden Sie unter Cloudrolleninstanz.

So legen Sie den Cloudrollennamen fest

• Verwenden Sie spring.application.name für native Spring Boot-Imageanwendungen.
• Verwenden Sie quarkus.application.name für native Quarkus-Imageanwendungen.

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

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

Legen Sie den Cloudrollennamen und die Cloudrolleninstanz über Ressourcenattribute fest. Der Cloudrollenname verwendet die Attribute service.namespace und service.name, obwohl er auf service.name zurückfällt, wenn service.namespace nicht festgelegt ist. Die Cloudrolleninstanz verwendet den service.instance.id-Attributwert. Informationen zu Standardattributen für Ressourcen finden Sie unter OpenTelemetry-Semantikkonventionen.

Legen Sie Ressourcenattribute mithilfe der Umgebungsvariablen OTEL_RESOURCE_ATTRIBUTES und/oder OTEL_SERVICE_NAME fest. OTEL_RESOURCE_ATTRIBUTES übernimmt eine Reihe von durch Kommata getrennten Schlüssel-Wert-Paaren. Wenn Sie beispielsweise den Cloudrollennamen auf my-namespace.my-helloworld-service festlegen und die Cloudrolleninstanz auf my-instance, können Sie OTEL_RESOURCE_ATTRIBUTES und OTEL_SERVICE_NAME wie folgt festlegen:

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

Wenn Sie das service.namespace-Ressourcenattribut nicht setzen, können Sie alternativ den Namen der Cloud-Rolle nur mit der Umgebungsvariablen OTEL_SERVICE_NAME oder dem service.name-Ressourcenattribut setzen. Wenn Sie beispielsweise den Cloudrollennamen auf my-helloworld-service festlegen und die Cloudrolleninstanz auf my-instance, können Sie OTEL_RESOURCE_ATTRIBUTES und OTEL_SERVICE_NAME wie folgt festlegen:

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

Von der Stichprobenentnahme wird eine Stichprobenrate zwischen 0 und 1 (einschließlich) erwartet. Bei einer Rate von 0,1 werden ca. zehn Prozent Ihrer Ablaufverfolgungen gesendet.

// 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 sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
    options.SamplingRatio = 0.1F;
});

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Von der Stichprobenentnahme wird eine Stichprobenrate zwischen 0 und 1 (einschließlich) erwartet. Bei einer Rate von 0,1 werden ca. zehn Prozent Ihrer Ablaufverfolgungen gesendet.

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

Ab Version 3.4.0 steht Sampling mit Ratenbegrenzung zur Verfügung und ist jetzt Standard. Weitere Informationen zum Sampling finden Sie unter Java-Sampling.

Für native Spring Boot-Anwendungen gelten die Konfigurationen der Stichprobenerstellung des OpenTelemetry Java SDK.

Informationen zu nativen Quarkus-Anwendungen finden Sie in der Dokumentation zu Quarkus OpenTelemetry.

Von der Stichprobenentnahme wird eine Stichprobenrate zwischen 0 und 1 (einschließlich) erwartet. Bei einer Rate von 0,1 werden ca. zehn Prozent Ihrer Ablaufverfolgungen gesendet.

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

Die configure_azure_monitor()-Funktion verwendet automatisch ApplicationInsightsSampler, um die Kompatibilität mit Application Insights-SDKs zu gewährleisten und Stichproben Ihrer Telemetriedaten zu erfassen. Die OTEL_TRACES_SAMPLER_ARG-Umgebungsvariable kann verwendet werden, um die Stichprobenentnahmerate anzugeben, mit einem gültigen Bereich von 0 bis 1, wobei 0 0 % und 1 100 % ist. Ein Wert von 0,1 bedeutet beispielsweise, dass 10 % Ihrer Ablaufverfolgungen gesendet werden.

export OTEL_TRACES_SAMPLER_ARG=0.1

Dieses Feature ist standardmäßig aktiviert.

Benutzer können Livemetriken beim Konfigurieren der Distribution deaktivieren.

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

Diese Funktion ist in der Exportfunktion von Azure Monitor .NET nicht verfügbar.

Die Funktion für Livemetriken ist standardmäßig aktiviert.

Weitere Informationen zur Java-Konfiguration finden Sie unter Konfigurationsoptionen: Azure Monitor Application Insights für Java.

Die Livemetriken sind derzeit für native GraalVM-Anwendungen nicht verfügbar.

Benutzer können Livemetriken beim Konfigurieren der Distribution mithilfe der enableLiveMetrics-Eigenschaft aktivieren oder deaktivieren.

const options: AzureMonitorOpenTelemetryOptions = {
    azureMonitorExporterOptions: {
        connectionString:
            process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
    },
    enableLiveMetrics: false
};

useAzureMonitor(options);

Sie können Livemetriken mit der Azure Monitor OpenTelemetry-Distribution für Python wie folgt aktivieren:

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

Wir unterstützen die von Azure Identity bereitgestellten Anmeldeinformationsklassen.

• Wir empfehlen DefaultAzureCredential für die lokale Entwicklung.
• Wir empfehlen ManagedIdentityCredential wird für systemseitig zugewiesene und benutzerseitig zugewiesene verwaltete Identitäten.
  • Verwenden Sie bei systemseitig zugewiesenen Identitäten den Standardkonstruktor ohne Parameter.
  • Stellen Sie bei benutzerseitig zugewiesenen Identitäten die Client-ID für den Konstruktor bereit.
• Wir empfehlen ClientSecretCredential für Dienstprinzipale.
  • Geben Sie die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel für den Konstruktor an.

1. Installieren Sie das neueste Azure.Identity-Paket:

   dotnet add package Azure.Identity
   

2. Geben Sie die gewünschte Klasse für Anmeldeinformation an:

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

Wir unterstützen die von Azure Identity bereitgestellten Anmeldeinformationsklassen.

• Wir empfehlen DefaultAzureCredential für die lokale Entwicklung.
• Wir empfehlen ManagedIdentityCredential wird für systemseitig zugewiesene und benutzerseitig zugewiesene verwaltete Identitäten.
  • Verwenden Sie bei systemseitig zugewiesenen Identitäten den Standardkonstruktor ohne Parameter.
  • Stellen Sie bei benutzerseitig zugewiesenen Identitäten die Client-ID für den Konstruktor bereit.
• Wir empfehlen ClientSecretCredential für Dienstprinzipale.
  • Geben Sie die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel für den Konstruktor an.

1. Installieren Sie das neueste Azure.Identity-Paket:

   dotnet add package Azure.Identity
   

2. Geben Sie die gewünschte Klasse für Anmeldeinformation an:

   // 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(logging =>
       {
           logging.AddAzureMonitorLogExporter(options =>
           {
               options.Credential = credential;
           });
       });
   });
   

Weitere Informationen zu Java finden Sie in der ergänzenden Java-Dokumentation.

Die Microsoft Entra ID-Authentifizierung ist für native GraalVM-Anwendungen nicht verfügbar.

Wir unterstützen die von Azure Identity bereitgestellten Anmeldeinformationsklassen.

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

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

// Create a new AzureMonitorOpenTelemetryOptions object and set the credential property to the credential object.
const options: AzureMonitorOpenTelemetryOptions = {
    azureMonitorExporterOptions: {
        connectionString:
            process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
        credential: credential
    }
};

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

Azure Monitor OpenTelemetry Distro für Python unterstützt die von Azure Identitybereitgestellten Anmeldeinformationsklassen.

• Wir empfehlen DefaultAzureCredential für die lokale Entwicklung.
• Wir empfehlen ManagedIdentityCredential wird für systemseitig zugewiesene und benutzerseitig zugewiesene verwaltete Identitäten.
  • Verwenden Sie bei systemseitig zugewiesenen Identitäten den Standardkonstruktor ohne Parameter.
  • Stellen Sie bei benutzerseitig zugewiesenen Identitäten die client_id für den Konstruktor bereit.
• Wir empfehlen ClientSecretCredential für Dienstprinzipale.
  • Geben Sie die Mandanten-ID, die Client-ID und den geheimen Clientschlüssel für den Konstruktor an.

Bei Verwendung von ManagedIdentityCredential

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

# Configure the Distro to authenticate with Azure Monitor using a managed identity credential.
credential = ManagedIdentityCredential(client_id="<client_id>")
configure_azure_monitor(
    connection_string="your-connection-string",
    credential=credential,
)

tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("hello with aad managed identity"):
    print("Hello, World!")

Bei Verwendung von ClientSecretCredential

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

# Configure the Distro to authenticate with Azure Monitor using a client secret credential.
credential = ClientSecretCredential(
    tenant_id="<tenant_id",
    client_id="<client_id>",
    client_secret="<client_secret>",
)
configure_azure_monitor(
    connection_string="your-connection-string",
    credential=credential,
)

with tracer.start_as_current_span("hello with aad client secret identity"):
    print("Hello, World!")

Das Distributionspaket enthält den AzureMonitorExporter, der standardmäßig einen der folgenden Speicherorte für den Offlinespeicher verwendet (in der Reihenfolge der Vorrangs aufgeführt):

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

Das Standardverzeichnis kann durch Festlegen von AzureMonitorOptions.StorageDirectory überschrieben werden.

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

Wenn Sie das Feature deaktivieren möchten, legen Sie AzureMonitorOptions.DisableOfflineStorage = true fest.

Standardmäßig verwendet AzureMonitorExporter einen der folgenden Speicherorte als Offlinespeicher (in der angegebenen Reihenfolge):

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

Das Standardverzeichnis kann durch Festlegen von AzureMonitorExporterOptions.StorageDirectory überschrieben werden.

// 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(logging =>
    {
        logging.AddAzureMonitorLogExporter(options =>
        {
            // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
            // This is the directory where the OpenTelemetry SDK will store any log data that cannot be sent to Azure Monitor immediately.
            options.StorageDirectory = "C:\\SomeDirectory";
        });
    });
});

Wenn Sie das Feature deaktivieren möchten, legen Sie AzureMonitorExporterOptions.DisableOfflineStorage = true fest.

Das Konfigurieren von Offlinespeicher und automatischen Wiederholungsversuchen ist in Java nicht verfügbar.

Eine vollständige Liste der verfügbaren Konfigurationen finden Sie unter Konfigurationsoptionen.

Das Konfigurieren von Offlinespeicher und automatischen Wiederholungsversuchen ist in nativen Java-Imageanwendungen nicht verfügbar.

Standardmäßig verwendet AzureMonitorExporter einen der folgenden Speicherorte als Offlinespeicher:

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

Das Standardverzeichnis kann durch Festlegen von storageDirectory überschrieben werden.

Beispiel:

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

Wenn Sie das Feature deaktivieren möchten, legen Sie disableOfflineStorage = true fest.

Von den Azure Monitor-Exportprogrammen wird standardmäßig folgender Pfad verwendet:

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

Wenn Sie das Standardverzeichnis überschreiben möchten, können Sie storage_directory auf das gewünschte Verzeichnis festlegen.

Beispiel:

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

Wenn Sie das Feature deaktivieren möchten, legen Sie disable_offline_storage auf True fest. Wird standardmäßig auf False festgelegt.

Beispiel:

...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and disable offline storage.
# Replace `your-connection-string` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
    connection_string="your-connection-string",
    disable_offline_storage=True,
)
...

1. Installieren Sie in Ihrem Projekt das Paket OpenTelemetry.Exporter.OpenTelemetryProtocol.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie im Beispiel zu GitHub.

   // Create a new ASP.NET Core web application builder.
   var builder = WebApplication.CreateBuilder(args);
   
   // Add the OpenTelemetry telemetry service to the application.
   // This service will collect and send telemetry data to Azure Monitor.
   builder.Services.AddOpenTelemetry().UseAzureMonitor();
   
   // Add the OpenTelemetry OTLP exporter to the application.
   // This exporter will send telemetry data to an OTLP receiver, such as Prometheus
   builder.Services.AddOpenTelemetry().WithTracing(builder => builder.AddOtlpExporter());
   builder.Services.AddOpenTelemetry().WithMetrics(builder => builder.AddOtlpExporter());
   
   // Build the ASP.NET Core web application.
   var app = builder.Build();
   
   // Start the ASP.NET Core web application.
   app.Run();
   

1. Installieren Sie in Ihrem Projekt das Paket OpenTelemetry.Exporter.OpenTelemetryProtocol.

   dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
   

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie im Beispiel zu 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();
   

Weitere Informationen zu Java finden Sie in der ergänzenden Java-Dokumentation.

Sie können neben Azure Monitor Exporter nicht den OTLP-Exporter (OpenTelemetry Protocol) aktivieren, um Ihre Telemetriedaten an zwei Speicherorte zu senden.

1. Installieren Sie den OpenTelemetry Collector Trace Exporter und andere OpenTelemetry-Pakete in Ihrem Projekt.

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

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie im Beispiel zu 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);
   

1. Installieren Sie das Paket opentelemetry-exporter-otlp.

2. Fügen Sie den folgenden Codeausschnitt hinzu. In diesem Beispiel wird davon ausgegangen, dass Sie über einen OpenTelemetry-Collector mit einem aktuell ausgeführten OTLP-Empfänger verfügen. Weitere Informationen finden Sie in dieser 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!")
   

Weitere Informationen zu Java finden Sie in der ergänzenden Java-Dokumentation.

Für native Spring Boot-Anwendungen sind die OpenTelemetry Java SDK-Konfigurationen verfügbar.

Informationen zu nativen Quarkus-Anwendungen finden Sie in der Dokumentation zu Quarkus OpenTelemetry.

Weitere Informationen zur Konfiguration des OpenTelemetry SDK finden Sie in der OpenTelemetry-Dokumentation.

Weitere Informationen zur Konfiguration des OpenTelemetry SDK finden Sie in der OpenTelemetry-Dokumentation und unter Verwendung der Azure Monitor-Distribution.

Schritt 1: Aktivieren der Diagnoseprotokollierung

Azure Monitor Exporter verwendet EventSource für die interne Protokollierung. Die Exporterprotokolle sind für alle EventListener verfügbar, indem Sie sich für die Quelle anmelden, die OpenTelemetry-AzureMonitor-Exporter genannt wird. Schritte zur Problembehandlung finden Sie unter OpenTelemetry Troubleshooting auf GitHub.

Schritt 2: Testen der Konnektivität zwischen Ihrem Anwendungshost und dem Erfassungsdienst

Application Insights SDKs und -Agents senden Telemetriedaten, die als REST-Aufrufe unserer Erfassungsendpunkte erfasst werden sollen. Verwenden Sie cURL-Befehle oder unformatierte REST-Anforderungen von PowerShell, um die Konnektivität von Ihrem Webserver- oder Anwendungshostcomputer mit den Endpunkten des Aufnahmediensts zu testen. Ausführliche Informationen finden Sie unter Problembehandlung bei fehlender Anwendungstelemetrie in Azure Monitor Application Insights.

Bekannte Probleme

Die folgenden Elemente sind bekannte Probleme für die OpenTelemetry-Exporter von Azure Monitor:

• Der Vorgangsname fehlt in der Abhängigkeitstelemetrie. Der fehlende Name des Vorgangs verursacht Fehler und wirkt sich negativ auf die Leistung der Registerkartenerfahrung aus.

• Das Gerätemodell fehlt bei der Anforderungs- und Abhängigkeitstelemetrie. Das fehlende Gerätemodell wirkt sich negativ auf die Analyse der Gerätekohorten aus.

Schritt 1: Aktivieren der Diagnoseprotokollierung

Azure Monitor Exporter verwendet EventSource für die interne Protokollierung. Die Exporterprotokolle sind für alle EventListener verfügbar, indem Sie sich für die Quelle anmelden, die OpenTelemetry-AzureMonitor-Exporter genannt wird. Schritte zur Problembehandlung finden Sie unter OpenTelemetry Troubleshooting auf GitHub.

Schritt 2: Testen der Konnektivität zwischen Ihrem Anwendungshost und dem Erfassungsdienst

Application Insights SDKs und -Agents senden Telemetriedaten, die als REST-Aufrufe unserer Erfassungsendpunkte erfasst werden sollen. Verwenden Sie cURL-Befehle oder unformatierte REST-Anforderungen von PowerShell, um die Konnektivität von Ihrem Webserver- oder Anwendungshostcomputer mit den Endpunkten des Aufnahmediensts zu testen. Ausführliche Informationen finden Sie unter Problembehandlung bei fehlender Anwendungstelemetrie in Azure Monitor Application Insights.

Bekannte Probleme

Die folgenden Elemente sind bekannte Probleme für die OpenTelemetry-Exporter von Azure Monitor:

• Der Vorgangsname fehlt in der Abhängigkeitstelemetrie. Der fehlende Name des Vorgangs verursacht Fehler und wirkt sich negativ auf die Leistung der Registerkartenerfahrung aus.

• Das Gerätemodell fehlt bei der Anforderungs- und Abhängigkeitstelemetrie. Das fehlende Gerätemodell wirkt sich negativ auf die Analyse der Gerätekohorten aus.

Schritt 1: Aktivieren der Diagnoseprotokollierung

Die Diagnoseprotokollierung ist standardmäßig in Azure Monitor Application Insights aktiviert. Weitere Informationen finden Sie im Handbuch zur Problembehandlung: Azure Monitor Application Insights for Java.

Schritt 2: Testen der Konnektivität zwischen Ihrem Anwendungshost und dem Erfassungsdienst

Application Insights SDKs und -Agents senden Telemetriedaten, die als REST-Aufrufe unserer Erfassungsendpunkte erfasst werden sollen. Verwenden Sie cURL-Befehle oder unformatierte REST-Anforderungen von PowerShell, um die Konnektivität von Ihrem Webserver- oder Anwendungshostcomputer mit den Endpunkten des Aufnahmediensts zu testen. Ausführliche Informationen finden Sie unter Problembehandlung bei fehlender Anwendungstelemetrie in Azure Monitor Application Insights.

Bekannte Probleme

• Wenn Sie die Application Insights-Clientbibliothek für die Installation aus einem Browser herunterladen, ist manchmal die heruntergeladene JAR-Datei beschädigt und ist etwa die Hälfte der Größe der Quelldatei. Wenn dieses Problem auftritt, laden Sie die JAR-Datei herunter, indem Sie den Befehl curl oder wget ausführen, wie in den folgenden Beispielbefehlsaufrufen gezeigt:

  curl --location --output applicationinsights-agent-3.4.11.jar https://github.com/microsoft/ApplicationInsights-Java/releases/download/3.4.11/applicationinsights-agent-3.4.11.jar
  

  wget --output-document=applicationinsights-agent-3.4.11.jar https://github.com/microsoft/ApplicationInsights-Java/releases/download/3.4.11/applicationinsights-agent-3.4.11.jar
  

  Hinweis

  Der Beispielbefehl gilt für Application Insights für Java, Version 3.4.11. Informationen zur Versionsnummer und URL-Adresse der aktuellen Version von Application Insights für Java finden Sie unter https://github.com/microsoft/ApplicationInsights-Java/releases.

Die folgenden Schritte gelten für systemeigene Spring Boot-Anwendungen.

Schritt 1: Überprüfen der OpenTelemetry-Version

Möglicherweise erscheint beim Starten der Anwendung die folgende Meldung:

WARN  c.a.m.a.s.OpenTelemetryVersionCheckRunner - The OpenTelemetry version is not compatible with the spring-cloud-azure-starter-monitor dependency.
The OpenTelemetry version should be <version>

In diesem Fall müssen Sie die OpenTelemetry Bills of Materials importieren, indem Sie die OpenTelemetry-Dokumentation im Spring Boot Starter befolgen.

Schritt 2: Aktivieren der Selbstdiagnose

Wenn etwas nicht wie erwartet funktioniert, können Sie die Selbstdiagnose auf Ebene DEBUG aktivieren, um einige Erkenntnisse zu erhalten. Legen Sie dazu mithilfe der Umgebungsvariablen APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL die Selbstdiagnosestufe auf ERROR, WARN, INFO, DEBUG oder TRACE fest.

Führen Sie den folgenden Befehl aus, um die Selbstdiagnose auf Ebene DEBUG beim Ausführen eines Docker-Containers zu aktivieren:

docker run -e APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL=DEBUG <image-name>

Informationen zum Haftungsausschluss von Drittanbietern

Die in diesem Artikel genannten Drittanbieterprodukte stammen von Herstellern, die von Microsoft unabhängig sind. Microsoft gewährt keine implizite oder sonstige Garantie in Bezug auf die Leistung oder Zuverlässigkeit dieser Produkte.

Schritt 1: Aktivieren der Diagnoseprotokollierung

Azure Monitor Exporter verwendet die OpenTelemetry-API-Protokollierung für interne Protokolle. Führen Sie zum Aktivieren des Loggers den folgenden Codeausschnitt aus:

const { diag, DiagConsoleLogger, DiagLogLevel } = require("@opentelemetry/api");
const { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");

const provider = new NodeTracerProvider();
diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ALL);
provider.register();

Schritt 2: Testen der Konnektivität zwischen Ihrem Anwendungshost und dem Erfassungsdienst

Application Insights SDKs und -Agents senden Telemetriedaten, die als REST-Aufrufe unserer Erfassungsendpunkte erfasst werden sollen. Verwenden Sie cURL-Befehle oder unformatierte REST-Anforderungen von PowerShell, um die Konnektivität von Ihrem Webserver- oder Anwendungshostcomputer mit den Endpunkten des Aufnahmediensts zu testen. Ausführliche Informationen finden Sie unter Problembehandlung bei fehlender Anwendungstelemetrie in Azure Monitor Application Insights.

Bekannte Probleme

Die folgenden Elemente sind bekannte Probleme für die OpenTelemetry-Exporter von Azure Monitor:

• Der Vorgangsname fehlt in der Abhängigkeitstelemetrie. Der fehlende Name des Vorgangs verursacht Fehler und wirkt sich negativ auf die Leistung der Registerkartenerfahrung aus.

• Das Gerätemodell fehlt bei der Anforderungs- und Abhängigkeitstelemetrie. Das fehlende Gerätemodell wirkt sich negativ auf die Analyse der Gerätekohorten aus.

• Der Datenbankservername fehlt im Abhängigkeitsnamen. Da der Datenbankservername nicht enthalten ist, aggregieren OpenTelemetry Exporters fälschlicherweise Tabellen mit demselben Namen auf verschiedenen Servern.

Schritt 1: Aktivieren der Diagnoseprotokollierung

Microsoft Azure Monitor Exporter verwendet die Python-Standardprotokollierungsbibliothek für die interne Protokollierung. OpenTelemetry-API und Azure Monitor Exporter-Protokolle werden einem Schweregrad von WARNING oder ERROR für unregelmäßige Aktivitäten zugewiesen. Der Schweregrad INFO wird für reguläre oder erfolgreiche Aktivitäten verwendet.

Standardmäßig legt die Python-Protokollierungsbibliothek den Schweregrad auf WARNING fest. Daher müssen Sie den Schweregrad ändern, um Protokolle unter diesem Schweregrad anzuzeigen. Der folgende Beispielcode zeigt, wie Protokolle aller Schweregradstufen in die Konsole und eine Datei ausgegeben werden:

...
import logging

logging.basicConfig(format = "%(asctime)s:%(levelname)s:%(message)s", level = logging.DEBUG)

logger = logging.getLogger(__name__)
file = logging.FileHandler("example.log")
stream = logging.StreamHandler()
logger.addHandler(file)
logger.addHandler(stream)
...

Schritt 2: Testen der Konnektivität zwischen Ihrem Anwendungshost und dem Erfassungsdienst

Application Insights SDKs und -Agents senden Telemetriedaten, die als REST-Aufrufe unserer Erfassungsendpunkte erfasst werden sollen. Verwenden Sie cURL-Befehle oder unformatierte REST-Anforderungen von PowerShell, um die Konnektivität von Ihrem Webserver- oder Anwendungshostcomputer mit den Endpunkten des Aufnahmediensts zu testen. Ausführliche Informationen finden Sie unter Problembehandlung bei fehlender Anwendungstelemetrie in Azure Monitor Application Insights.

Schritt 3: Vermeiden doppelter Telemetrie

Doppelte Telemetrie wird häufig verursacht, wenn Sie mehrere Instanzen von Prozessoren oder Exportern erstellen. Stellen Sie sicher, dass Sie jeweils nur einen Exporteur und Prozessor für jede Telemetriesäule ausführen (Protokolle, Metriken und verteilte Ablaufverfolgung).

In den folgenden Abschnitten werden Szenarien beschrieben, die doppelte Telemetrie verursachen können.

Doppelte Ablaufverfolgungsprotokolle in Azure Functions

Wenn für jedes Ablaufverfolgungsprotokoll in Application Insights ein Paar Einträge angezeigt wird, haben Sie wahrscheinlich die folgenden Arten der Protokollierungsinstrumentation aktiviert:

• Die systemeigene Protokollierungsinstrumentation in Azure Functions
• Die azure-monitor-opentelemetry-Protokollierungsinstrumentation innerhalb der Verteilung

Um Duplizierungen zu verhindern, können Sie die Protokollierung der Verteilung deaktivieren, aber die systemeigene Protokollierungsinstrumentation in Azure Functions aktiviert lassen. Legen Sie dazu die Umgebungsvariable OTEL_LOGS_EXPORTER auf None fest.

Doppelte Telemetrie in Azure Functions „Always On“

Wenn die Einstellung Always On in Azure Functions auf On festgelegt ist, werden einige Prozesse nach Abschluss jeder Ausführung im Hintergrund ausgeführt. Angenommen, Sie verfügen über eine fünfminütige Timerfunktion, die jedes Mal configure_azure_monitor aufruft. Nach 20 Minuten verfügen Sie möglicherweise über vier Metrikexporteure, die gleichzeitig ausgeführt werden. Diese Situation kann die Quelle Ihrer doppelten Metrik-Telemetrie sein.

Legen Sie in diesem Fall entweder die Einstellung Always On auf Off fest, oder versuchen Sie, die Anbieter zwischen jedem configure_azure_monitor-Aufruf manuell zu beenden. Um jeden Anbieter herunterzufahren, führen Sie Herunterfahren-Aufrufe für jeden aktuellen Meter-, Tracer- und Logger-Anbieter aus, wie im folgenden Code gezeigt:

get_meter_provider().shutdown()
get_tracer_provider().shutdown()
get_logger_provider().shutdown()

Azure-Arbeitsmappen und Jupyter-Notebooks

Azure-Arbeitsmappen und Jupyter-Notebooks können Exporterprozesse im Hintergrund beibehalten. Um doppelte Telemetrie zu verhindern, löschen Sie den Cache, bevor Sie weitere Aufrufe an configure_azure_monitor tätigen.

Schritt 4: Sicherstellen, dass Flask-Anforderungsdaten gesammelt werden

Wenn Sie eine Flask-Anwendung implementieren, stellen Sie möglicherweise fest, dass Sie keine Anforderungstabellendaten aus Application Insights sammeln können, während Sie die Azure Monitor OpenTelemetry Distro-Clientbibliothek für Python verwenden. Dieses Problem kann auftreten, wenn Sie ihre import-Deklarationen nicht ordnungsgemäß strukturieren. Möglicherweise importieren Sie das flask.Flask Webanwendungsframework, bevor Sie die configure_azure_monitor-Funktion aufrufen, um die Flask-Bibliothek zu instrumentieren. Der folgende Code instrumentiert die Flask-App z. B. nicht erfolgreich:

from azure.monitor.opentelemetry import configure_azure_monitor
from flask import Flask

configure_azure_monitor()

app = Flask(__name__)

Stattdessen wird empfohlen, das flask-Modul als Ganzes zu importieren und dann configure_azure_monitor aufzurufen, um OpenTelemetry so zu konfigurieren, dass Azure Monitor verwendet wird, bevor Sie auf flask.Flask zugreifen:

from azure.monitor.opentelemetry import configure_azure_monitor
import flask

configure_azure_monitor()

app = flask.Flask(__name__)

Alternativ können Sie vor dem Import von flask.Flask configure_azure_monitor aufrufen:

from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor()

from flask import Flask

app = Flask(__name__)

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry .NET-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit Azure Monitor Exporter finden Sie auf der Issues-Seite auf GitHub.

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry .NET-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit Azure Monitor Exporter finden Sie auf der Issues-Seite auf GitHub.

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Hilfestellungen für die Problembehandlung finden Sie in den Problembehandlungsschritten.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit automatischer Azure Monitor-Java-Instrumentierung finden Sie auf der Issues-Seite auf GitHub.

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry-Community.
• Eine Liste der offenen Probleme mit systemeigenen Spring Boot-Anwendungen finden Sie auf der GitHub-Problemseite.
• Eine Liste der offenen Probleme mit systemeigenen Quarkus-Anwendungen finden Sie auf der GitHub-Problemseite.

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry JavaScript-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit Azure Monitor Exporter finden Sie auf der Issues-Seite auf GitHub.

• Bei Azure-Supportproblemen öffnen Sie ein Azure-Supportticket.
• Wenden Sie sich bei OpenTelemetry-Problemen direkt an die OpenTelemetry Python-Community.
• Eine Liste der offenen Probleme im Zusammenhang mit der Azure Monitor-Distribution finden Sie auf der Seite der GitHub-Probleme.