Aggiungere e modificare Monitoraggio di Azure OpenTelemetry per applicazioni .NET, Java, Node.jse Python

Per aggiungere una libreria della community, usare i metodi ConfigureOpenTelemetryMeterProvider o ConfigureOpenTelemetryTracerProvider dopo aver aggiunto il pacchetto NuGet per la libreria.

L'esempio seguente illustra come aggiungere la strumentazione runtime per raccogliere metriche aggiuntive:

dotnet add package OpenTelemetry.Instrumentation.Runtime

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

// Configure the OpenTelemetry meter provider to add runtime instrumentation.
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddRuntimeInstrumentation());

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

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

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

L'esempio seguente illustra come aggiungere la strumentazione runtime per raccogliere metriche aggiuntive:

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

Non è possibile estendere l'agente Java con librerie di strumentazione della community. Per richiedere l'inserimento di altre librerie di strumentazione, aprire un problema nella pagina GitHub.

Non è possibile usare librerie di strumentazione della comunità con applicazioni native Java di GraalVM.

export class RegisterExpressInstrumentationSample {
  static async run() {
	// Dynamically import Azure Monitor and Express instrumentation
	const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
	const { registerInstrumentations } = await import("@opentelemetry/instrumentation");
	const { ExpressInstrumentation } = await import("@opentelemetry/instrumentation-express");

	// Initialize Azure Monitor (uses env var if set)
	const monitor = useAzureMonitor();

	// Register the Express instrumentation
	registerInstrumentations({
	  instrumentations: [new ExpressInstrumentation()],
	});

	console.log("Express instrumentation registered");
  }
}

Per aggiungere una libreria di strumentazioni della community, instrumentare direttamente con le strumentazioni. È possibile trovare l'elenco delle librerie di strumentazione della community in GitHub.

# Import the `configure_azure_monitor()`, `SQLAlchemyInstrumentor`, `create_engine`, and `text` functions from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
from sqlalchemy import create_engine, text

# Configure OpenTelemetry to use Azure Monitor.
configure_azure_monitor()

# Create a SQLAlchemy engine.
engine = create_engine("sqlite:///:memory:")

# SQLAlchemy instrumentation is not officially supported by this package, however, you can use the OpenTelemetry `instrument()` method manually in conjunction with `configure_azure_monitor()`.
SQLAlchemyInstrumentor().instrument(
	engine=engine,
)

# Database calls using the SQLAlchemy library will be automatically captured.
with engine.connect() as conn:
	result = conn.execute(text("select 'hello world'"))
	print(result.all())

L'avvio dell'applicazione deve sottoscrivere un contatore in base al nome:

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

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

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

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

Meter deve essere inizializzato utilizzando lo stesso nome:

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new histogram metric named "FruitSalePrice".
Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

// Create a new Random object.
var rand = new Random();

// Record a few random sale prices for apples and lemons, with different colors.
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "green"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));

public class Program
{
    // Create a static readonly Meter object named "OTel.AzureMonitor.Demo".
    // This meter will be used to track metrics about the application.
    private static readonly Meter meter = new("OTel.AzureMonitor.Demo");

    public static void Main()
    {
        // Create a new MeterProvider object using the OpenTelemetry SDK.
        // The MeterProvider object is responsible for managing meters and sending
        // metric data to exporters.
        // It is important to keep the MetricsProvider instance active
        // throughout the process lifetime.
        //
        // The MeterProviderBuilder is configured to add a meter named
        // "OTel.AzureMonitor.Demo" and an Azure Monitor metric exporter.
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter()
            .Build();

        // Create a new Histogram metric named "FruitSalePrice".
        // This metric will track the distribution of fruit sale prices.
        Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

        // Create a new Random object. This object will be used to generate random sale prices.
        var rand = new Random();

        // Record a few random sale prices for apples and lemons, with different colors.
        // Each record includes a timestamp, a value, and a set of attributes.
        // The attributes can be used to filter and analyze the metric data.
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "green"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
        myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));

        // Display a message to the user and wait for them to press Enter.
        // This allows the user to see the message and the console before the
        // application exits.
        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.DoubleHistogram;
import io.opentelemetry.api.metrics.Meter;

public class Program {

    public static void main(String[] args) {
        Meter meter = GlobalOpenTelemetry.getMeter("OTEL.AzureMonitor.Demo");
        DoubleHistogram histogram = meter.histogramBuilder("histogram").build();
        histogram.record(1.0);
        histogram.record(100.0);
        histogram.record(30.0);
    }
}

1. Inserimento di OpenTelemetry:

   • Primavera

     import io.opentelemetry.api.OpenTelemetry;
     
     @Autowired
     OpenTelemetry openTelemetry;
     

   • Quarkus

     import io.opentelemetry.api.OpenTelemetry;
     
     @Inject
     OpenTelemetry openTelemetry;
     

2. Creare un istogramma:

   import io.opentelemetry.api.metrics.DoubleHistogram;
   import io.opentelemetry.api.metrics.Meter;
   
   Meter meter = openTelemetry.getMeter("OTEL.AzureMonitor.Demo");
   DoubleHistogram histogram = meter.histogramBuilder("histogram").build();
   histogram.record(1.0);
   histogram.record(100.0);
   histogram.record(30.0);
   

export class HistogramSample {
  static async run() {
    // Dynamically import Azure Monitor and metrics API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { metrics } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor({
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
    });

    // Create a histogram and record values
    const meter = metrics.getMeter("testMeter");
    const histogram = meter.createHistogram("histogram");

    histogram.record(1, { testKey: "testValue" });
    histogram.record(30, { testKey: "testValue2" });
    histogram.record(100, { testKey2: "testValue" });

    console.log("Histogram metrics recorded");
  }
}

# Import the `configure_azure_monitor()` and `metrics` functions from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import metrics

import os

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

# Opt in to allow grouping of your metrics via a custom metrics namespace in app insights metrics explorer.
# Specify the namespace name using get_meter("namespace-name")
os.environ["APPLICATIONINSIGHTS_METRIC_NAMESPACE_OPT_IN"] = "true"

# Get a meter provider and a meter with the name "otel_azure_monitor_histogram_demo".
meter = metrics.get_meter_provider().get_meter("otel_azure_monitor_histogram_demo")

# Record three values to the histogram.
histogram = meter.create_histogram("histogram")
histogram.record(1.0, {"test_key": "test_value"})
histogram.record(100.0, {"test_key2": "test_value"})
histogram.record(30.0, {"test_key": "test_value2"})

# Wait for background execution.
input()

L'avvio dell'applicazione deve sottoscrivere un contatore in base al nome:

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

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

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

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

Meter deve essere inizializzato utilizzando lo stesso nome:

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new counter metric named "MyFruitCounter".
Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

// Record the number of fruits sold, grouped by name and color.
myFruitCounter.Add(1, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(2, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(1, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(2, new("name", "apple"), new("color", "green"));
myFruitCounter.Add(5, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(4, new("name", "lemon"), new("color", "yellow"));

public class Program
{
    // Create a static readonly Meter object named "OTel.AzureMonitor.Demo".
    // This meter will be used to track metrics about the application.
    private static readonly Meter meter = new("OTel.AzureMonitor.Demo");

    public static void Main()
    {
        // Create a new MeterProvider object using the OpenTelemetry SDK.
        // The MeterProvider object is responsible for managing meters and sending
        // metric data to exporters.
        // It is important to keep the MetricsProvider instance active
        // throughout the process lifetime.
        //
        // The MeterProviderBuilder is configured to add a meter named
        // "OTel.AzureMonitor.Demo" and an Azure Monitor metric exporter.
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter()
            .Build();

        // Create a new counter metric named "MyFruitCounter".
        // This metric will track the number of fruits sold.
        Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

        // Record the number of fruits sold, grouped by name and color.
        myFruitCounter.Add(1, new("name", "apple"), new("color", "red"));
        myFruitCounter.Add(2, new("name", "lemon"), new("color", "yellow"));
        myFruitCounter.Add(1, new("name", "lemon"), new("color", "yellow"));
        myFruitCounter.Add(2, new("name", "apple"), new("color", "green"));
        myFruitCounter.Add(5, new("name", "apple"), new("color", "red"));
        myFruitCounter.Add(4, new("name", "lemon"), new("color", "yellow"));

        // Display a message to the user and wait for them to press Enter.
        // This allows the user to see the message and the console before the
        // application exits.
        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;

public class Program {

    public static void main(String[] args) {
        Meter meter = GlobalOpenTelemetry.getMeter("OTEL.AzureMonitor.Demo");

        LongCounter myFruitCounter = meter
                .counterBuilder("MyFruitCounter")
                .build();

        myFruitCounter.add(1, Attributes.of(AttributeKey.stringKey("name"), "apple", AttributeKey.stringKey("color"), "red"));
        myFruitCounter.add(2, Attributes.of(AttributeKey.stringKey("name"), "lemon", AttributeKey.stringKey("color"), "yellow"));
        myFruitCounter.add(1, Attributes.of(AttributeKey.stringKey("name"), "lemon", AttributeKey.stringKey("color"), "yellow"));
        myFruitCounter.add(2, Attributes.of(AttributeKey.stringKey("name"), "apple", AttributeKey.stringKey("color"), "green"));
        myFruitCounter.add(5, Attributes.of(AttributeKey.stringKey("name"), "apple", AttributeKey.stringKey("color"), "red"));
        myFruitCounter.add(4, Attributes.of(AttributeKey.stringKey("name"), "lemon", AttributeKey.stringKey("color"), "yellow"));
    }
}

1. Inserimento di OpenTelemetry:

   • Primavera

     import io.opentelemetry.api.OpenTelemetry;
     
     @Autowired
     OpenTelemetry openTelemetry;
     

   • Quarkus

     import io.opentelemetry.api.OpenTelemetry;
     
     @Inject
     OpenTelemetry openTelemetry;
     

2. Creare il contatore:

   import io.opentelemetry.api.common.AttributeKey;
   import io.opentelemetry.api.common.Attributes;
   import io.opentelemetry.api.metrics.LongCounter;
   import io.opentelemetry.api.metrics.Meter;
   
   Meter meter = openTelemetry.getMeter("OTEL.AzureMonitor.Demo");
   
   LongCounter myFruitCounter = meter.counterBuilder("MyFruitCounter")
                                     .build();
   
   myFruitCounter.add(1, Attributes.of(AttributeKey.stringKey("name"), "apple", AttributeKey.stringKey("color"), "red"));
   myFruitCounter.add(2, Attributes.of(AttributeKey.stringKey("name"), "lemon", AttributeKey.stringKey("color"), "yellow"));
   myFruitCounter.add(1, Attributes.of(AttributeKey.stringKey("name"), "lemon", AttributeKey.stringKey("color"), "yellow"));
   myFruitCounter.add(2, Attributes.of(AttributeKey.stringKey("name"), "apple", AttributeKey.stringKey("color"), "green"));
   myFruitCounter.add(5, Attributes.of(AttributeKey.stringKey("name"), "apple", AttributeKey.stringKey("color"), "red"));
   myFruitCounter.add(4, Attributes.of(AttributeKey.stringKey("name"), "lemon", AttributeKey.stringKey("color"), "yellow"));
   

export class CounterSample {
  static async run() {
    // Dynamically import Azure Monitor and metrics API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { metrics } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor({
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
    });

    // Create a counter and add some sample values
    const meter = metrics.getMeter("otel_azure_monitor_counter_demo");
    const counter = meter.createCounter("MyFruitCounter");

    counter.add(1, { name: "apple", color: "red" });
    counter.add(2, { name: "lemon", color: "yellow" });
    counter.add(1, { name: "lemon", color: "yellow" });
    counter.add(2, { name: "apple", color: "green" });
    counter.add(5, { name: "apple", color: "red" });
    counter.add(4, { name: "lemon", color: "yellow" });

    console.log("Counter metrics recorded");
  }
}

# Import the `configure_azure_monitor()` and `metrics` functions from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import metrics

import os

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

# Opt in to allow grouping of your metrics via a custom metrics namespace in app insights metrics explorer.
# Specify the namespace name using get_meter("namespace-name")
os.environ["APPLICATIONINSIGHTS_METRIC_NAMESPACE_OPT_IN"] = "true"

# Get a meter provider and a meter with the name "otel_azure_monitor_counter_demo".
meter = metrics.get_meter_provider().get_meter("otel_azure_monitor_counter_demo")

# Create a counter metric with the name "counter".
counter = meter.create_counter("counter")

# Add three values to the counter.
# The first argument to the `add()` method is the value to add.
# The second argument is a dictionary of dimensions.
# Dimensions are used to group related metrics together.
counter.add(1.0, {"test_key": "test_value"})
counter.add(5.0, {"test_key2": "test_value"})
counter.add(3.0, {"test_key": "test_value2"})

# Wait for background execution.
input()

L'avvio dell'applicazione deve sottoscrivere un contatore in base al nome:

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

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

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

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

Meter deve essere inizializzato utilizzando lo stesso nome:

// Get the current process.
var process = Process.GetCurrentProcess();

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new observable gauge metric named "Thread.State".
// This metric will track the state of each thread in the current process.
ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

private static IEnumerable<Measurement<int>> GetThreadState(Process process)
{
    // Iterate over all threads in the current process.
    foreach (ProcessThread thread in process.Threads)
    {
        // Create a measurement for each thread, including the thread state, process ID, and thread ID.
        yield return new((int)thread.ThreadState, new("ProcessId", process.Id), new("ThreadId", thread.Id));
    }
}

public class Program
{
    // Create a static readonly Meter object named "OTel.AzureMonitor.Demo".
    // This meter will be used to track metrics about the application.
    private static readonly Meter meter = new("OTel.AzureMonitor.Demo");

    public static void Main()
    {
        // Create a new MeterProvider object using the OpenTelemetry SDK.
        // The MeterProvider object is responsible for managing meters and sending
        // metric data to exporters.
        // It is important to keep the MetricsProvider instance active
        // throughout the process lifetime.
        //
        // The MeterProviderBuilder is configured to add a meter named
        // "OTel.AzureMonitor.Demo" and an Azure Monitor metric exporter.
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter()
            .Build();

        // Get the current process.
        var process = Process.GetCurrentProcess();

        // Create a new observable gauge metric named "Thread.State".
        // This metric will track the state of each thread in the current process.
        ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

        // Display a message to the user and wait for them to press Enter.
        // This allows the user to see the message and the console before the
        // application exits.
        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }

    private static IEnumerable<Measurement<int>> GetThreadState(Process process)
    {
        // Iterate over all threads in the current process.
        foreach (ProcessThread thread in process.Threads)
        {
            // Create a measurement for each thread, including the thread state, process ID, and thread ID.
            yield return new((int)thread.ThreadState, new("ProcessId", process.Id), new("ThreadId", thread.Id));
        }
    }
}

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.Meter;

public class Program {

    public static void main(String[] args) {
        Meter meter = GlobalOpenTelemetry.getMeter("OTEL.AzureMonitor.Demo");

        meter.gaugeBuilder("gauge")
                .buildWithCallback(
                        observableMeasurement -> {
                            double randomNumber = Math.floor(Math.random() * 100);
                            observableMeasurement.record(randomNumber, Attributes.of(AttributeKey.stringKey("testKey"), "testValue"));
                        });
    }
}

1. Inserimento di OpenTelemetry:

   • Primavera

     import io.opentelemetry.api.OpenTelemetry;
     
     @Autowired
     OpenTelemetry openTelemetry;
     

   • Quarkus

     import io.opentelemetry.api.OpenTelemetry;
     
     @Inject
     OpenTelemetry openTelemetry;
     

2. Creare un misuratore:

   import io.opentelemetry.api.common.AttributeKey;
   import io.opentelemetry.api.common.Attributes;
   import io.opentelemetry.api.metrics.Meter;
   
   Meter meter = openTelemetry.getMeter("OTEL.AzureMonitor.Demo");
   
   meter.gaugeBuilder("gauge")
        .buildWithCallback(
               observableMeasurement -> {
                   double randomNumber = Math.floor(Math.random() * 100);
                   observableMeasurement.record(randomNumber, Attributes.of(AttributeKey.stringKey("testKey"), "testValue"));
               });
   

export class GaugeSample {
  static async run() {
    // Dynamically import Azure Monitor and metrics API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { metrics } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor({
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
    });

    // Create an observable gauge and register a callback
    const meter = metrics.getMeter("testMeter");
    const gauge = meter.createObservableGauge("gauge");

    gauge.addCallback((observableResult) => {
      const randomNumber = Math.floor(Math.random() * 100);
      observableResult.observe(randomNumber, { testKey: "testValue" });
    });

    console.log("Observable gauge registered");
  }
}

# Import the necessary packages.
from typing import Iterable
import os

from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import metrics
from opentelemetry.metrics import CallbackOptions, Observation

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

# Opt in to allow grouping of your metrics via a custom metrics namespace in app insights metrics explorer.
# Specify the namespace name using get_meter("namespace-name")
os.environ["APPLICATIONINSIGHTS_METRIC_NAMESPACE_OPT_IN"] = "true"

# Get a meter provider and a meter with the name "otel_azure_monitor_gauge_demo".
meter = metrics.get_meter_provider().get_meter("otel_azure_monitor_gauge_demo")

# Define two observable gauge generators.
# The first generator yields a single observation with the value 9.
# The second generator yields a sequence of 10 observations with the value 9 and a different dimension value for each observation.
def observable_gauge_generator(options: CallbackOptions) -> Iterable[Observation]:
    yield Observation(9, {"test_key": "test_value"})

def observable_gauge_sequence(options: CallbackOptions) -> Iterable[Observation]:
    observations = []
    for i in range(10):
        observations.append(
            Observation(9, {"test_key": i})
        )
    return observations

# Create two observable gauges using the defined generators.
gauge = meter.create_observable_gauge("gauge", [observable_gauge_generator])
gauge2 = meter.create_observable_gauge("gauge2", [observable_gauge_sequence])

# Wait for background execution.
input()

• Per registrare un'eccezione usando un'attività:

  // Start a new activity named "ExceptionExample".
  using (var activity = activitySource.StartActivity("ExceptionExample"))
  {
      // Try to execute some code.
      try
      {
          throw new Exception("Test exception");
      }
      // If an exception is thrown, catch it and set the activity status to "Error".
      catch (Exception ex)
      {
          activity?.SetStatus(ActivityStatusCode.Error);
          activity?.RecordException(ex);
      }
  }
  

• Per registrare un'eccezione usando ILogger:

  // Create a logger using the logger factory. The logger category name is used to filter and route log messages.
  var logger = loggerFactory.CreateLogger(logCategoryName);
  
  // Try to execute some code.
  try
  {
      throw new Exception("Test Exception");
  }
  catch (Exception ex)
  {
      // Log an error message with the exception. The log level is set to "Error" and the event ID is set to 0.
      // The log message includes a template and a parameter. The template will be replaced with the value of the parameter when the log message is written.
      logger.Log(
          logLevel: LogLevel.Error,
          eventId: 0,
          exception: ex,
          message: "Hello {name}.",
          args: new object[] { "World" });
  }
  

• Per registrare un'eccezione usando un'attività:

  // Start a new activity named "ExceptionExample".
  using (var activity = activitySource.StartActivity("ExceptionExample"))
  {
      // Try to execute some code.
      try
      {
          throw new Exception("Test exception");
      }
      // If an exception is thrown, catch it and set the activity status to "Error".
      catch (Exception ex)
      {
          activity?.SetStatus(ActivityStatusCode.Error);
          activity?.RecordException(ex);
      }
  }
  

• Per registrare un'eccezione usando ILogger:

  // Create a logger using the logger factory. The logger category name is used to filter and route log messages.
  var logger = loggerFactory.CreateLogger("ExceptionExample");
  
  try
  {
      // Try to execute some code.
      throw new Exception("Test Exception");
  }
  catch (Exception ex)
  {
      // Log an error message with the exception. The log level is set to "Error" and the event ID is set to 0.
      // The log message includes a template and a parameter. The template will be replaced with the value of the parameter when the log message is written.
      logger.Log(
          logLevel: LogLevel.Error,
          eventId: 0,
          exception: ex,
          message: "Hello {name}.",
          args: new object[] { "World" });
  }
  

È possibile usare opentelemetry-api per aggiornare lo stato di un intervallo e registrare le eccezioni.

1. Aggiungere opentelemetry-api-1.0.0.jar (o versione successiva) all'applicazione:

   <dependency>
     <groupId>io.opentelemetry</groupId>
     <artifactId>opentelemetry-api</artifactId>
     <version>1.0.0</version>
   </dependency>
   

2. Impostare lo stato su error e registrare un'eccezione nel codice:

    import io.opentelemetry.api.trace.Span;
    import io.opentelemetry.api.trace.StatusCode;
   
    Span span = Span.current();
    span.setStatus(StatusCode.ERROR, "errorMessage");
    span.recordException(e);
   

Impostare lo stato su error e registrare un'eccezione nel codice:

import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.StatusCode;

Span span = Span.current();
span.setStatus(StatusCode.ERROR, "errorMessage");
span.recordException(e);

L'SDK di Node.js esporta eccezioni basate su intervalli registrati manualmente in Application Insights come eccezioni solo se registrate in un intervallo di livello superiore o figlio di un intervallo remoto o interno.

export class CustomExceptionSample {
  static async run() {
    // Dynamically import Azure Monitor and tracing API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { trace } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor({
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
    });

    // Create a span and record an exception
    const tracer = trace.getTracer("testTracer");
    const span = tracer.startSpan("hello");

    try {
      throw new Error("Test Error");
    } catch (error) {
      span.recordException(error as Error);
    } finally {
      span.end();
    }

    console.log("Exception recorded on span");
  }
}

OpenTelemetry Python SDK viene implementato in modo che le eccezioni generate vengano acquisite e registrate automaticamente. Vedere il codice di esempio seguente per un esempio di questo comportamento:

# Import the necessary packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace

# 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 a tracer for the current module.
tracer = trace.get_tracer("otel_azure_monitor_exception_demo")

# Exception events
try:
    # Start a new span with the name "hello".
    with tracer.start_as_current_span("hello") as span:
        # This exception will be automatically recorded
        raise Exception("Custom exception message.")
except Exception:
    print("Exception raised")

Se si desidera registrare manualmente le eccezioni, è possibile disabilitare tale opzione all'interno del gestore del contesto e usare record_exception() direttamente, come illustrato nell'esempio seguente:

...
# Start a new span with the name "hello" and disable exception recording.
with tracer.start_as_current_span("hello", record_exception=False) as span:
    try:
        # Raise an exception.
        raise Exception("Custom exception message.")
    except Exception as ex:
        # Manually record exception
        span.record_exception(ex)
...

// Define an activity source named "ActivitySourceName". This activity source will be used to create activities for all requests to the application.
internal static readonly ActivitySource activitySource = new("ActivitySourceName");

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

// Configure the OpenTelemetry tracer provider to add a source named "ActivitySourceName". This will ensure that all activities created by the activity source are traced.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

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

// Map a GET request to the root path ("/") to the specified action.
app.MapGet("/", () =>
{
    // Start a new activity named "CustomActivity". This activity will be traced and the trace data will be sent to Azure Monitor.
    using (var activity = activitySource.StartActivity("CustomActivity"))
    {
        // your code here
    }

    // Return a response message.
    return $"Hello World!";
});

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

StartActivity per impostazione predefinita è ActivityKind.Internal, ma è possibile specificare qualsiasi altro ActivityKind. ActivityKind.Client, ActivityKind.Producer e ActivityKind.Internal vengono mappati a dependencies Application Insights. ActivityKind.Server e ActivityKind.Consumer vengono mappati ad Application Insights requests.

// Create an OpenTelemetry tracer provider builder.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("ActivitySourceName")
        .AddAzureMonitorTraceExporter()
        .Build();

// Create an activity source named "ActivitySourceName".
var activitySource = new ActivitySource("ActivitySourceName");

// Start a new activity named "CustomActivity". This activity will be traced and the trace data will be sent to Azure Monitor.
using (var activity = activitySource.StartActivity("CustomActivity"))
{
    // your code here
}

StartActivity per impostazione predefinita è ActivityKind.Internal, ma è possibile specificare qualsiasi altro ActivityKind. ActivityKind.Client, ActivityKind.Producer e ActivityKind.Internal vengono mappati a dependencies Application Insights. ActivityKind.Server e ActivityKind.Consumer vengono mappati ad Application Insights requests.

• Usare l'annotazione OpenTelemetry

  Il modo più semplice per aggiungere intervalli personalizzati consiste nell'usare l'annotazione @WithSpan OpenTelemetry.

  Gli intervalli popolano le tabelle requests e dependencies in Application Insights.

  1. Aggiungere opentelemetry-instrumentation-annotations-1.32.0.jar (o versione successiva) all'applicazione:

     <dependency>
         <groupId>io.opentelemetry.instrumentation</groupId>
         <artifactId>opentelemetry-instrumentation-annotations</artifactId>
         <version>1.32.0</version>
     </dependency>
     

  2. Usare l'annotazione @WithSpan per generare un intervallo ogni volta che viene eseguito il metodo:

     import io.opentelemetry.instrumentation.annotations.WithSpan;
     
     @WithSpan(value = "your span name")
     public void yourMethod() {
     }
     

  Per impostazione predefinita, l'intervallo finisce nella tabella dependencies con il tipo di dipendenza InProc.

  Per i metodi che rappresentano un processo in background non acquisito dalla strumentazione automatica, è consigliabile applicare l'attributo kind = SpanKind.SERVER all'annotazione @WithSpan per assicurarsi che vengano visualizzati nella tabella requests di Application Insights.

• Usare l'API OpenTelemetry

  Se l'annotazione OpenTelemetry @WithSpan precedente non soddisfa le proprie esigenze, è possibile aggiungere gli intervalli usando l'API OpenTelemetry.

  1. Aggiungere opentelemetry-api-1.0.0.jar (o versione successiva) all'applicazione:

     <dependency>
         <groupId>io.opentelemetry</groupId>
         <artifactId>opentelemetry-api</artifactId>
         <version>1.0.0</version>
     </dependency>
     

  2. Usare la classe GlobalOpenTelemetry per creare un Tracer:

     import io.opentelemetry.api.GlobalOpenTelemetry;
     import io.opentelemetry.api.trace.Tracer;
     
     static final Tracer tracer = GlobalOpenTelemetry.getTracer("com.example");
     

  3. Creare un intervallo, impostarlo come corrente e quindi terminarlo:

     Span span = tracer.spanBuilder("my first span").startSpan();
     try (Scope ignored = span.makeCurrent()) {
         // do stuff within the context of this
     } catch (Throwable t) {
         span.recordException(t);
     } finally {
         span.end();
     }
     

1. Inserimento di OpenTelemetry:

   • Primavera

     import io.opentelemetry.api.OpenTelemetry;
     
     @Autowired
     OpenTelemetry openTelemetry;
     

   • Quarkus

     import io.opentelemetry.api.OpenTelemetry;
     
     @Inject
     OpenTelemetry openTelemetry;
     

2. Creare un Tracer:

   import io.opentelemetry.api.trace.Tracer;
   
   static final Tracer tracer = openTelemetry.getTracer("com.example");
   

3. Creare un intervallo, impostarlo come corrente e quindi terminarlo:

   Span span = tracer.spanBuilder("my first span").startSpan();
   try (Scope ignored = span.makeCurrent()) {
       // do stuff within the context of this
   } catch (Throwable t) {
       span.recordException(t);
   } finally {
       span.end();
   }
   

export class CustomTraceSample {
  static async run() {
    // Dynamically import Azure Monitor and tracing API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { trace } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor({
      azureMonitorExporterOptions: {
        connectionString:
          process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
      },
    });

    // Create a custom span, add attributes/events, then end
    const tracer = trace.getTracer("otel_azure_monitor_custom_trace_demo");
    const span = tracer.startSpan("doWork");

    try {
      span.setAttribute("component", "worker");
      span.setAttribute("operation.id", "42");
      span.addEvent("invoking doWork");

      for (let i = 0; i < 1_000_000; i++) { /* simulate work */ }
    } catch (err) {
      span.recordException(err as Error);
    } finally {
      span.end();
    }

    console.log("Custom span recorded");
  }
}

L'API OpenTelemetry può essere usata per aggiungere intervalli personalizzati, visualizzati nelle tabelle requests e dependencies in Application Insights.

Nell'esempio di codice viene illustrato come usare il metodo tracer.start_as_current_span() per iniziare, impostare l'intervallo corrente e terminare l'intervallo all'interno del relativo contesto.

...
# Import the necessary packages.
from opentelemetry import trace

# Get a tracer for the current module.
tracer = trace.get_tracer(__name__)

# Start a new span with the name "my first span" and make it the current span.
# The "with" context manager starts, makes the span current, and ends the span within it's context
with tracer.start_as_current_span("my first span") as span:
    try:
        # Do stuff within the context of this span.
        # All telemetry generated within this scope will be attributed to this span.
    except Exception as ex:
        # Record the exception on the span.
        span.record_exception(ex)
...

Per impostazione predefinita, l'intervallo si trova nella tabella dependencies con un tipo di dipendenza InProc.

Se il metodo rappresenta un processo in background non ancora acquisito dalla strumentazione automatica, è consigliabile impostare l'attributo kind = SpanKind.SERVER per assicurarsi che venga visualizzato nella tabella requests di Application Insights.

...
# Import the necessary packages.
from opentelemetry import trace
from opentelemetry.trace import SpanKind

# Get a tracer for the current module.
tracer = trace.get_tracer(__name__)

# Start a new span with the name "my request span" and the kind set to SpanKind.SERVER.
with tracer.start_as_current_span("my request span", kind=SpanKind.SERVER) as span:
    # Do stuff within the context of this span.
...

Gli eventi personalizzati usano Azure.Monitor.OpenTelemetry.AspNetCore.

Per inviare un CustomEvent utilizzando ILogger, impostare l'attributo "microsoft.custom_event.name" nel modello di messaggio.

// Create a logger factory and configure OpenTelemetry with Azure Monitor
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddOpenTelemetry(options =>
        {
            options.AddAzureMonitorLogExporter();
        });
});

// Create a logger for the specified category
var logger = loggerFactory.CreateLogger(logCategoryName);

// Log a custom event with a custom name and additional attribute
// The 'microsoft.custom_event.name' value will be used as the name of the customEvent
logger.LogInformation("{microsoft.custom_event.name} {additional_attrs}", "test-event-name", "val1");

Gli eventi personalizzati usano Azure.Monitor.OpenTelemetry.Exporter.

Per inviare un CustomEvent utilizzando ILogger, impostare l'attributo "microsoft.custom_event.name" nel modello di messaggio.

// Create a logger factory and configure OpenTelemetry with Azure Monitor
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddOpenTelemetry(options =>
        {
            options.AddAzureMonitorLogExporter();
        });
});

// Create a logger for the specified category
var logger = loggerFactory.CreateLogger(logCategoryName);

// Log a custom event with a custom name and additional attribute
// The 'microsoft.custom_event.name' value will be used as the name of the customEvent
logger.LogInformation("{microsoft.custom_event.name} {additional_attrs}", "test-event-name", "val1");

Per inviare un customEvent con l'agente Java, impostare l'attributo "microsoft.custom_event.name" nel record di log OpenTelemetry.

A seconda che l'agente di Application Insights Java sia in uso o l'SDK di configurazione automatica, il modo di recuperare il logger OpenTelemetry è leggermente diverso. Questo dettaglio è illustrato più avanti negli esempi seguenti.

Per l'agente Java di Application Insights:

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.logs.Severity;

Logger logger = GlobalOpenTelemetry.get().getLogsBridge().get("opentelemetry-logger");

logger.logRecordBuilder()
	  .setAttribute(AttributeKey.stringKey("microsoft.custom_event.name"),"test-event-name")
      .setSeverity(Severity.INFO)
      .emit();

Per l'SDK di configurazione automatica:

import com.azure.monitor.opentelemetry.autoconfigure.AzureMonitorAutoConfigure;
import com.azure.monitor.opentelemetry.autoconfigure.AzureMonitorAutoConfigureOptions;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdkBuilder;

AutoConfiguredOpenTelemetrySdkBuilder sdkBuilder = AutoConfiguredOpenTelemetrySdk.builder();
AzureMonitorAutoConfigureOptions options = new AzureMonitorAutoConfigureOptions();
options.connectionString("<YOUR-CONNECTION-STRING>");

AzureMonitorAutoConfigure.customize(sdkBuilder, options);
OpenTelemetry openTelemetry = sdkBuilder.build().getOpenTelemetrySdk();

Logger logger = openTelemetry.getLogsBridge().get("opentelemetry-logger");
logger.logRecordBuilder()
	  .setAttribute(AttributeKey.stringKey("microsoft.custom_event.name"),"test-event-name")
      .setSeverity(Severity.INFO)
      .emit();

Per generare eventi personalizzati in modo affidabile, usare direttamente l'API OpenTelemetry. Alcuni framework di registrazione non supportano l'aggiunta o l'analisi dell'attributo degli eventi personalizzati.

Non è possibile inviare un usando l'attributo />

Per inviare un customEvent utilizzando logger.emit, impostare l'attributo "microsoft.custom_event.name" nell'oggetto log attributes. È anche possibile includere altri attributi in base alle esigenze.

export class CustomEventSample {
  static async run() {
    // Dynamically import Azure Monitor and the OpenTelemetry logs API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { logs, SeverityNumber } = await import("@opentelemetry/api-logs");

    // Initialize Azure Monitor (enables logs bridge)
    const monitor = useAzureMonitor();

    // Get a logger and emit a customEvent by setting the microsoft attribute key
    const logger = logs.getLogger("my-app-logger");

    logger.emit({
      body: "Hello World!",
      severityNumber: SeverityNumber.INFO,
      attributes: {
        "microsoft.custom_event.name": "test-event-name",
        "additional_attrs": "val1",
      },
    });

    // Example: populate client_IP via attribute 'client.address'
    logger.emit({
      body: "This entry will have a custom client_IP",
      severityNumber: SeverityNumber.INFO,
      attributes: {
        "microsoft.custom_event.name": "test_event",
        "client.address": "192.168.1.1",
      },
    });

    console.log("Custom events emitted");
  }
}

Per inviare un customEvent in Python, usare la libreria logging con l'attributo "microsoft.custom_event.name" nel parametro extra.

import logging
from azure.monitor.opentelemetry import configure_azure_monitor

# Set up your application logger
logger = logging.getLogger("my-app-logger")

# Configure Azure Monitor to collect logs from the specified logger name
configure_azure_monitor(
    logger_name="my-app-logger",  # Collect logs from your namespaced logger
)

# Log a custom event with a custom name and additional attribute
# The 'microsoft.custom_event.name' value will be used as the name of the customEvent
logger.warning(
    "Hello World!",
    extra={
        "microsoft.custom_event.name": "test-event-name",
        "additional_attrs": "val1"
    }
)

# You can also populate fields like client_IP with attribute `client.address`
logger.info(
    "This entry will have a custom client_IP",
    extra={
        "microsoft.custom_event.name": "test_event",
        "client.address": "192.168.1.1"
    }
)

Per aggiungere attributi di span, usare uno dei seguenti due modi:

• Usare le opzioni fornite dalle librerie di strumentazione.
• Aggiungere un processore di estensione personalizzato.

1. Molte librerie di strumentazione offrono un'opzione di arricchimento. Per indicazioni, vedere i file leggimi delle singole librerie di strumentazione:

   • ASP.NET Core
   • HttpClient

2. Usare un processore personalizzato:

   Suggerimento

   Aggiungere il processore illustrato qui prima di aggiungere Monitoraggio di Azure.

   // Create an ASP.NET Core application builder.
   var builder = WebApplication.CreateBuilder(args);
   
   // Configure the OpenTelemetry tracer provider to add a new processor named ActivityEnrichingProcessor.
   builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityEnrichingProcessor()));
   
   // Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
   builder.Services.AddOpenTelemetry().UseAzureMonitor();
   
   // Build the ASP.NET Core application.
   var app = builder.Build();
   
   // Start the ASP.NET Core application.
   app.Run();
   

   Aggiungere ActivityEnrichingProcessor.cs al project con il codice seguente:

   public class ActivityEnrichingProcessor : BaseProcessor<Activity>
   {
       public override void OnEnd(Activity activity)
       {
           // The updated activity will be available to all processors which are called after this processor.
           activity.DisplayName = "Updated-" + activity.DisplayName;
           activity.SetTag("CustomDimension1", "Value1");
           activity.SetTag("CustomDimension2", "Value2");
       }
   }
   

Per aggiungere attributi di span, usare uno dei seguenti due modi:

• Usare le opzioni fornite dalle librerie di strumentazione.
• Aggiungere un processore di estensione personalizzato.

1. Molte librerie di strumentazione offrono un'opzione di arricchimento. Per indicazioni, vedere i file leggimi delle singole librerie di strumentazione:

   • ASP.NET
   • ASP.NET Core
   • HttpClient

2. Usare un processore personalizzato:

   Suggerimento

   Aggiungere il processore illustrato qui prima dello strumento di esportazione di Monitoraggio di Azure.

   // Create an OpenTelemetry tracer provider builder.
   // It is important to keep the TracerProvider instance active throughout the process lifetime.
   using var tracerProvider = Sdk.CreateTracerProviderBuilder()
           // Add a source named "OTel.AzureMonitor.Demo".
           .AddSource("OTel.AzureMonitor.Demo") // Add a new processor named ActivityEnrichingProcessor.
           .AddProcessor(new ActivityEnrichingProcessor()) // Add the Azure Monitor trace exporter.
           .AddAzureMonitorTraceExporter() // Add the Azure Monitor trace exporter.
           .Build();
   

   Aggiungere ActivityEnrichingProcessor.cs al project con il codice seguente:

   public class ActivityEnrichingProcessor : BaseProcessor<Activity>
   {
       // The OnEnd method is called when an activity is finished. This is the ideal place to enrich the activity with additional data.
       public override void OnEnd(Activity activity)
       {
           // Update the activity's display name.
           // The updated activity will be available to all processors which are called after this processor.
           activity.DisplayName = "Updated-" + activity.DisplayName;
           // Set custom tags on the activity.
           activity.SetTag("CustomDimension1", "Value1");
           activity.SetTag("CustomDimension2", "Value2");
       }
   }
   

È possibile usare opentelemetry-api per aggiungere attributi agli intervalli.

L'aggiunta di uno o più attributi di intervallo popola il campo customDimensions della tabella requests, dependencies, traces o exceptions.

1. Aggiungere opentelemetry-api-1.0.0.jar (o versione successiva) all'applicazione:

   <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-api</artifactId>
       <version>1.0.0</version>
   </dependency>
   

2. Aggiungere dimensioni personalizzate nel codice:

   import io.opentelemetry.api.trace.Span;
   import io.opentelemetry.api.common.AttributeKey;
   
   AttributeKey attributeKey = AttributeKey.stringKey("mycustomdimension");
   Span.current().setAttribute(attributeKey, "myvalue1");
   

Aggiungere dimensioni personalizzate nel codice:

import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.common.AttributeKey;

AttributeKey attributeKey = AttributeKey.stringKey("mycustomdimension");
Span.current().setAttribute(attributeKey, "myvalue1");

export class SpanAttributeEnrichmentSample {
  static async run() {
    // Dynamically import the Azure Monitor integration
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");

    // Create a SpanEnrichingProcessor to add custom dimensions
    class SpanEnrichingProcessor {
      forceFlush() { return Promise.resolve(); }
      shutdown() { return Promise.resolve(); }
      onStart() {}
      onEnd(span: any) {
        (span as any).attributes = (span as any).attributes || {};
        (span as any).attributes["CustomDimension1"] = "value1";
        (span as any).attributes["CustomDimension2"] = "value2";
      }
    }

    // Initialize Azure Monitor with the custom processor
    const monitor = useAzureMonitor({
      spanProcessors: [new SpanEnrichingProcessor()],
    });

    console.log("Span enrichment processor registered");
  }
}

Usare un processore personalizzato:

...
# Import the necessary packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace

# Create a SpanEnrichingProcessor instance.
span_enrich_processor = SpanEnrichingProcessor()

# 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>",
    # Configure the custom span processors to include span enrich processor.
    span_processors=[span_enrich_processor],
)

...

Aggiungere SpanEnrichingProcessor al project con il codice seguente:

# Import the SpanProcessor class from the opentelemetry.sdk.trace module.
from opentelemetry.sdk.trace import SpanProcessor

class SpanEnrichingProcessor(SpanProcessor):

    def on_end(self, span):
        # Prefix the span name with the string "Updated-".
        span._name = "Updated-" + span.name
        # Add the custom dimension "CustomDimension1" with the value "Value1".
        span._attributes["CustomDimension1"] = "Value1"
         # Add the custom dimension "CustomDimension2" with the value "Value2".
        span._attributes["CustomDimension2"] = "Value2"

Usare l'esempio di proprietà personalizzata, ma sostituire le righe di codice seguenti in ActivityEnrichingProcessor.cs:

// Add the client IP address to the activity as a tag.
// only applicable in case of activity.Kind == Server
activity.SetTag("client.address", "<IP Address>");

Usare l'esempio di proprietà personalizzata, ma sostituire le righe di codice seguenti in ActivityEnrichingProcessor.cs:

// Add the client IP address to the activity as a tag.
// only applicable in case of activity.Kind == Server
activity.SetTag("client.address", "<IP Address>");

Java popola automaticamente questo campo.

Questo campo viene popolato automaticamente.

Usare l'esempio di proprietà personalizzata, ma sostituire le righe di codice seguenti:

export class SetUserIpSample {
  static async run() {
    // Dynamically import Azure Monitor and tracing API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { trace } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor();

    // Framework-agnostic helper to set client IP on the active server span
    const setIpForRequest = (clientIp: string) => {
      const span = trace.getActiveSpan();
      if (span) {
        // Preferred attribute for client IP
        span.setAttribute("client.address", clientIp);
        // Optional: legacy/alternate attribute
        span.setAttribute("http.client_ip", clientIp);
      }
    };

    // Call setIpForRequest("<IP Address>") from within your web framework's request pipeline
    console.log("Use setIpForRequest('<IP Address>') inside your request handler to stamp the active span.");
  }
}

Usare l'esempio di proprietà personalizzata, ma sostituire le righe di codice seguenti in SpanEnrichingProcessor.py:

# Set the `http.client_ip` attribute of the span to the specified IP address.
span._attributes["http.client_ip"] = "<IP Address>"

Usare l'esempio di proprietà personalizzata:

// Add the user ID to the activity as a tag, but only if the activity is not null.
activity?.SetTag("enduser.id", "<User Id>");

Usare l'esempio di proprietà personalizzata:

// Add the user ID to the activity as a tag, but only if the activity is not null.
activity?.SetTag("enduser.id", "<User Id>");

Popolare il campo user ID della tabella requests, dependencies o exceptions.

1. Aggiungere opentelemetry-api-1.0.0.jar (o versione successiva) all'applicazione:

   <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-api</artifactId>
       <version>1.0.0</version>
   </dependency>
   

2. Impostare user_Id nel codice:

   import io.opentelemetry.api.trace.Span;
   
   Span.current().setAttribute("enduser.id", "myuser"); // (user_AuthenticatedId)
   Span.current().setAttribute("enduser.pseudo.id", "myuser"); // (user_Id)
   

Popolare il campo user ID della tabella requests, dependencies o exceptions.

Impostare user_Id nel codice:

import io.opentelemetry.api.trace.Span;

Span.current().setAttribute("enduser.id", "myuser"); // (user_AuthenticatedId)
Span.current().setAttribute("enduser.pseudo.id", "myuser"); // (user_Id)

Usare l'esempio di proprietà personalizzata, ma sostituire le righe di codice seguenti:

export class SetUserIdSample {
  static async run() {
    // Dynamically import Azure Monitor and tracing API
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const { trace } = await import("@opentelemetry/api");

    // Initialize Azure Monitor
    const monitor = useAzureMonitor();

    // Framework-agnostic helper to set user identifiers on the active server span
    const setUserForRequest = (authenticatedId?: string, anonymousId?: string) => {
      const span = trace.getActiveSpan();
      if (span) {
        if (authenticatedId) span.setAttribute("enduser.id", authenticatedId);      // user_AuthenticatedId
        if (anonymousId) span.setAttribute("enduser.pseudo.id", anonymousId);      // user_Id
      }
    };

    // Call setUserForRequest("<authenticated-id>", "<anonymous-id>") inside your request handler
    console.log("Use setUserForRequest('<auth-id>', '<anon-id>') inside your request handler to stamp the active span.");
  }
}

Usare l'esempio di proprietà personalizzata, ma sostituire le righe di codice seguenti:

# Set the `enduser.id` attribute of the span to the specified user ID.
span._attributes["enduser.id"] = "<User ID>"

OpenTelemetry usa .NET ILogger. È possibile allegare dimensioni personalizzate ai log usando un modello di messaggio.

OpenTelemetry usa .NET ILogger. È possibile allegare dimensioni personalizzate ai log usando un modello di messaggio.

Logback, Log4j e java.util.logging vengono instrumentati automaticamente. Il collegamento di dimensioni personalizzate ai log può essere eseguito in questi modi:

• Log4j 2.0 MapMessage (una MapMessage chiave di "message" viene acquisita come messaggio di log)
• Il contesto thread di Log4j 2.0
• Log4j 1.2 MDC

Per le applicazioni native Spring Boot, Logback è instrumentato automaticamente.

export class BunyanLogAttributesSample {
  static async run() {
    // Dynamically import Azure Monitor and Bunyan
    const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
    const bunyanMod = await import("bunyan");
    const bunyan = (bunyanMod as any).default ?? bunyanMod;

    // Enable Azure Monitor integration and bunyan instrumentation
    const monitor = useAzureMonitor({
      instrumentationOptions: { bunyan: { enabled: true } },
    });

    // Emit a log with custom attributes
    const log = (bunyan as any).createLogger({ name: "testApp" });
    log.info({ key1: "value1", feature: "demo" }, "Warning log with properties");

    console.log("Bunyan log with attributes emitted");
  }
}

La libreria Python logging è autoinstrumented. È possibile allegare dimensioni personalizzate ai log inserendo un dizionario nell'argomento extra dei log.

...
# Create a warning log message with the properties "key1" and "value1".
logger.warning("WARNING: Warning log with properties", extra={"key1": "value1"})
...

Il codice seguente mostra un processore di attività personalizzato che contrassegna le risposte HTTP 4xx come riuscite.

Processore:

public class Http4xxSuccessProcessor : BaseProcessor<Activity>
{
	public override void OnEnd(Activity activity)
	{
		if (activity.Kind == ActivityKind.Server)
		{
			var statusCodeTag = activity.GetTagItem("http.response.status_code");
			if (statusCodeTag is int statusCode && statusCode >= 400 && statusCode < 500)
			{
				// Set status to Ok to bypass the Azure Monitor exporter's default logic
				// which treats any HTTP 4xx as failure when status is Unset.
				// The response code tag (e.g., 400) remains unchanged — only the
				// success field in Application Insights is affected.
				activity.SetStatus(ActivityStatusCode.Ok);
			}
		}

		base.OnEnd(activity);
	}
}

Registrazione:

builder.Services.AddOpenTelemetry()
	.UseAzureMonitor(options =>
	{
		options.ConnectionString = "<your-connection-string>";
	})
	.WithTracing(tracing =>
	{
		// Add custom processor to mark 4xx responses as successful
		tracing.AddProcessor<Http4xxSuccessProcessor>();
	});

Il codice seguente è relativo a un processore di attività personalizzato che contrassegna le risposte HTTP 4xx come riuscite.

Processore:

public class Http4xxSuccessProcessor : BaseProcessor<Activity>
{
	public override void OnEnd(Activity activity)
	{
		if (activity.Kind == ActivityKind.Server)
		{
			var statusCodeTag = activity.GetTagItem("http.response.status_code");
			if (statusCodeTag is int statusCode && statusCode >= 400 && statusCode < 500)
			{
				// Set status to Ok to bypass the Azure Monitor exporter's default logic
				// which treats any HTTP 4xx as failure when status is Unset.
				// The response code tag (e.g., 400) remains unchanged — only the
				// success field in Application Insights is affected.
				activity.SetStatus(ActivityStatusCode.Ok);
			}
		}

		base.OnEnd(activity);
	}
}

Registrazione:

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
	// Add the processor before the exporter
	.AddProcessor(new Http4xxSuccessProcessor())
	.AddAzureMonitorTraceExporter(options =>
	{
		options.ConnectionString = "<your-connection-string>";
	})
	.Build();

Per impostazione predefinita, l'agente acquisisce le richieste del server HTTP che generano codici di risposta 4xx come errori. È possibile modificare questo comportamento per trattarli come successi:

{
  "preview": {
	"captureHttpServer4xxAsError": false
  }
}

Processore:

import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.trace.SpanKind;
import io.opentelemetry.api.trace.StatusCode;
import io.opentelemetry.context.Context;
import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.trace.ReadWriteSpan;
import io.opentelemetry.sdk.trace.ReadableSpan;
import io.opentelemetry.sdk.trace.internal.ExtendedSpanProcessor;

import java.util.Set;

public final class Http4xxAsSuccessProcessor implements ExtendedSpanProcessor {

	private static final AttributeKey<Long> HTTP_RESPONSE_STATUS_CODE =
		AttributeKey.longKey("http.response.status_code");

	// Deprecated semconv attribute that some libraries may still emit
	private static final AttributeKey<Long> HTTP_STATUS_CODE =
		AttributeKey.longKey("http.status_code");

	private static final AttributeKey<Boolean> MODIFIED_FLAG =
		AttributeKey.booleanKey("ai.modified.http4xx.success");

	private final Set<Long> keepAsFailure = Set.of(429L);

	@Override
	public void onStart(Context parentContext, ReadWriteSpan span) {
		// No-op
	}

	@Override
	public boolean isStartRequired() {
		return false;
	}

	@Override
	public void onEnding(ReadWriteSpan span) {
		if (span.getKind() != SpanKind.SERVER) {
			return;
		}

		Long statusCode = span.getAttribute(HTTP_RESPONSE_STATUS_CODE);
		if (statusCode == null) {
			statusCode = span.getAttribute(HTTP_STATUS_CODE);
		}

		if (statusCode != null
			&& statusCode >= 400
			&& statusCode < 500
			&& !keepAsFailure.contains(statusCode)) {

			// Keep the HTTP status code attribute unchanged, but mark the span as OK
			// so downstream backends such as Application Insights don't count it as a failure.
			span.setStatus(StatusCode.OK);
			span.setAttribute(MODIFIED_FLAG, true);
		}
	}

	@Override
	public boolean isOnEndingRequired() {
		return true;
	}

	@Override
	public void onEnd(ReadableSpan span) {
		// No-op
	}

	@Override
	public boolean isEndRequired() {
		return false;
	}

	@Override
	public CompletableResultCode shutdown() {
		return CompletableResultCode.ofSuccess();
	}

	@Override
	public CompletableResultCode forceFlush() {
		return CompletableResultCode.ofSuccess();
	}
}

Registrazione (Spring Boot):

import com.azure.monitor.opentelemetry.autoconfigure.AzureMonitorAutoConfigure;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdkBuilder;

public class TelemetryConfiguration {
	public static OpenTelemetry configureOpenTelemetry() {
		AutoConfiguredOpenTelemetrySdkBuilder sdkBuilder = AutoConfiguredOpenTelemetrySdk.builder();

		AzureMonitorAutoConfigure.customize(sdkBuilder, "<your-connection-string>");

		sdkBuilder.addTracerProviderCustomizer(
			(tracerProviderBuilder, configProperties) ->
				tracerProviderBuilder.addSpanProcessor(new Http4xxAsSuccessProcessor())
		);

		return sdkBuilder.build().getOpenTelemetrySdk();
	}
}

Registrazione (Quarkus):

import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class Http4xxAsSuccessProcessor extends Http4xxAsSuccessProcessorBase {
}

import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
import { SpanProcessor, ReadableSpan } from "@opentelemetry/sdk-trace-base";
import { ATTR_HTTP_RESPONSE_STATUS_CODE } from "@opentelemetry/semantic-conventions";

// Deprecated semconv attribute; not exported from the stable entry point.
const ATTR_HTTP_STATUS_CODE = "http.status_code";

export class Http4xxAsSuccessProcessor implements SpanProcessor {
  private keepAsFailure = new Set<number>(/* [429] */);

  onStart(): void {}

  onEnd(span: ReadableSpan): void {
	if (span.kind !== SpanKind.SERVER) return;

	const attrs = span.attributes;
	const sc =
	  (attrs[ATTR_HTTP_RESPONSE_STATUS_CODE] as number | undefined) ??
	  (attrs[ATTR_HTTP_STATUS_CODE] as number | undefined);

	if (
	  typeof sc === "number" &&
	  sc >= 400 &&
	  sc < 500 &&
	  !this.keepAsFailure.has(sc)
	) {
	  // By onEnd the span is ended, so setStatus()/setAttribute() are no-ops.
	  // Directly mutate the backing fields so the exporter sees the change.
	  (span as any).status = { code: SpanStatusCode.OK };
	  (span as any).attributes = {
		...attrs,
		"ai.modified.http4xx.success": true,
	  };
	  console.log(`[Processor] Rewrote ${sc} span to OK`);
	}
  }

  shutdown(): Promise<void> {
	return Promise.resolve();
  }
  forceFlush(): Promise<void> {
	return Promise.resolve();
  }
}

Processore:

from __future__ import annotations

from typing import Iterable, Optional

from opentelemetry.trace import SpanKind, Status, StatusCode
from opentelemetry.sdk.trace import ReadableSpan, SpanProcessor

# Current HTTP semconv attribute
ATTR_HTTP_RESPONSE_STATUS_CODE = "http.response.status_code"

# Older / deprecated attribute that some instrumentations may still emit
ATTR_HTTP_STATUS_CODE = "http.status_code"

class Http4xxAsSuccessProcessor(SpanProcessor):

	def __init__(self, keep_as_failure: Optional[Iterable[int]] = None) -> None:
		# Example: keep 429 as a failure if you want throttling to remain visible
		# self._keep_as_failure = set(keep_as_failure or {429})

	def on_start(self, span, parent_context=None) -> None:
		# No-op
		return

	def on_end(self, span: ReadableSpan) -> None:
		if span.kind is not SpanKind.SERVER:
			return

		attrs = span.attributes
		status_code = attrs.get(
			ATTR_HTTP_RESPONSE_STATUS_CODE,
			attrs.get(ATTR_HTTP_STATUS_CODE),
		)

		if (
			isinstance(status_code, int)
			and 400 <= status_code < 500
			and status_code not in self._keep_as_failure
		):
			# ReadableSpan.status is read-only, so in current released SDKs
			# we mutate the private backing field that the exporter reads.
			span._status = Status(StatusCode.OK)  # pylint: disable=protected-access

			# Optional diagnostic marker so you can tell the processor rewrote it.
			# ReadableSpan.attributes returns a read-only MappingProxyType, so we
			# update the private backing store instead.
			if getattr(span, "_attributes", None) is None:
				span._attributes = {}  # pylint: disable=protected-access

			try:
				span._attributes["ai.modified.http4xx.success"] = True  # pylint: disable=protected-access
			except TypeError:
				# Fallback if the backing store is not directly writable
				span._attributes = dict(span.attributes)  # pylint: disable=protected-access
				span._attributes["ai.modified.http4xx.success"] = True  # pylint: disable=protected-access

	def shutdown(self) -> None:
		return

	def force_flush(self, timeout_millis: int = 30000) -> bool:
		return True

Registrazione:

from azure.monitor.opentelemetrgit  import configure_azure_monitor

configure_azure_monitor(
	connection_string="<your-connection-string>",
	span_processors=[Http4xxAsSuccessProcessor()],
)

// Get the current activity.
Activity activity = Activity.Current;
// Get the trace ID of the activity.
string traceId = activity?.TraceId.ToHexString();
// Get the span ID of the activity.
string spanId = activity?.SpanId.ToHexString();

// Get the current activity.
Activity activity = Activity.Current;
// Get the trace ID of the activity.
string traceId = activity?.TraceId.ToHexString();
// Get the span ID of the activity.
string spanId = activity?.SpanId.ToHexString();

È possibile usare opentelemetry-api per ottenere l'ID di traccia o l'ID di span.

1. Aggiungere opentelemetry-api-1.0.0.jar (o versione successiva) all'applicazione:

   <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-api</artifactId>
       <version>1.0.0</version>
   </dependency>
   

2. Ottenere l'ID di traccia della richiesta e l'ID intervallo nel codice:

   import io.opentelemetry.api.trace.Span;
   
   Span span = Span.current();
   String traceId = span.getSpanContext().getTraceId();
   String spanId = span.getSpanContext().getSpanId();
   

Ottenere l'ID di traccia della richiesta e l'ID intervallo nel codice:

import io.opentelemetry.api.trace.Span;

Span span = Span.current();
String traceId = span.getSpanContext().getTraceId();
String spanId = span.getSpanContext().getSpanId();

Ottenere l'ID di traccia della richiesta e l'ID intervallo nel codice:

export class GetTraceAndSpanIdSample {
  static async run() {
    // Dynamically import tracing API
    const { trace } = await import("@opentelemetry/api");

    // Read the span/trace id from the active span (if any)
    const activeSpan = trace.getActiveSpan();
    const spanId = activeSpan?.spanContext().spanId;
    const traceId = activeSpan?.spanContext().traceId;

    console.log("SpanId:", spanId, "TraceId:", traceId);
  }
}

Ottenere l'ID di traccia della richiesta e l'ID intervallo nel codice:

# Import the necessary libraries.
from opentelemetry import trace

# Get the trace ID and span ID of the current span.
trace_id = trace.get_current_span().get_span_context().trace_id
span_id = trace.get_current_span().get_span_context().span_id

Per informazioni sulla risoluzione dei problemi, vedere Risoluzione dei problemi di OpenTelemetry in .NET e Risoluzione dei problemi di telemetria delle applicazioni mancanti in Monitoraggio di Azure Application Insights.

Per informazioni sulla risoluzione dei problemi, vedere Risoluzione dei problemi di OpenTelemetry in .NET e Risoluzione dei problemi di telemetria delle applicazioni mancanti in Monitoraggio di Azure Application Insights.

Per informazioni sulla risoluzione dei problemi, vedere Risoluzione dei problemi di OpenTelemetry in Java e Risoluzione dei problemi di telemetria dell'applicazione mancante in Monitoraggio di Azure Application Insights.

Per informazioni sulla risoluzione dei problemi, vedere Risoluzione dei problemi OpenTelemetry nelle applicazioni Spring Boot con immagini native e Risoluzione dei problemi di telemetria delle applicazioni mancanti in Monitoraggio di Azure Application Insights.

Per informazioni sulla risoluzione dei problemi, vedere Risolvere i problemi di OpenTelemetry in Node.js e Risolvere i problemi di telemetria dell'applicazione mancante in Application Insights di Monitoraggio di Azure.

Per informazioni sulla risoluzione dei problemi, vedere Risolvere i problemi di OpenTelemetry in Python e Risolvere i problemi di telemetria mancante delle applicazioni in Monitoraggio di Azure Application Insights.

• Per i problemi di supporto Azure, aprire un ticket di supporto Azure.
• Per i problemi di OpenTelemetry, contattare direttamente OpenTelemetry .NET community.
• Per un elenco dei problemi aperti relativi all'utilità di esportazione di Monitoraggio di Azure, vedere la pagina GitHub Issues Page.

• Per problemi di supporto Azure, aprire un ticket di supporto Azure.
• Per i problemi di OpenTelemetry, contattare direttamente OpenTelemetry .NET community.
• Per un elenco dei problemi aperti relativi all'utilità di esportazione di Monitoraggio di Azure, vedere la pagina GitHub Issues Page.

• Per problemi di supporto Azure, aprire un ticket supporto Azure.
• Per informazioni sulla risoluzione dei problemi, vedere i passaggi per la risoluzione dei problemi.
• Per i problemi di OpenTelemetry, contattare direttamente la community di OpenTelemetry .
• Per un elenco dei problemi aperti correlati alla strumentazione automatica Java di Monitoraggio di Azure, vedere la pagina dei problemi di GitHub.

• Per problemi con il supporto Azure, aprire un ticket di supporto Azure.
• Per i problemi di OpenTelemetry, contattare direttamente la community di OpenTelemetry .
• Per un elenco dei problemi aperti relativi alle applicazioni native Spring Boot, vedere la pagina GitHub Issues Page.
• Per un elenco dei problemi aperti relativi alle applicazioni native Quarkus, vedere la pagina GitHub Issues Page.

• Per problemi di supporto Azure, aprire un ticket di supporto Azure.
• Per i problemi di OpenTelemetry, contattare direttamente la community JavaScript di OpenTelemetry .
• Per un elenco dei problemi aperti relativi all'utilità di esportazione di Monitoraggio di Azure, vedere la pagina GitHub Issues Page.

• Per problemi di supporto Azure, aprire un ticket di supporto Azure.
• Per i problemi di OpenTelemetry, contattare direttamente OpenTelemetry Python community.
• Per un elenco dei problemi aperti relativi alla distribuzione Monitoraggio di Azure, vedere la pagina GitHub Pagina problemi.

• Per esaminare il codice sorgente, vedere il repository Monitoraggio di Azure ASP.NET Core GitHub.
• Per esaminare un'applicazione di esempio, vedere Monitoraggio di Azure OpenTelemetry per ASP.NET Core.
• Per installare il pacchetto NuGet, verificare la disponibilità di aggiornamenti o visualizzare le note sulla versione, vedere la pagina Monitoraggio di Azure pacchetto NuGet AspNetCore.
• Per altre informazioni su OpenTelemetry e sulla relativa community, vedere il repository OpenTelemetry .NET GitHub repository.
• Per abilitare le esperienze di utilizzo, abilitare il monitoraggio degli utenti del Web o del browser.

• Per esaminare il codice sorgente, vedere il repository GitHub Monitoraggio di Azure Exporter.
• Per esaminare un'applicazione di esempio, vedere Monitoraggio di Azure OpenTelemetry per .NET.
• Per installare il pacchetto NuGet, verificare la disponibilità di aggiornamenti o visualizzare le note sulla versione, vedere la pagina Monitoraggio di Azure Exporter NuGet Package.
• Per altre informazioni su OpenTelemetry e sulla relativa community, vedere il repository OpenTelemetry .NET GitHub repository.
• Per abilitare le esperienze di utilizzo, abilitare il monitoraggio degli utenti del Web o del browser.

• Per esaminare le opzioni di configurazione, vedere Java opzioni di configurazione di strumentazione automatica.
• Per esaminare il codice sorgente, vedere il repository GitHub della strumentazione automatica Java di Monitoraggio di Azure.
• Per esaminare le applicazioni di esempio, vedere Application Insights Java Samples.
• Esamina le note di rilascio su GitHub.
• Per ulteriori informazioni su OpenTelemetry e sulla sua community, consultare il repository GitHub Java di OpenTelemetry OpenTelemetry.
• Per abilitare le esperienze utente, vedere Abilitare il monitoraggio degli utenti web o del browser.

• Per esaminare il codice sorgente, vedere Monitoraggio di Azure OpenTelemetry Distro in Spring Boot native image Java application and Quarkus OpenTelemetry Exporter for Azure.
• Per esaminare un'applicazione di esempio, vedere Telemetry for GraalVM native images.
• Esamina le note di rilascio su GitHub.
• Scopri di più sulle funzionalità per le applicazioni di immagini native Spring Boot in OpenTelemetry SpringBoot starter
• Scopri di più sulle funzionalità per le applicazioni native Quarkus in Quarkus OpenTelemetry Exporter per Azure.
• Per ulteriori informazioni su OpenTelemetry e sulla sua community, consultare il repository GitHub Java di OpenTelemetry OpenTelemetry.

• Per esaminare il codice sorgente, vedere Monitoraggio di Azure OpenTelemetry for JavaScript repository.
• Per esaminare un'applicazione di esempio, vedere Monitoraggio di Azure OpenTelemetry per Node.js.
• Per installare il pacchetto npm e verificare la disponibilità di aggiornamenti, vedere la pagina @azure/monitor-opentelemetry npm Package.
• Per ulteriori informazioni su OpenTelemetry e la sua community, vedere il repository OpenTelemetry JavaScript GitHub.
• Per abilitare le esperienze di utilizzo, abilitare il monitoraggio degli utenti del Web o del browser.

• Per esaminare il codice sorgente e la documentazione aggiuntiva, vedere il repository Monitoraggio di Azure Python GitHub.
• Per esaminare le applicazioni di esempio, vedere Monitoraggio di Azure OpenTelemetry per Python.
• Per installare il pacchetto PyPI e verificare la disponibilità di aggiornamenti, vedere la pagina Monitoraggio di Azure Distribuzione del pacchetto PyPI.
• Esamina le note di rilascio su GitHub.
• Per esaminare i componenti e le strumentazioni OpenTelemetry disponibili, vedere il repository OpenTelemetry Contributor Python GitHub repository.
• Per altre informazioni su OpenTelemetry e sulla relativa community, vedere il repository OpenTelemetry Python GitHub repository.
• Per abilitare le esperienze di utilizzo, abilitare il monitoraggio degli utenti del Web o del browser.