Azure Monitor OpenTelemetry configureren

Gebruik een van de volgende drie manieren om de verbindingsreeks te configureren:

• Toevoegen UseAzureMonitor() aan uw program.cs bestand:

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

• Stel een omgevingsvariabele in.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Voeg de volgende sectie toe aan uw appsettings.json configuratiebestand.

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

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

• Voeg de Azure Monitor Exporter toe aan elk OpenTelemetry-signaal bij het opstarten van de toepassing.

    // Create a new OpenTelemetry tracer provider.
    // It is important to keep the TracerProvider instance active throughout the process lifetime.
    var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddAzureMonitorTraceExporter(options =>
        {
            options.ConnectionString = "<Your Connection String>";
        })
        .Build();

    // Create a new OpenTelemetry meter provider.
    // It is important to keep the MetricsProvider instance active throughout the process lifetime.
    var metricsProvider = Sdk.CreateMeterProviderBuilder()
        .AddAzureMonitorMetricExporter(options =>
        {
            options.ConnectionString = "<Your Connection String>";
        })
        .Build();

    // Create a new logger factory.
    // It is important to keep the LoggerFactory instance active throughout the process lifetime.
    var loggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddOpenTelemetry(logging =>
        {
            logging.AddAzureMonitorLogExporter(options =>
            {
                options.ConnectionString = "<Your Connection String>";
            });
        });
    });

• Stel een omgevingsvariabele in.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

Zie Verbindingsreeks om de verbindingsreeks in te stellen.

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

• Stel een omgevingsvariabele in.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Stel een eigenschap in.

    applicationinsights.connection.string=<Your Connection String>

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

• Stel een omgevingsvariabele in.

APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Gebruik een configuratieobject.

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

Gebruik een van de volgende twee manieren om de verbindingsreeks te configureren:

• Stel een omgevingsvariabele in.

   APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>

• Gebruik de configure_azure_monitorfunctie.

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

Stel de naam van de cloudrol en het cloudrolexemplaar in met resourcekenmerken. Cloud-rolnaam gebruikt service.namespace en service.name attributen, hoewel het terugvalt op service.name als service.namespace niet is ingesteld. Cloud Role Instance maakt gebruik van de service.instance.id kenmerkwaarde. Zie OpenTelemetry Semantic Conventions voor informatie over standaardkenmerken voor resources.

// Setting role name and role instance

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

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

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

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

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

Stel de naam van de cloudrol en het cloudrolexemplaar in met resourcekenmerken. Cloud-rolnaam gebruikt service.namespace en service.name attributen, hoewel het terugvalt op service.name als service.namespace niet is ingesteld. Cloud Role Instance maakt gebruik van de service.instance.id kenmerkwaarde. Zie OpenTelemetry Semantic Conventions voor informatie over standaardkenmerken voor resources.

// Setting role name and role instance

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

// Create a resource builder.
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);

// Create a new OpenTelemetry tracer provider and set the resource builder.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    // Set ResourceBuilder on the TracerProvider.
    .SetResourceBuilder(resourceBuilder)
    .AddAzureMonitorTraceExporter()
    .Build();

// Create a new OpenTelemetry meter provider and set the resource builder.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
    // Set ResourceBuilder on the MeterProvider.
    .SetResourceBuilder(resourceBuilder)
    .AddAzureMonitorMetricExporter()
    .Build();

// Create a new logger factory and add the OpenTelemetry logger provider with the resource builder.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddOpenTelemetry(logging =>
    {
        // Set ResourceBuilder on the Logging config.
        logging.SetResourceBuilder(resourceBuilder);
        logging.AddAzureMonitorLogExporter();
    });
});

Als u de naam van de cloudrol wilt instellen, raadpleegt u de naam van de cloudrol.

Om het cloudrolexemplaar in te stellen, zie cloudrolexemplaar.

De naam van de cloudrol instellen:

• Gebruik de spring.application.name voor systeemeigen Spring Boot-afbeeldingsapplicaties
• Gebruik de quarkus.application.name voor Quarkus native image-applicaties

Stel de naam van de cloudrol en het cloudrolexemplaar in met resourcekenmerken. Cloud-rolnaam gebruikt service.namespace en service.name attributen, hoewel het terugvalt op service.name als service.namespace niet is ingesteld. Cloud Role Instance maakt gebruik van de service.instance.id kenmerkwaarde. Zie OpenTelemetry Semantic Conventions voor informatie over standaardkenmerken voor resources.

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

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

    const options = {
      resource: customResource,
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
    };

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

Stel de naam van de cloudrol en het cloudrolexemplaar in met resourcekenmerken. Cloud-rolnaam gebruikt service.namespace en service.name attributen, hoewel het terugvalt op service.name als service.namespace niet is ingesteld. Cloud Role Instance maakt gebruik van de service.instance.id kenmerkwaarde. Zie OpenTelemetry Semantic Conventions voor informatie over standaardkenmerken voor resources.

Stel resourcekenmerken in met behulp van de OTEL_RESOURCE_ATTRIBUTES en/of OTEL_SERVICE_NAME omgevingsvariabelen. OTEL_RESOURCE_ATTRIBUTES neemt een reeks komma-gescheiden sleutel-waardeparen. Als u bijvoorbeeld de naam van de cloudrol wilt instellen op my-namespace.my-helloworld-service en de cloudrolinstantie op my-instance, kunt u OTEL_RESOURCE_ATTRIBUTES en OTEL_SERVICE_NAME als volgt instellen:

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

Als u het service.namespace kenmerk Resource niet instelt, kunt u ook de naam van de cloudrol instellen met alleen de omgevingsvariabele OTEL_SERVICE_NAME of het service.name kenmerk Resource. Als u bijvoorbeeld de naam van de cloudrol wilt instellen op my-helloworld-service en de cloudrolinstantie op my-instance, kunt u OTEL_RESOURCE_ATTRIBUTES en OTEL_SERVICE_NAME als volgt instellen:

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

De sampler verwacht een steekproeffrequentie tussen 0 en 1. Een snelheid van 0,1 betekent dat ongeveer 10% van uw traceringen worden verzonden.

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

De sampler verwacht een steekproeffrequentie tussen 0 en 1. Een snelheid van 0,1 betekent dat ongeveer 10% van uw traceringen worden verzonden.

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

Vanaf 3.4.0 is een steekproef met frequentielimiet beschikbaar en is nu de standaardinstelling. Zie Java-steekproeven voor meer informatie over steekproeven.

Voor systeemeigen Spring Boot-toepassingen zijn de samplingconfiguraties van de OpenTelemetry Java SDK van toepassing.

Voor systeemeigen Quarkus-toepassingen configureert u steekproeven met behulp van de Quarkus OpenTelemetry-handleiding en gebruikt u vervolgens de Quarkus OpenTelemetry Exporter om telemetrie te verzenden naar Application Insights.

De sampling met snelheidslimiet is beschikbaar vanaf azure-monitor-opentelemetry-exporter versie 1.0.0-beta.32. Configureer steekproeven met behulp van de volgende omgevingsvariabelen:

• OTEL_TRACES_SAMPLER: Hiermee geeft u het type sampler op
  • microsoft.fixed.percentage voor Application Insights-sampler
  • microsoft.rate_limited voor snelheidsbeperkte bemonstering
• OTEL_TRACES_SAMPLER_ARG: Definieert de steekproeffrequentie
  • ApplicationInsightsSampler: De sampler verwacht een steekproeffrequentie tussen 0 en 1. Een snelheid van 0,1 betekent dat ongeveer 10% van uw traceringen worden verzonden.
  • RateLimitedSampler: Maximum aantal traceringen per seconde (bijvoorbeeld 0,5 = één tracering om de twee seconden, 5,0 = vijf traceringen per seconde)

Alternatieve configuratie

export class FixedRateSamplingSample {
  static async run() {
    // Dynamically import and initialize Azure Monitor with fixed-rate sampling (~10%).
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      samplingRatio: 0.1, // ~10% of traces
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (fixed-rate sampling)");
  }
}

export class RateLimitedSamplingSample {
  static async run() {
    // Dynamically import and initialize Azure Monitor with rate-limited sampling (~1.5 traces/sec).
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const options = {
      tracesPerSecond: 1.5, // ~1.5 traces per second
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
    };
    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (rate-limited sampling)");
  }
}

ApplicationInsightsSampler-voorbeeld

export OTEL_TRACES_SAMPLER="microsoft.fixed.percentage"
export OTEL_TRACES_SAMPLER_ARG=0.3

Voorbeeld van RateLimitedSampler

export OTEL_TRACES_SAMPLER="microsoft.rate_limited"
export OTEL_TRACES_SAMPLER_ARG=1.5

Snelheidsbeperkingen zijn beschikbaar vanaf azure-monitor-opentelemetry versie 1.8.0. Configureer steekproeven met behulp van de volgende omgevingsvariabelen:

• OTEL_TRACES_SAMPLER: Hiermee geeft u het type sampler op
  • microsoft.fixed.percentage voor Application Insights-sampler
  • microsoft.rate_limited voor snelheidsbeperkte bemonstering
• OTEL_TRACES_SAMPLER_ARG: Definieert de steekproeffrequentie
  • ApplicationInsightsSampler: Geldig bereik 0 tot 1 (0 = 0%, 1 = 100%)
  • RateLimitedSampler: Maximum aantal traceringen per seconde (bijvoorbeeld 0,5 = één tracering om de twee seconden, 5,0 = vijf traceringen per seconde)

Alternatieve configuratie: Gebruik de configure_azure_monitor() functie met het traces_per_second kenmerk om RateLimitedSampler in te schakelen.

ApplicationInsightsSampler-voorbeeld

export OTEL_TRACES_SAMPLER="microsoft.fixed.percentage"
export OTEL_TRACES_SAMPLER_ARG=0.1

Voorbeeld van RateLimitedSampler

export OTEL_TRACES_SAMPLER="microsoft.rate_limited"
export OTEL_TRACES_SAMPLER_ARG=0.5

Deze functie is standaard ingeschakeld.

Gebruikers kunnen Live Metrics uitschakelen bij het configureren van de distributie.

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

Deze functie is niet beschikbaar in de Azure Monitor .NET-exporteur.

De live metrics-ervaring is standaard ingeschakeld.

Zie Configuratieopties: Azure Monitor Application Insights voor Java voor meer informatie over Java-configuratie.

De Live Metrics zijn momenteel niet beschikbaar voor systeemeigen GraalVM-toepassingen.

Gebruikers kunnen Live Metrics in- of uitschakelen bij het configureren van de distributie met behulp van de enableLiveMetrics eigenschap.

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

U kunt live metrische gegevens als volgt inschakelen met behulp van de Azure Monitor OpenTelemetry Distro voor Python:

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

Zie Microsoft Entra-verificatie voor Application Insights voor meer informatie over het configureren van Entra-id-verificatie

Zie Microsoft Entra-verificatie voor Application Insights voor meer informatie over het configureren van Entra-id-verificatie

Zie Microsoft Entra-verificatie voor Application Insights voor meer informatie over het configureren van Entra-id-verificatie

Microsoft Entra ID-verificatie is niet beschikbaar voor GraalVM Native-toepassingen.

Zie Microsoft Entra-verificatie voor Application Insights voor meer informatie over het configureren van Entra-id-verificatie

Zie Microsoft Entra-verificatie voor Application Insights voor meer informatie over het configureren van Entra-id-verificatie

Het Distro-pakket bevat de AzureMonitorExporter, die standaard een van de volgende locaties gebruikt voor offlineopslag (vermeld in volgorde van prioriteit):

• Ramen
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Anders dan Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

Als u de standaardmap wilt overschrijven, moet u AzureMonitorOptions.StorageDirectory definiëren.

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

Als u deze functie wilt uitschakelen, moet u instellen AzureMonitorOptions.DisableOfflineStorage = true.

Standaard gebruikt AzureMonitorExporter een van de volgende locaties voor offlineopslag (vermeld in volgorde van prioriteit):

• Ramen
  • %LOCALAPPDATA%\Microsoft\AzureMonitor
  • %TEMP%\Microsoft\AzureMonitor
• Anders dan Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor
  • /tmp/Microsoft/AzureMonitor

Als u de standaardmap wilt overschrijven, moet u AzureMonitorExporterOptions.StorageDirectory definiëren.

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

// Create a new OpenTelemetry meter provider and set the storage directory.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
    .AddAzureMonitorMetricExporter(options =>
    {
        // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
        // This is the directory where the OpenTelemetry SDK will store any metric data that cannot be sent to Azure Monitor immediately.
        options.StorageDirectory = "C:\\SomeDirectory";
        })
        .Build();

// Create a new logger factory and add the OpenTelemetry logger provider with the storage directory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder.AddOpenTelemetry(logging =>
    {
        logging.AddAzureMonitorLogExporter(options =>
        {
            // Set the Azure Monitor storage directory to "C:\\SomeDirectory".
            // This is the directory where the OpenTelemetry SDK will store any log data that cannot be sent to Azure Monitor immediately.
            options.StorageDirectory = "C:\\SomeDirectory";
        });
    });
});

Als u deze functie wilt uitschakelen, moet u instellen AzureMonitorExporterOptions.DisableOfflineStorage = true.

Wanneer de agent geen telemetrie naar Azure Monitor kan verzenden, worden telemetriebestanden op schijf opgeslagen. De bestanden worden opgeslagen in een telemetry map onder de map die is opgegeven door de java.io.tmpdir systeemeigenschap. Elke bestandsnaam begint met een tijdstempel en eindigt met de .trn extensie. Dit offlineopslagmechanisme helpt ervoor te zorgen dat telemetrie wordt bewaard tijdens tijdelijke netwerkstoringen of opnamefouten.

De agent slaat standaard maximaal 50 MB telemetriegegevens op en staat de configuratie van de opslaglimiet toe. Pogingen om opgeslagen telemetrie te verzenden, worden periodiek uitgevoerd. Telemetriebestanden die ouder zijn dan 48 uur worden verwijderd en de oudste gebeurtenissen worden verwijderd wanneer de opslaglimiet is bereikt.

Zie Configuratieopties voor een volledige lijst met beschikbare configuraties.

Wanneer de agent geen telemetrie naar Azure Monitor kan verzenden, worden telemetriebestanden op schijf opgeslagen. De bestanden worden opgeslagen in een telemetry map onder de map die is opgegeven door de java.io.tmpdir systeemeigenschap. Elke bestandsnaam begint met een tijdstempel en eindigt met de .trn extensie. Dit offlineopslagmechanisme helpt ervoor te zorgen dat telemetrie wordt bewaard tijdens tijdelijke netwerkstoringen of opnamefouten.

De agent slaat standaard maximaal 50 MB aan telemetriegegevens op. Pogingen om opgeslagen telemetrie te verzenden, worden periodiek uitgevoerd. Telemetriebestanden die ouder zijn dan 48 uur worden verwijderd en de oudste gebeurtenissen worden verwijderd wanneer de opslaglimiet is bereikt.

AzureMonitorExporter gebruikt standaard een van de volgende locaties voor offlineopslag.

• Ramen
  • %TEMP%\Microsoft\AzureMonitor
• Anders dan Windows
  • %TMPDIR%/Microsoft/AzureMonitor
  • /var/tmp/Microsoft/AzureMonitor

Als u de standaardmap wilt overschrijven, moet u storageDirectory definiëren.

Voorbeeld:

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

Als u deze functie wilt uitschakelen, moet u instellen disableOfflineStorage = true.

Azure Monitor-exporteurs gebruiken standaard het volgende pad:

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

Als u de standaardmap wilt overschrijven, moet u storage_directory instellen op de map die u wilt.

Voorbeeld:

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

Als u deze functie wilt uitschakelen, moet u disable_offline_storage instellen op True. Standaardwaarde is False.

Voorbeeld:

...
# 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. Installeer het pakket OpenTelemetry.Exporter.OpenTelemetryProtocol in uw project.

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

1. Voeg het volgende codefragment toe. In dit voorbeeld wordt ervan uitgegaan dat u een OpenTelemetry Collector hebt met een OTLP-ontvanger die actief is. Zie het voorbeeld op GitHub voor meer informatie.

// 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. Installeer het pakket OpenTelemetry.Exporter.OpenTelemetryProtocol in uw project.

    dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

1. Voeg het volgende codefragment toe. In dit voorbeeld wordt ervan uitgegaan dat u een OpenTelemetry Collector hebt met een OTLP-ontvanger die actief is. Zie het voorbeeld op GitHub voor meer informatie.

    // Create a new OpenTelemetry tracer provider and add the Azure Monitor trace exporter and the OTLP trace exporter.
    // It is important to keep the TracerProvider instance active throughout the process lifetime.
    var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddAzureMonitorTraceExporter()
        .AddOtlpExporter()
        .Build();

    // Create a new OpenTelemetry meter provider and add the Azure Monitor metric exporter and the OTLP metric exporter.
    // It is important to keep the MetricsProvider instance active throughout the process lifetime.
    var metricsProvider = Sdk.CreateMeterProviderBuilder()
        .AddAzureMonitorMetricExporter()
        .AddOtlpExporter()
        .Build();

De Java-agent van Application Insights biedt geen ondersteuning voor OTLP. Zie de aanvullende Java-documentatie voor meer informatie over ondersteunde configuraties.

U kunt de OTLP-exporteur (OpenTelemetry Protocol) niet inschakelen naast de Azure Monitor-exporteur om uw telemetrie naar twee locaties te verzenden.

1. Installeer de OpenTelemetry Collector Trace Exporter en andere OpenTelemetry-pakketten in uw project.

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

1. Voeg het volgende codefragment toe. In dit voorbeeld wordt ervan uitgegaan dat u een OpenTelemetry Collector hebt met een OTLP-ontvanger die actief is. Zie het voorbeeld op GitHub voor meer informatie.

export class OtlpExporterSample {
  static async run() {
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { BatchSpanProcessor } = await import("@opentelemetry/sdk-trace-base");
    const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");

    // Create an OTLP trace exporter (set 'url' if your collector isn't on the default endpoint).
    const otlpExporter = new OTLPTraceExporter({
      // url: "http://localhost:4318/v1/traces",
    });

    // Configure Azure Monitor and add the OTLP exporter as an additional span processor.
    const options = {
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
      },
      spanProcessors: [new BatchSpanProcessor(otlpExporter)],
    };

    const monitor = useAzureMonitor(options);
    console.log("Azure Monitor initialized (OTLP exporter added)");
  }
}

1. Installeer het openelemetry-exporter-otlp-pakket .

2. Voeg het volgende codefragment toe. In dit voorbeeld wordt ervan uitgegaan dat u een OpenTelemetry Collector hebt met een OTLP-ontvanger die actief is. Zie deze LEESMIJ voor meer informatie.

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

Zie de aanvullende Java-documentatie voor meer informatie over Java.

Voor systeemeigen Spring Boot-toepassingen zijn de OpenTelemetry Java SDK-configuraties beschikbaar.

Raadpleeg de documentatie over Quarkus OpenTelemetry voor systeemeigen toepassingen voor Quarkus.

Zie de documentatie over OpenTelemetry SDK voor meer informatie over de configuratie van de OpenTelemetry-SDK.

Zie de OpenTelemetry SDK-documentatie en het Gebruik van Azure Monitor Distro voor meer informatie over de configuratie van de OpenTelemetry SDK.

Wanneer u het distro-pakket Azure.Monitor.OpenTelemetry.AspNetCore gebruikt, worden de instrumentatiebibliotheken voor zowel ASP.NET Core als HttpClient opgenomen. De standaardinstelling van ons distributiepakket schakelt de anonimisering van queryreeksen uit.

Als u dit gedrag wilt wijzigen, moet u een omgevingsvariabele instellen op of truefalse.

• ASP.NET Core Instrumentation: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION Query String Redaction is standaard uitgeschakeld. Als u deze omgevingsvariabele wilt inschakelen, stelt u deze omgevingsvariabele in op false.
• Http Client Instrumentation: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION Query String Redaction is standaard uitgeschakeld. Als u deze omgevingsvariabele wilt inschakelen, stelt u deze omgevingsvariabele in op false.

Wanneer u azure.Monitor.OpenTelemetry.Exporter gebruikt, moet u handmatig de ASP.NET Core- of HttpClient Instrumentation-bibliotheken opnemen in uw OpenTelemetry-configuratie. Voor deze instrumentatiebibliotheken is QueryString Redaction standaard ingeschakeld.

Als u dit gedrag wilt wijzigen, moet u een omgevingsvariabele instellen op of truefalse.

• ASP.NET Core Instrumentation: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION Redaction van queryreeks is standaard ingeschakeld. Als u wilt uitschakelen, stelt u deze omgevingsvariabele in op true.
• Http Client Instrumentation: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION Query String Redaction is standaard ingeschakeld. Als u wilt uitschakelen, stelt u deze omgevingsvariabele in op true.

Voeg het volgende toe aan het applicationinsights.json configuratiebestand:

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

We werken actief in de OpenTelemetry-community om ondersteuning te bieden voor redaction.

Wanneer u het Azure Monitor OpenTelemetry-distributiepakket gebruikt, kunnen querystrings worden geredigeerd door het maken en toepassen van een spanprocessor op de distributieconfiguratie.

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

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

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

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

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

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

We werken actief in de OpenTelemetry-community om ondersteuning te bieden voor redaction.