Informace o nativních aplikacích Quartz najdete v dokumentaci k Quarkus.
Následující knihovny instrumentace OpenTelemetry jsou součástí distro služby Azure Monitor Application Insights. Další informace najdete v tématu Sada Azure SDK pro JavaScript.
Příklady použití knihovny protokolování Pythonu najdete na GitHubu.
Telemetrie generovaná službou Azure SDKS se automaticky shromažďuje ve výchozím nastavení.
Poznámka pod čarou
¹: Podporuje automatické hlášení neošetřených nebo nezachycených výjimek.
²: Podporuje metriky OpenTelemetry
³: Ve výchozím nastavení se protokolování shromažďuje pouze na úrovni INFO nebo vyšší. Pokud chcete toto nastavení změnit, podívejte se na možnosti konfigurace.
⁴: Ve výchozím nastavení se protokolování shromažďuje pouze v případě, že se protokolování provádí na úrovni UPOZORNĚNÍ nebo vyšší.
Poznámka:
Distribuce OpenTelemetry služby Azure Monitor zahrnují vlastní mapování a logiku pro automatické generování standardních metrik Application Insights.
Tip
Všechny metriky OpenTelemetry, ať už se automaticky shromažďují z knihoven instrumentace nebo ručně shromažďované z vlastního kódování, se v současné době považují za vlastní metriky Application Insights pro účely fakturace. Další informace.
Přidání knihovny instrumentace komunity
Pokud zahrnete knihovny instrumentace z komunity OpenTelemetry, můžete automaticky shromažďovat další data.
Upozornění
Nepodporujeme ani nezaručujeme kvalitu komunitních instrumentačních knihoven. Pokud ho chcete navrhnout pro naši distribuci, publikujte nebo hlasujte v naší komunitě pro zpětnou vazbu. Mějte na paměti, že některé jsou založené na experimentálních specifikacích OpenTelemetry a můžou představovat budoucí zásadní změny.
Pokud chcete přidat knihovnu komunity ConfigureOpenTelemetryMeterProvider , po přidání balíčku NuGet pro knihovnu použijte tyto metody ConfigureOpenTelemetryTracerProvider .
Následující příklad ukazuje, jak lze instrumentaci modulu runtime přidat ke shromažďování dalších metrik:
// 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();
Následující příklad ukazuje, jak lze instrumentaci modulu runtime přidat ke shromažďování dalších metrik:
// 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();
Distribuci Javy nemůžete rozšířit o komunitní instrumentační knihovny. Pokud chcete požádat, abychom zahrnuli jinou knihovnu instrumentace, otevřete problém na naší stránce GitHubu. Odkaz na naši stránku GitHubu najdete v dalších krocích.
Knihovny instrumentace komunity nemůžete používat s nativními aplikacemi GraalVM v Javě.
Další instrumentace OpenTelemetry jsou k dispozici tady a je možné je přidat pomocí TraceHandler v ApplicationInsightsClient:
// Import the Azure Monitor OpenTelemetry plugin and OpenTelemetry API
const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
const { metrics, trace, ProxyTracerProvider } = require("@opentelemetry/api");
// Import the OpenTelemetry instrumentation registration function and Express instrumentation
const { registerInstrumentations } = require( "@opentelemetry/instrumentation");
const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');
// Get the OpenTelemetry tracer provider and meter provider
const tracerProvider = (trace.getTracerProvider() as ProxyTracerProvider).getDelegate();
const meterProvider = metrics.getMeterProvider();
// Enable Azure Monitor integration
useAzureMonitor();
// Register the Express instrumentation
registerInstrumentations({
// List of instrumentations to register
instrumentations: [
new ExpressInstrumentation(), // Express instrumentation
],
// OpenTelemetry tracer provider
tracerProvider: tracerProvider,
// OpenTelemetry meter provider
meterProvider: meterProvider
});
Pokud chcete přidat komunitní instrumentační knihovnu (není oficiálně podporovaná nebo zahrnutá v distribucích služby Azure Monitor), můžete instrumentovat přímo s instrumentacemi. Seznam knihoven instrumentace komunity najdete tady.
Poznámka:
Instrumentace podporované knihovny instrumentace ručně s instrument() použitím distrou configure_azure_monitor() se nedoporučuje. Nejedná se o podporovaný scénář a u telemetrie se může zobrazit nežádoucí chování.
# 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())
Shromažďování vlastních telemetrických dat
Tato část vysvětluje, jak shromažďovat vlastní telemetrická data z vaší aplikace.
V závislosti na vašem jazyce a typu signálu existují různé způsoby shromažďování vlastních telemetrických dat, mezi které patří:
OpenTelemetry API
Knihovny protokolování/metrik pro konkrétní jazyk
Klasické rozhraní API Application Insights
Následující tabulka představuje aktuálně podporované vlastní typy telemetrie:
Jazyk
Vlastní události
Vlastní metriky
Závislosti
Výjimky
Zobrazení stránek
Žádosti
Trasování
ASP.NET Core
OpenTelemetry API
Ano
Ano
Ano
Yes
ILogger Rozhraní api
Ano
Klasické rozhraní API AI
Java
OpenTelemetry API
Ano
Ano
Ano
Yes
Logback, Log4j, JUL
Ano
Yes
Metriky v mikrometrech
Ano
Klasické rozhraní API AI
Ano
Ano
Ano
Ano
Ano
Ano
Yes
Node.js
OpenTelemetry API
Ano
Ano
Ano
Yes
Python
OpenTelemetry API
Ano
Ano
Ano
Yes
Modul protokolování Pythonu
Ano
Rozšíření událostí
Ano
Ano
Poznámka:
Application Insights Java 3.x naslouchá telemetrii odesílané do klasického rozhraní API Application Insights. Podobně Application Insights Node.js 3.x shromažďuje události vytvořené pomocí klasického rozhraní API Application Insights. Díky tomu je upgrade jednodušší a vyplní mezeru v naší podpoře vlastní telemetrie, dokud nebudou podporovány všechny vlastní typy telemetrie prostřednictvím rozhraní API OpenTelemetry.
Přidání vlastních metrik
V tomto kontextu vlastní metriky odkazují na ruční instrumentaci kódu a shromažďují další metriky nad rámec toho, co knihovny instrumentace OpenTelemetry automaticky shromažďují.
Rozhraní Api OpenTelemetry nabízí šest "nástrojů" pro pokrytí různých scénářů metrik a při vizualizaci metrik v Průzkumníku metrik musíte vybrat správný typ agregace. Tento požadavek platí při použití rozhraní API metriky OpenTelemetry k odesílání metrik a při použití knihovny instrumentace.
Následující tabulka uvádí doporučené typy agregace pro jednotlivé nástroje metriky OpenTelemetry.
OpenTelemetry Instrument
Typ agregace služby Azure Monitor
Čítač
Sum
Asynchronní čítač
Sum
Histogram
Min, Max, Average, Sum a Count
Asynchronní měřidlo
Průměr
UpDownCounter
Sum
Asynchronní upDownCounter
Sum
Upozornění
Typy agregace nad rámec toho, co je znázorněno v tabulce, obvykle nejsou smysluplné.
Specifikace OpenTelemetry popisuje nástroje a poskytuje příklady, kdy je možné jednotlivé nástroje použít.
Tip
Histogram je nejuniverzálnější a nejpodřenější ekvivalent rozhraní API GetMetric GetMetric. Azure Monitor v současné době zploštěná instrument histogramu do pěti podporovaných typů agregace a podpora percentilů probíhá. I když méně všestranné, jiné nástroje OpenTelemetry mají menší dopad na výkon vaší aplikace.
Spuštění aplikace se musí přihlásit k odběru měřiče podle názvu:
// 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();
Musí Meter být inicializován pomocí stejného názvu:
// 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);
}
}
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);
// Import the Azure Monitor OpenTelemetry plugin and OpenTelemetry API
const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
const { metrics } = require("@opentelemetry/api");
// Enable Azure Monitor integration
useAzureMonitor();
// Get the meter for the "testMeter" namespace
const meter = metrics.getMeter("testMeter");
// Create a histogram metric
let histogram = meter.createHistogram("histogram");
// Record values to the histogram metric with different tags
histogram.record(1, { "testKey": "testValue" });
histogram.record(30, { "testKey": "testValue2" });
histogram.record(100, { "testKey2": "testValue" });
# Import the `configure_azure_monitor()` and `metrics` functions from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import metrics
# 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 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()
Spuštění aplikace se musí přihlásit k odběru měřiče podle názvu:
// 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();
Musí Meter být inicializován pomocí stejného názvu:
// 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"));
}
}
// Import the Azure Monitor OpenTelemetry plugin and OpenTelemetry API
const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
const { metrics } = require("@opentelemetry/api");
// Enable Azure Monitor integration
useAzureMonitor();
// Get the meter for the "testMeter" namespace
const meter = metrics.getMeter("testMeter");
// Create a counter metric
let counter = meter.createCounter("counter");
// Add values to the counter metric with different tags
counter.add(1, { "testKey": "testValue" });
counter.add(5, { "testKey2": "testValue" });
counter.add(3, { "testKey": "testValue2" });
# Import the `configure_azure_monitor()` and `metrics` functions from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import metrics
# 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 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()
Spuštění aplikace se musí přihlásit k odběru měřiče podle názvu:
// 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();
Musí Meter být inicializován pomocí stejného názvu:
// 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"));
});
}
}
// Import the useAzureMonitor function and the metrics module from the @azure/monitor-opentelemetry and @opentelemetry/api packages, respectively.
const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
const { metrics } = require("@opentelemetry/api");
// Enable Azure Monitor integration.
useAzureMonitor();
// Get the meter for the "testMeter" meter name.
const meter = metrics.getMeter("testMeter");
// Create an observable gauge metric with the name "gauge".
let gauge = meter.createObservableGauge("gauge");
// Add a callback to the gauge metric. The callback will be invoked periodically to generate a new value for the gauge metric.
gauge.addCallback((observableResult: ObservableResult) => {
// Generate a random number between 0 and 99.
let randomNumber = Math.floor(Math.random() * 100);
// Set the value of the gauge metric to the random number.
observableResult.observe(randomNumber, {"testKey": "testValue"});
});
# Import the necessary packages.
from typing import Iterable
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>",
)
# 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()
Přidání vlastních výjimek
Výběr knihoven instrumentace automaticky hlásí výjimky do Application Insights.
Můžete ale chtít ručně hlásit výjimky nad rámec sestavy knihoven instrumentace.
Například výjimky zachycené vaším kódem nejsou obvykle hlášeny. Můžete je chtít nahlásit, aby upoutat pozornost v relevantních prostředích, včetně části selhání a zobrazení komplexních transakcí.
// 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);
}
}
Protokolování výjimky pomocí 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" });
}
Protokolování výjimky pomocí aktivity:
// 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);
}
}
Protokolování výjimky pomocí 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" });
}
Můžete použít opentelemetry-api k aktualizaci stavu výjimek rozsahu a záznamů.
Přidejte opentelemetry-api-1.0.0.jar do aplikace (nebo novější):
// Import the Azure Monitor OpenTelemetry plugin and OpenTelemetry API
const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
const { trace, SpanKind } = require("@opentelemetry/api");
// Enable Azure Monitor integration
useAzureMonitor();
// Get the tracer for the "testTracer" namespace
const tracer = trace.getTracer("testTracer");
// Start a span with the name "hello"
let span = tracer.startSpan("hello", {
kind: SpanKind.SERVER
});
// Try to throw an error
try{
throw new Error("Test Error");
}
// Catch the error and record it to the span
catch(error){
span.recordException(error);
}
Sada OpenTelemetry Python SDK se implementuje tak, aby se výjimky vyvolané automaticky zaznamenávaly a zaznamenávaly. Příklad tohoto chování najdete v následující ukázce kódu:
# 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")
Pokud chcete zaznamenat výjimky ručně, můžete tuto možnost zakázat v rámci správce kontextu a použít record_exception() ji přímo, jak je znázorněno v následujícím příkladu:
...
# 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)
...
Přidání vlastních rozsahů
Vlastní rozsah můžete přidat ve dvou scénářích. Za prvé, pokud už knihovna instrumentace neshromažďuje požadavek na závislost. Za druhé, pokud chcete modelovat proces aplikace jako rozsah v zobrazení komplexní transakce.
Třídy Activity a ActivitySource z System.Diagnostics oboru názvů představují koncepty Span OpenTelemetry a Tracer, v uvedeném pořadí. Vytváříte ActivitySource přímo pomocí jeho konstruktoru místo pomocí .TracerProvider Každá ActivitySource třída musí být explicitně připojena TracerProvider pomocí .AddSource() Je to proto, že části rozhraní API trasování OpenTelemetry jsou začleněny přímo do modulu runtime .NET. Další informace najdete v tématu Úvod k rozhraní API pro trasování .NET OpenTelemetry.
// 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 výchozí hodnota ActivityKind.Internalje , ale můžete poskytnout jakékoli jiné ActivityKind.
ActivityKind.Client, ActivityKind.Producera ActivityKind.Internal jsou mapovány na Application Insights dependencies.
ActivityKind.Server a ActivityKind.Consumer jsou mapovány na Application Insights requests.
Poznámka:
Třídy Activity a ActivitySource z System.Diagnostics oboru názvů představují koncepty Span OpenTelemetry a Tracer, v uvedeném pořadí. Vytváříte ActivitySource přímo pomocí jeho konstruktoru místo pomocí .TracerProvider Každá ActivitySource třída musí být explicitně připojena TracerProvider pomocí .AddSource() Je to proto, že části rozhraní API trasování OpenTelemetry jsou začleněny přímo do modulu runtime .NET. Další informace najdete v tématu Úvod k rozhraní API pro trasování .NET OpenTelemetry.
// 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 výchozí hodnota ActivityKind.Internalje , ale můžete poskytnout jakékoli jiné ActivityKind.
ActivityKind.Client, ActivityKind.Producera ActivityKind.Internal jsou mapovány na Application Insights dependencies.
ActivityKind.Server a ActivityKind.Consumer jsou mapovány na Application Insights requests.
Použití poznámky OpenTelemetry
Nejjednodušší způsob, jak přidat vlastní rozsahy, je použití anotace OpenTelemetry @WithSpan .
Zaplní tabulky requests a dependencies tabulky v Application Insights.
Přidejte opentelemetry-instrumentation-annotations-1.32.0.jar do aplikace (nebo novější):
Ve výchozím nastavení končí rozsah v dependencies tabulce s typem InProczávislosti .
U metod představujících úlohu na pozadí, kterou autoinstrumentace nezachytí, doporučujeme použít atribut kind = SpanKind.SERVER na @WithSpan anotaci, aby se zajistilo, že se zobrazí v tabulce Application Insights requests .
Použití rozhraní OpenTelemetry API
Pokud předchozí poznámka OpenTelemetry @WithSpan nevyhovuje vašim potřebám, můžete rozsahy přidat pomocí rozhraní API OpenTelemetry.
Přidejte opentelemetry-api-1.0.0.jar do aplikace (nebo novější):
import io.opentelemetry.api.trace.Tracer;
static final Tracer tracer = openTelemetry.getTracer("com.example");
Vytvořte rozsah, nastavte ho jako aktuální a pak ho ukončete:
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();
}
// Import the Azure Monitor OpenTelemetry plugin and OpenTelemetry API
const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
const { trace } = require("@opentelemetry/api");
// Enable Azure Monitor integration
useAzureMonitor();
// Get the tracer for the "testTracer" namespace
const tracer = trace.getTracer("testTracer");
// Start a span with the name "hello"
let span = tracer.startSpan("hello");
// End the span
span.end();
Rozhraní API OpenTelemetry se dá použít k přidání vlastních rozsahů, které se zobrazují v requests tabulkách a dependencies v Application Insights.
Příklad kódu ukazuje, jak použít metodu tracer.start_as_current_span() ke spuštění, nastavit rozsah jako aktuální a ukončit rozsah v kontextu.
...
# 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)
...
Ve výchozím nastavení je rozsah v dependencies tabulce s typem InProczávislosti .
Pokud vaše metoda představuje úlohu na pozadí, která ještě není zachycena automatickou instruací, doporučujeme nastavit atribut kind = SpanKind.SERVER , aby se zajistilo, že se zobrazí v tabulce Application Insights requests .
...
# 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.
...
Odesílání vlastní telemetrie pomocí klasického rozhraní API Application Insights
Kdykoli je to možné, doporučujeme používat rozhraní API OpenTelemetry, ale v některých situacích může být nutné použít klasické rozhraní API Služby Application Insights.
Vlastní telemetrii není možné odesílat pomocí klasického rozhraní API Application Insights v javě nativní.
Pokud chcete přidat vlastní události nebo získat přístup k rozhraní API Application Insights, nahraďte @azure/monitor-opentelemetry balíček balíčkem applicationinsightsv3 Beta. Nabízí stejné metody a rozhraní a veškerý vzorový kód, který platí pro @azure/monitor-opentelemetry balíček v3 Beta.
// Import the TelemetryClient class from the Application Insights SDK for JavaScript.
const { TelemetryClient } = require("applicationinsights");
// Create a new TelemetryClient instance.
const telemetryClient = new TelemetryClient();
Pak použijte TelemetryClient k odesílání vlastní telemetrie:
Události
// Create an event telemetry object.
let eventTelemetry = {
name: "testEvent"
};
// Send the event telemetry object to Azure Monitor Application Insights.
telemetryClient.trackEvent(eventTelemetry);
Protokoly
// Create a trace telemetry object.
let traceTelemetry = {
message: "testMessage",
severity: "Information"
};
// Send the trace telemetry object to Azure Monitor Application Insights.
telemetryClient.trackTrace(traceTelemetry);
Výjimky
// Try to execute a block of code.
try {
...
}
// If an error occurs, catch it and send it to Azure Monitor Application Insights as an exception telemetry item.
catch (error) {
let exceptionTelemetry = {
exception: error,
severity: "Critical"
};
telemetryClient.trackException(exceptionTelemetry);
}
Na rozdíl od jiných jazyků Python nemá sadu Application Insights SDK. Pomocí distrou Služby Azure Monitor OpenTelemetry můžete s výjimkou odesílání customEventssplnit všechny své potřeby monitorování. Dokud se rozhraní API událostí OpenTelemetry stabilizuje, použijte rozšíření událostí služby Azure Monitor s distroem OpenTelemetry služby Azure Monitor k odeslání customEvents do Application Insights.
track_event K odesílání vlastních událostí použijte rozhraní API nabízené v rozšíření:
...
from azure.monitor.events.extension import track_event
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor()
# Use the track_event() api to send custom event telemetry
# Takes event name and custom dimensions
track_event("Test event", {"key1": "value1", "key2": "value2"})
input()
...
Úprava telemetrie
Tato část vysvětluje, jak upravit telemetrii.
Přidání atributů span
Mezi tyto atributy může patřit přidání vlastní vlastnosti do telemetrie. Pomocí atributů můžete také nastavit volitelná pole ve schématu Application Insights, jako je IP adresa klienta.
Přidání vlastní vlastnosti do spanu
Všechny atributy , které přidáte do rozsahů, se exportují jako vlastní vlastnosti. Naplní pole customDimensions v tabulce požadavků, závislostí, trasování nebo výjimek.
Pokud chcete přidat atributy span, použijte jeden z následujících dvou způsobů:
Použijte možnosti poskytované knihovnami instrumentace.
Přidání vlastního procesoru span
Tip
Výhodou použití možností poskytovaných knihovnami instrumentace, pokud jsou k dispozici, je, že je k dispozici celý kontext. V důsledku toho mohou uživatelé vybrat přidání nebo filtrování dalších atributů. Například možnost rozšiřování v knihovně instrumentace HttpClient poskytuje uživatelům přístup k HttpRequestMessage a samotné httpResponseMessage . Můžou z něj vybrat cokoli a uložit ho jako atribut.
Mnoho knihoven instrumentace nabízí možnost obohacení. Pokyny najdete v souborech readme jednotlivých knihoven instrumentace:
Před přidáním služby Azure Monitor přidejte procesor uvedený tady.
// 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();
Do projektu přidejte ActivityEnrichingProcessor.cs následující kód:
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");
}
}
Pokud chcete přidat atributy span, použijte jeden z následujících dvou způsobů:
Použijte možnosti poskytované knihovnami instrumentace.
Přidání vlastního procesoru span
Tip
Výhodou použití možností poskytovaných knihovnami instrumentace, pokud jsou k dispozici, je, že je k dispozici celý kontext. V důsledku toho mohou uživatelé vybrat přidání nebo filtrování dalších atributů. Například možnost rozšiřování v knihovně instrumentace HttpClient poskytuje uživatelům přístup k samotné httpRequestMessage. Můžou z něj vybrat cokoli a uložit ho jako atribut.
Mnoho knihoven instrumentace nabízí možnost obohacení. Pokyny najdete v souborech readme jednotlivých knihoven instrumentace:
Před exportérem služby Azure Monitor přidejte procesor uvedený zde.
// 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();
Do projektu přidejte ActivityEnrichingProcessor.cs následující kód:
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");
}
}
Můžete použít opentelemetry-api k přidání atributů do rozsahů.
Přidání jednoho nebo více atributů span naplní customDimensions pole v requeststabulce , dependencies, tracesnebo exceptions tabulce.
Přidejte opentelemetry-api-1.0.0.jar do aplikace (nebo novější):
...
# 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],
)
...
Do projektu přidejte SpanEnrichingProcessor následující kód:
# 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"
Nastavení IP adresy uživatele
Pole client_IP pro žádosti můžete naplnit nastavením atributu v rozsahu. Application Insights používá IP adresu k vygenerování atributů umístění uživatele a ve výchozím nastavení ji zahodí.
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu vActivityEnrichingProcessor.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>");
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu vActivityEnrichingProcessor.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 toto pole automaticky naplní.
Toto pole se vyplní automaticky.
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu:
...
// Import the SemanticAttributes class from the @opentelemetry/semantic-conventions package.
const { SemanticAttributes } = require("@opentelemetry/semantic-conventions");
// Create a new SpanEnrichingProcessor class.
class SpanEnrichingProcessor implements SpanProcessor {
onEnd(span) {
// Set the HTTP_CLIENT_IP attribute on the span to the IP address of the client.
span.attributes[SemanticAttributes.HTTP_CLIENT_IP] = "<IP Address>";
}
}
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu vSpanEnrichingProcessor.py:
# Set the `http.client_ip` attribute of the span to the specified IP address.
span._attributes["http.client_ip"] = "<IP Address>"
Nastavení ID uživatele nebo ověřeného ID uživatele
Pole user_Id nebo user_AuthenticatedId pro žádosti můžete naplnit pomocí následujících doprovodných materiálů. ID uživatele je anonymní identifikátor uživatele. Ověřené ID uživatele je známý identifikátor uživatele.
Důležité
Než nastavíte ID ověřeného uživatele, obraťte se na příslušné zákony o ochraně osobních údajů.
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu:
...
// Import the SemanticAttributes class from the @opentelemetry/semantic-conventions package.
import { SemanticAttributes } from "@opentelemetry/semantic-conventions";
// Create a new SpanEnrichingProcessor class.
class SpanEnrichingProcessor implements SpanProcessor {
onEnd(span: ReadableSpan) {
// Set the ENDUSER_ID attribute on the span to the ID of the user.
span.attributes[SemanticAttributes.ENDUSER_ID] = "<User ID>";
}
}
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu:
# Set the `enduser.id` attribute of the span to the specified user ID.
span._attributes["enduser.id"] = "<User ID>"
Knihovna protokolování Pythonu se automaticky implementuje. Vlastní dimenze můžete k protokolům připojit předáním slovníku do argumentu extra protokolů:
...
# Create a warning log message with the properties "key1" and "value1".
logger.warning("WARNING: Warning log with properties", extra={"key1": "value1"})
...
Filtrování telemetrie
Před opuštěním aplikace můžete telemetrii vyfiltrovat pomocí následujících způsobů.
Před přidáním služby Azure Monitor přidejte procesor uvedený tady.
// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);
// Configure the OpenTelemetry tracer provider to add a new processor named ActivityFilteringProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityFilteringProcessor()));
// Configure the OpenTelemetry tracer provider to add a new source named "ActivitySourceName".
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();
// Start the ASP.NET Core application.
app.Run();
Do projektu přidejte ActivityFilteringProcessor.cs následující kód:
public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
// The OnStart method is called when an activity is started. This is the ideal place to filter activities.
public override void OnStart(Activity activity)
{
// prevents all exporters from exporting internal activities
if (activity.Kind == ActivityKind.Internal)
{
activity.IsAllDataRequested = false;
}
}
}
Pokud konkrétní zdroj není explicitně přidán pomocí , AddSource("ActivitySourceName")žádná z aktivit vytvořených pomocí tohoto zdroje se exportuje.
Mnoho knihoven instrumentace poskytuje možnost filtru. Pokyny najdete v souborech readme jednotlivých knihoven instrumentace:
// 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("OTel.AzureMonitor.Demo") // Add a source named "OTel.AzureMonitor.Demo".
.AddProcessor(new ActivityFilteringProcessor()) // Add a new processor named ActivityFilteringProcessor.
.AddAzureMonitorTraceExporter() // Add the Azure Monitor trace exporter.
.Build();
Do projektu přidejte ActivityFilteringProcessor.cs následující kód:
public class ActivityFilteringProcessor : BaseProcessor<Activity>
{
// The OnStart method is called when an activity is started. This is the ideal place to filter activities.
public override void OnStart(Activity activity)
{
// prevents all exporters from exporting internal activities
if (activity.Kind == ActivityKind.Internal)
{
activity.IsAllDataRequested = false;
}
}
}
Pokud konkrétní zdroj není explicitně přidán pomocí , AddSource("ActivitySourceName")žádná z aktivit vytvořených pomocí tohoto zdroje se exportuje.
Vylučte možnost adresy URL poskytovanou mnoha knihovnami instrumentace HTTP.
Následující příklad ukazuje, jak vyloučit určitou adresu URL ze sledování pomocí knihovny instrumentace HTTP/HTTPS:
// Import the useAzureMonitor function and the ApplicationInsightsOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, ApplicationInsightsOptions } = require("@azure/monitor-opentelemetry");
// Import the HttpInstrumentationConfig class from the @opentelemetry/instrumentation-http package.
const { HttpInstrumentationConfig }= require("@opentelemetry/instrumentation-http");
// Import the IncomingMessage and RequestOptions classes from the http and https packages, respectively.
const { IncomingMessage } = require("http");
const { RequestOptions } = require("https");
// Create a new HttpInstrumentationConfig object.
const httpInstrumentationConfig: HttpInstrumentationConfig = {
enabled: true,
ignoreIncomingRequestHook: (request: IncomingMessage) => {
// Ignore OPTIONS incoming requests.
if (request.method === 'OPTIONS') {
return true;
}
return false;
},
ignoreOutgoingRequestHook: (options: RequestOptions) => {
// Ignore outgoing requests with the /test path.
if (options.path === '/test') {
return true;
}
return false;
}
};
// Create a new ApplicationInsightsOptions object.
const config: ApplicationInsightsOptions = {
instrumentationOptions: {
http: {
httpInstrumentationConfig
}
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the ApplicationInsightsOptions object.
useAzureMonitor(config);
Použijte vlastní procesor. Vlastní procesor span můžete použít k vyloučení určitých rozsahů z exportu. Pokud chcete označit rozsahy, které se nemají exportovat, nastavte TraceFlag na DEFAULThodnotu .
Použijte příklad přidat vlastní vlastnost, ale nahraďte následující řádky kódu:
// Import the necessary packages.
const { SpanKind, TraceFlags } = require("@opentelemetry/api");
const { ReadableSpan, Span, SpanProcessor } = require("@opentelemetry/sdk-trace-base");
// Create a new SpanEnrichingProcessor class.
class SpanEnrichingProcessor implements SpanProcessor {
forceFlush(): Promise<void> {
return Promise.resolve();
}
shutdown(): Promise<void> {
return Promise.resolve();
}
onStart(_span: Span): void {}
onEnd(span) {
// If the span is an internal span, set the trace flags to NONE.
if(span.kind == SpanKind.INTERNAL){
span.spanContext().traceFlags = TraceFlags.NONE;
}
}
}
Vylučte adresu URL s proměnnou OTEL_PYTHON_EXCLUDED_URLS prostředí:
Tím se vyloučí koncový bod zobrazený v následujícím příkladu Flasku:
...
# Import the Flask and Azure Monitor OpenTelemetry SDK libraries.
import flask
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 to your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="<your-connection-string>",
)
# Create a Flask application.
app = flask.Flask(__name__)
# Define a route. Requests sent to this endpoint will not be tracked due to
# flask_config configuration.
@app.route("/ignore")
def ignore():
return "Request received but not tracked."
...
Použijte vlastní procesor. Vlastní procesor span můžete použít k vyloučení určitých rozsahů z exportu. Pokud chcete označit rozsahy, které se nemají exportovat, nastavte TraceFlag na DEFAULT:
...
# Import the necessary libraries.
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>",
# Configure the custom span processors to include span filter processor.
span_processors=[span_filter_processor],
)
...
Do projektu přidejte SpanFilteringProcessor následující kód:
# Import the necessary libraries.
from opentelemetry.trace import SpanContext, SpanKind, TraceFlags
from opentelemetry.sdk.trace import SpanProcessor
# Define a custom span processor called `SpanFilteringProcessor`.
class SpanFilteringProcessor(SpanProcessor):
# Prevents exporting spans from internal activities.
def on_start(self, span, parent_context):
# Check if the span is an internal activity.
if span._kind is SpanKind.INTERNAL:
# Create a new span context with the following properties:
# * The trace ID is the same as the trace ID of the original span.
# * The span ID is the same as the span ID of the original span.
# * The is_remote property is set to `False`.
# * The trace flags are set to `DEFAULT`.
# * The trace state is the same as the trace state of the original span.
span._context = SpanContext(
span.context.trace_id,
span.context.span_id,
span.context.is_remote,
TraceFlags(TraceFlags.DEFAULT),
span.context.trace_state,
)
Získání ID trasování nebo ID rozsahu
Aktuálně aktivní span můžete získat Trace IDSpan ID pomocí následujícího postupu.
Třídy Activity a ActivitySource z System.Diagnostics oboru názvů představují koncepty Span OpenTelemetry a Tracer, v uvedeném pořadí. Je to proto, že části rozhraní API trasování OpenTelemetry jsou začleněny přímo do modulu runtime .NET. Další informace najdete v tématu Úvod k rozhraní API pro trasování .NET OpenTelemetry.
// 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();
Poznámka:
Třídy Activity a ActivitySource z System.Diagnostics oboru názvů představují koncepty Span OpenTelemetry a Tracer, v uvedeném pořadí. Je to proto, že části rozhraní API trasování OpenTelemetry jsou začleněny přímo do modulu runtime .NET. Další informace najdete v tématu Úvod k rozhraní API pro trasování .NET OpenTelemetry.
// 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();
Můžete použít opentelemetry-api k získání ID trasování nebo ID rozsahu.
Přidejte opentelemetry-api-1.0.0.jar do aplikace (nebo novější):
Získejte ID trasování požadavku a ID rozsahu v kódu:
// Import the trace module from the OpenTelemetry API.
const { trace } = require("@opentelemetry/api");
// Get the span ID and trace ID of the active span.
let spanId = trace.getActiveSpan().spanContext().spanId;
let traceId = trace.getActiveSpan().spanContext().traceId;
Získejte ID trasování požadavku a ID rozsahu v kódu:
# 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
Další konfiguraci distribuce OpenTelemetry najdete v tématu Konfigurace OpenTelemetry služby Azure Monitor.
Informace o zdrojovém kódu najdete v úložišti Azure Monitor AspNetCore na GitHubu.
Pokud chcete nainstalovat balíček NuGet, vyhledat aktualizace nebo zobrazit poznámky k verzi, podívejte se na stránku balíčku NuGet AspNetCore služby Azure Monitor.
Pokud se chcete seznámit se službou Azure Monitor a OpenTelemetry, podívejte se na ukázkovou aplikaci Azure Monitoru.
Další informace o OpenTelemetry a její komunitě najdete v úložišti OpenTelemetry .NET Na GitHubu.
Pokud chcete povolit používání, povolte monitorování uživatelů ve webovém nebo prohlížeči.
Pokud chcete zkontrolovat zdrojový kód, projděte si úložiště GitHubu exportéru služby Azure Monitor.
Pokud chcete nainstalovat balíček NuGet, vyhledat aktualizace nebo zobrazit poznámky k verzi, podívejte se na stránku balíčku NuGet exportéru služby Azure Monitor.
Pokud se chcete seznámit se službou Azure Monitor a OpenTelemetry, podívejte se na ukázkovou aplikaci Azure Monitoru.
Další informace o OpenTelemetry a její komunitě najdete v úložišti OpenTelemetry .NET Na GitHubu.
Pokud chcete povolit používání, povolte monitorování uživatelů ve webovém nebo prohlížeči.
Projděte si možnosti konfigurace automatického nastavení Javy.
Pokud chcete zkontrolovat zdrojový kód, projděte si úložiště GitHubu pro automatickou správu Java služby Azure Monitor.
Další informace o OpenTelemetry a její komunitě najdete v úložišti OpenTelemetry Java Na GitHubu.
Pokud chcete povolit používání, přečtěte si téma Povolení monitorování uživatelů ve webovém nebo prohlížeči.
Přečtěte si poznámky k verzi na GitHubu.
Podrobnosti o přidávání a úpravách OpenTelemetry služby Azure Monitor najdete v tématu Přidání a úprava OpenTelemetry služby Azure Monitor.
Další ukázky a případy použití najdete v ukázkách distribuce služby Azure Monitor.
Přečtěte si poznámky k verzi na GitHubu.
Pokud chcete nainstalovat balíček PyPI, vyhledat aktualizace nebo zobrazit poznámky k verzi, podívejte se na stránku balíčku Azure Monitor Distro PyPI.
Pokud se chcete seznámit se službou Azure Monitor Application Insights a OpenTelemetry, podívejte se na ukázkovou aplikaci služby Azure Monitor.
Další informace o OpenTelemetry a její komunitě najdete v úložišti GitHub v Pythonu OpenTelemetry.
Informace o dostupných instrumentacích a komponentách OpenTelemetry najdete v úložišti GitHubu pro Přispěvatel OpenTelemetry v Pythonu.
Pokud chcete povolit používání, povolte monitorování uživatelů ve webovém nebo prohlížeči.
Nejčastější dotazy
Tato část obsahuje odpovědi na běžné otázky.
Co je OpenTelemetry?
Jedná se o nový opensourcový standard pro pozorovatelnost. Další informace najdete v OpenTelemetry.
Proč Microsoft Azure Monitor investuje do OpenTelemetry?
Microsoft investuje do OpenTelemetry z následujících důvodů:
Je neutrální od dodavatele a poskytuje konzistentní rozhraní API a sady SDK napříč jazyky.
V průběhu času věříme, že OpenTelemetry umožní zákazníkům služby Azure Monitor sledovat aplikace napsané v jazycích nad rámec našich podporovaných jazyků.
Rozšiřuje typy dat, která můžete shromažďovat prostřednictvím bohaté sady knihoven instrumentace.
Sady OpenTelemetry Software Development Kit (SDK) mají tendenci být výkonnější ve velkém měřítku než jejich předchůdci, sady SDK Application Insights.
Co je distribuce OpenTelemetry služby Azure Monitor?
Můžete si ho představit jako tenký obal, který spojuje všechny komponenty OpenTelemetry pro prvotřídní prostředí v Azure. Tento obálka se také nazývá distribuce v OpenTelemetry.
Proč mám používat distrou OpenTelemetry služby Azure Monitor?
Použití opentelemetry Azure Monitoru přes nativní OpenTelemetry od komunity má několik výhod:
Snižuje úsilí o povolení
Podporováno Microsoftem
Přináší funkce specifické pro Azure, například:
Vzorkování kompatibilní s klasickými sadami Application Insights SDK
V duchu OpenTelemetry jsme navrhli distribuci tak, aby byla otevřená a rozšiřitelná. Můžete například přidat:
Vývozce protokolu OTLP (OpenTelemetry Protocol) a odeslání do druhého místa určení současně
Jiné knihovny instrumentace, které nejsou součástí distribuce
Vzhledem k tomu, že distro poskytuje distribuci OpenTelemetry, distro podporuje cokoli, co podporuje OpenTelemetry. Pokud je OpenTelemetry podporuje, můžete například přidat další procesory telemetrie, exportéry nebo knihovny instrumentace.
Poznámka:
Distribuce nastaví sampler na vlastní vzorkovník s pevnou rychlostí pro Application Insights. Můžete to změnit na jiný sampler, ale můžete to udělat tak, že zakážete některé zahrnuté funkce distribuce.
Další informace o podporovaném sampleru najdete v části Povolení vzorkování v části Konfigurace OpenTelemetry služby Azure Monitor.
Pro jazyky bez podporovaného samostatného exportéru OpenTelemetry je jediným aktuálně podporovaným způsobem použití OpenTelemetry se službou Azure Monitor. Pro jazyky s podporovaným samostatným exportérem OpenTelemetry máte možnost použít distro služby Azure Monitor OpenTelemetry nebo příslušný samostatný exportér OpenTelemetry v závislosti na vašem scénáři telemetrie. Další informace najdete v tématu Kdy mám použít exportér OpenTelemetry služby Azure Monitor?.
Jak můžu otestovat distribuci OpenTelemetry služby Azure Monitor?
Kdy mám použít exportér OpenTelemetry služby Azure Monitor?
Pro ASP.NET Core, Javu, Node.js a Python doporučujeme použít distro OpenTelemetry služby Azure Monitor. Začněte jedním řádkem kódu.
Pro všechny ostatní scénáře .NET, včetně klasických ASP.NET, konzolových aplikací, model Windows Forms (WinForms) atd., doporučujeme použít exportér OpenTelemetry pro .NET Azure Monitor: Azure.Monitor.OpenTelemetry.Exporter.
Pro složitější scénáře telemetrie Pythonu, které vyžadují pokročilou konfiguraci, doporučujeme použít exportér OpenTelemetry služby Python Azure Monitor.
Jaký je aktuální stav funkcí ve službě Azure Monitor OpenTelemetry Distro?
Následující graf rozebíral podporu funkcí OpenTelemetry pro každý jazyk.
Je možné OpenTelemetry použít pro webové prohlížeče?
Ano, ale nedoporučujeme ho a Azure ho nepodporuje. OpenTelemetry JavaScript je silně optimalizovaný pro Node.js. Místo toho doporučujeme použít sadu Application Insights JavaScript SDK.
Kdy můžeme očekávat, že sada OpenTelemetry SDK bude dostupná pro použití ve webových prohlížečích?
Webová sada SDK OpenTelemetry nemá určenou časovou osu dostupnosti. Pravděpodobně jsme několik let daleko od sady SDK prohlížeče, která je možná alternativou k sadě Application Insights JavaScript SDK.
Můžu dnes testovat OpenTelemetry ve webovém prohlížeči?
Webový sandbox OpenTelemetry je fork navržený tak, aby openTelemetry fungoval v prohlížeči. Zatím není možné odesílat telemetrii do Application Insights. Sada SDK nedefinuje obecné události klienta.
Podporuje se spouštění Application Insights společně s agenty konkurentů, jako jsou AppDynamics, DataDog a NewRelic?
Tento postup není něco, co plánujeme testovat nebo podporovat, i když naše distribuce umožňují exportovat do koncového bodu OTLP společně se službou Azure Monitor současně.
Můžu používat funkce preview v produkčních prostředích?
Jaký je rozdíl mezi ručním a automatickým instrumentací?
Viz přehled OpenTelemetry.
Můžu použít kolektor OpenTelemetry?
Někteří zákazníci používají OpenTelemetry Collector jako alternativu agenta, i když Microsoft oficiálně nepodporuje přístup založený na agentech pro monitorování aplikací. Do té doby opensourcová komunita přispěla exportérem Služby Azure Monitoru OpenTelemetry, který někteří zákazníci používají k odesílání dat do služby Azure Monitor Application Insights. Microsoft to nepodporuje.
Jaký je rozdíl mezi OpenCensus a OpenTelemetry?
OpenCensus je prekurzorem OpenTelemetry. Microsoft pomohl spojit OpenTracing a OpenCensus k vytvoření OpenTelemetry, jediného pozorovatelného standardu pro svět. Aktuální sada Python SDK doporučená pro produkční prostředí pro Azure Monitor je založená na OpenCensus. Společnost Microsoft se zavázala vytvářet Azure Monitor na základě OpenTelemetry.
V Grafaně, proč vidím Status: 500. Can't visualize trace events using the trace visualizer?
Místo trasování OpenTelemetry se můžete pokoušet vizualizovat nezpracované textové protokoly.
V Application Insights tabulka Traces ukládá nezpracované textové protokoly pro účely diagnostiky. Pomáhají identifikovat a korelovat trasování související s požadavky uživatelů, dalšími událostmi a sestavami výjimek. Tabulka Traces ale přímo nepřispívá do kompletního zobrazení transakcí (vodopádový graf) v nástrojích vizualizace, jako je Grafana.
S rostoucím přijetím postupů nativních pro cloud existuje vývoj shromažďování a terminologie telemetrie. OpenTelemetry se stal standardem pro shromažďování a instrumentaci telemetrických dat. V tomto kontextu pojem Traces převzal nový význam. Místo nezpracovaných protokolů označují trasování v OpenTelemetry bohatší strukturovanou formu telemetrie, která zahrnuje rozsahy, které představují jednotlivé jednotky práce. Tato rozsahy jsou zásadní pro vytváření podrobných zobrazení transakcí, což umožňuje lepší monitorování a diagnostiku aplikací nativních pro cloud.
Exportér služby Azure Monitor používá k internímu protokolování EventSource. Protokoly vývozce jsou k dispozici pro jakýkoli EventListener tím, že se přihlásí ke zdroji, který je pojmenován OpenTelemetry-AzureMonitor-Exporter. Postup řešení potíží najdete v tématu Řešení potíží s OpenTelemetry na GitHubu.
Krok 2: Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat
Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovala jako volání REST v koncových bodech příjmu dat. Pokud chcete otestovat připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat, použijte příkazy cURL nebo nezpracované požadavky REST z PowerShellu. Další informace najdete v tématu Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.
Známé problémy
V následujících položkách jsou známé problémy pro exportéry OpenTelemetry služby Azure Monitor:
V telemetrii závislostí chybí název operace. Chybějící název operace způsobuje selhání a nepříznivě ovlivňuje výkon karty.
V požadavku a telemetrii závislostí chybí model zařízení. Chybějící model zařízení nepříznivě ovlivňuje analýzu kohorty zařízení.
Krok 1: Povolení protokolování diagnostiky
Exportér služby Azure Monitor používá k internímu protokolování EventSource. Protokoly vývozce jsou k dispozici pro jakýkoli EventListener tím, že se přihlásí ke zdroji, který je pojmenován OpenTelemetry-AzureMonitor-Exporter. Postup řešení potíží najdete v tématu Řešení potíží s OpenTelemetry na GitHubu.
Krok 2: Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat
Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovala jako volání REST v koncových bodech příjmu dat. Pokud chcete otestovat připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat, použijte příkazy cURL nebo nezpracované požadavky REST z PowerShellu. Další informace najdete v tématu Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.
Známé problémy
V následujících položkách jsou známé problémy pro exportéry OpenTelemetry služby Azure Monitor:
V telemetrii závislostí chybí název operace. Chybějící název operace způsobuje selhání a nepříznivě ovlivňuje výkon karty.
V požadavku a telemetrii závislostí chybí model zařízení. Chybějící model zařízení nepříznivě ovlivňuje analýzu kohorty zařízení.
Krok 2: Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat
Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovala jako volání REST v koncových bodech příjmu dat. Pokud chcete otestovat připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat, použijte příkazy cURL nebo nezpracované požadavky REST z PowerShellu. Další informace najdete v tématu Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.
Známé problémy
Pokud si stáhnete klientskou knihovnu Application Insights pro instalaci z prohlížeče, někdy se stažený soubor JAR poškodí a je přibližně poloviční velikost zdrojového souboru. Pokud dojde k tomuto problému, stáhněte soubor JAR spuštěním příkazu curl nebo wget , jak je znázorněno v následujícím příkladu volání příkazů:
Ukázkové volání příkazů platí pro Application Insights pro Javu verze 3.4.11. Pokud chcete najít číslo verze a adresu URL aktuální verze Application Insights pro Javu, přečtěte si téma https://github.com/microsoft/ApplicationInsights-Java/releases.
Následující kroky platí pro nativní aplikace Spring Boot.
Krok 1: Ověření verze OpenTelemetry
Během spuštění aplikace si můžete všimnout následující zprávy:
WARN c.a.m.a.s.OpenTelemetryVersionCheckRunner - The OpenTelemetry version is not compatible with the spring-cloud-azure-starter-monitor dependency.
The OpenTelemetry version should be <version>
V tomto případě musíte importovat faktury OpenTelemetry podle dokumentace OpenTelemetry v úvodní aplikaci Spring Boot.
Krok 2: Povolení samoobslužné diagnostiky
Pokud něco nefunguje podle očekávání, můžete povolit samoobslužnou diagnostiku na DEBUG úrovni, abyste získali nějaké přehledy. Uděláte to tak, že nastavíte úroveň samoobslužné diagnostiky na ERRORhodnotu , WARNINFO, DEBUG, nebo TRACE pomocí APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL proměnné prostředí.
Pokud chcete povolit samoobslužnou diagnostiku na DEBUG úrovni při spuštění kontejneru Dockeru, spusťte následující příkaz:
docker run -e APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL=DEBUG <image-name>
Poznámka:
Odpovídajícím způsobem nahraďte <image-name> názvem image Dockeru.
Zřeknutí se odpovědnosti za informace třetích stran
Produkty třetích stran, o nichž se hovoří v tomto článku, jsou vyráběny společnostmi nezávislými na společnosti Microsoft. Společnost Microsoft neposkytuje žádnou záruku (implicitně předpokládanou ani jinou) týkající se výkonu a spolehlivosti těchto produktů.
Krok 1: Povolení protokolování diagnostiky
Exportér služby Azure Monitor používá protokolovací nástroj rozhraní API OpenTelemetry pro interní protokoly. Pokud chcete protokolovací nástroj povolit, spusťte následující fragment kódu:
Krok 2: Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat
Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovala jako volání REST v koncových bodech příjmu dat. Pokud chcete otestovat připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat, použijte příkazy cURL nebo nezpracované požadavky REST z PowerShellu. Další informace najdete v tématu Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.
Známé problémy
V následujících položkách jsou známé problémy pro exportéry OpenTelemetry služby Azure Monitor:
V telemetrii závislostí chybí název operace. Chybějící název operace způsobuje selhání a nepříznivě ovlivňuje výkon karty.
V požadavku a telemetrii závislostí chybí model zařízení. Chybějící model zařízení nepříznivě ovlivňuje analýzu kohorty zařízení.
V názvu závislosti chybí název databázového serveru. Vzhledem k tomu, že název databázového serveru není zahrnutý, exportéři OpenTelemetry nesprávně agregují tabulky se stejným názvem na různé servery.
Krok 1: Povolení protokolování diagnostiky
Exportér Microsoft Azure Monitoru používá pro své interní protokolování standardní knihovnu protokolování Pythonu. Protokoly rozhraní OpenTelemetry API a exportéru služby Azure Monitor mají přiřazenou úroveň WARNING závažnosti nebo ERROR pro nepravidelnou aktivitu. Úroveň INFO závažnosti se používá pro běžnou nebo úspěšnou aktivitu.
Ve výchozím nastavení nastaví knihovna protokolování Pythonu úroveň závažnosti na WARNING. Proto je nutné změnit úroveň závažnosti, abyste viděli protokoly v tomto nastavení závažnosti. Následující příklad kódu ukazuje, jak výstupní protokoly všech úrovní závažnosti do konzoly a souboru:
Krok 2: Testování připojení mezi hostitelem vaší aplikace a službou příjmu dat
Sady Application Insights SDK a agenti odesílají telemetrii, aby se ingestovala jako volání REST v koncových bodech příjmu dat. Pokud chcete otestovat připojení z webového serveru nebo hostitelského počítače aplikace ke koncovým bodům služby pro příjem dat, použijte příkazy cURL nebo nezpracované požadavky REST z PowerShellu. Další informace najdete v tématu Řešení potíží s chybějící telemetrií aplikací ve službě Azure Monitor Application Insights.
Krok 3: Vyhněte se duplicitní telemetrii
Duplicitní telemetrie je často způsobena vytvořením více instancí procesorů nebo exportérů. Ujistěte se, že pro každý pilíř telemetrie (protokoly, metriky a distribuované trasování) spouštíte vždy jenom jeden vývozce a procesor.
Následující části popisují scénáře, které můžou způsobit duplicitní telemetrii.
Duplicitní protokoly trasování ve službě Azure Functions
Pokud se v Application Insights zobrazí dvojice položek pro každý protokol trasování, pravděpodobně jste povolili následující typy instrumentace protokolování:
Nativní instrumentace protokolování ve službě Azure Functions
Instrumentace azure-monitor-opentelemetry protokolování v rámci distribuce
Pokud chcete zabránit duplikaci, můžete protokolování distribuce zakázat, ale v Azure Functions nechte povolenou nativní instrumentaci protokolování. Uděláte to tak, že nastavíte proměnnou OTEL_LOGS_EXPORTER prostředí na Nonehodnotu .
Duplicitní telemetrie ve službě Azure Functions AlwaysOn
Pokud je nastavení AlwaysOn ve službě Azure Functions nastavené na Zapnuto, služba Azure Functions udržuje některé procesy spuštěné na pozadí po dokončení každého spuštění. Předpokládejme například, že máte pětiminutovou funkci časovače, která pokaždé volá configure_azure_monitor . Po 20 minutách můžete mít čtyři exportéry metrik, které běží současně. Tato situace může být zdrojem telemetrie duplicitních metrik.
V takovém případě buď nastavte nastavení AlwaysOn na Vypnuto, nebo zkuste ručně vypnout poskytovatele mezi jednotlivými configure_azure_monitor voláními. Pokud chcete vypnout každého zprostředkovatele, spusťte volání vypnutí pro každého aktuálního měřiče, trasování a zprostředkovatele protokolovacího nástroje, jak je znázorněno v následujícím kódu:
Azure Workbooks a Jupyter Notebooks můžou udržovat procesy exportéru spuštěné na pozadí. Pokud chcete zabránit duplicitní telemetrii, vymažte mezipaměť předtím, než budete volat configure_azure_monitorvíce .
Krok 4: Ujistěte se, že se shromažďují data žádosti Flask.
Pokud implementujete aplikaci Flask, můžete zjistit, že během používání klientské knihovny OpenTelemetry OpenTelemetry pro Python nemůžete shromažďovat data tabulky Requests z Application Insights. K tomuto problému může dojít v případě, že deklarace nespravujete import správně. Před voláním configure_azure_monitor funkce instrumentace knihovny Flask můžete naimportovat architekturu flask.Flask webové aplikace. Například následující kód úspěšně instrumentuje aplikaci Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
from flask import Flask
configure_azure_monitor()
app = Flask(__name__)
Místo toho doporučujeme importovat flask modul jako celek a pak volat configure_azure_monitor konfiguraci OpenTelemetry tak, aby používala Azure Monitor před přístupem flask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
import flask
configure_azure_monitor()
app = flask.Flask(__name__)
Alternativně můžete volat configure_azure_monitor před importem flask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor()
from flask import Flask
app = Flask(__name__)
Technická podpora
Vyberte kartu pro jazyk podle vašeho výběru a objevte možnosti podpory.