Зависимости для собственных приложений Spring Boot
JDBC
R2DBC
MongoDB
Kafka
Метрики
Метрики Micrometer
Журналы для собственных приложений Spring Boot
Logback
Для собственных приложений Изумите, ознакомьтесь с документацией Quarkus.
Следующие библиотеки инструментирования OpenTelemetry включены в состав дистрибутива Azure Monitor Application Insights. Дополнительные сведения см. в статье с пакетом SDK Azure для JavaScript.
Примеры использования библиотеки ведения журнала Python можно найти на сайте GitHub.
Данные телеметрии, создаваемые Azure SDKS, автоматически собираются по умолчанию.
Сноски
NO. Поддерживает автоматическую отчетность необработанных и неуправляемых исключений.
2. Поддерживает метрики OpenTelemetry
Fx. По умолчанию ведение журнала собирается только на уровне INFO или выше. Чтобы изменить этот параметр, см . параметры конфигурации.
⁴. По умолчанию ведение журнала собирается только при выполнении этого ведения журнала на уровне ПРЕДУПРЕЖДЕНИЯ или выше.
Примечание.
Дистрибутивы OpenTelemetry Azure Monitor включают настраиваемое сопоставление и логику для автоматического выдачи стандартных метрик Application Insights.
Совет
Все метрики OpenTelemetry, собираемые автоматически из библиотек инструментирования или вручную собранные из пользовательского кода, в настоящее время считаются Application Insights "пользовательскими метриками" для выставления счетов. Подробнее.
Добавление библиотеки инструментирования сообщества
Вы можете автоматически собирать дополнительные данные при включении библиотек инструментирования из сообщества OpenTelemetry.
Внимание
Мы не поддерживаем или не гарантируем качество библиотек инструментирования сообщества. Чтобы предложить один для нашего дистрибутива, публикации или голосования в нашем сообществе отзывов. Помните, что некоторые из них основаны на экспериментальных спецификациях OpenTelemetry и могут ввести будущие критические изменения.
Чтобы добавить библиотеку сообщества, используйте ConfigureOpenTelemetryMeterProviderConfigureOpenTelemetryTracerProvider методы после добавления пакета NuGet для библиотеки.
// 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();
// 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();
Вы не можете расширить дистрибутив Java с помощью библиотек инструментирования сообщества. Чтобы запросить включение другой библиотеки инструментирования, откройте проблему на странице GitHub. Ссылку на страницу GitHub можно найти на следующей странице.
Вы не можете использовать библиотеки инструментирования сообщества с собственными приложениями GraalVM Java.
Другие инструментирования OpenTelemetry доступны здесь и могут быть добавлены с помощью TraceHandler в 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
});
Чтобы добавить библиотеку инструментирования сообщества (официально не поддерживаемую или включенную в дистрибутив Azure Monitor), можно инструментировать непосредственно с помощью инструментирования. Список библиотек инструментирования сообщества можно найти здесь.
Примечание.
Инструментирование поддерживаемой библиотеки инструментирования вручную с instrument() помощью дистрибутива configure_azure_monitor() не рекомендуется. Это не поддерживаемый сценарий, и вы можете получить нежелательное поведение для телеметрии.
# 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())
Сбор пользовательских данных телеметрии
В этом разделе объясняется, как собирать пользовательские данные телеметрии из приложения.
В зависимости от языка и типа сигнала существуют различные способы сбора пользовательских данных телеметрии, в том числе:
OpenTelemetry API
Библиотеки журналов и метрик для конкретного языка
Классический API Application Insights
В следующей таблице представлены поддерживаемые в настоящее время пользовательские типы телеметрии:
Язык
Пользовательские события
Пользовательские метрики
Зависимости
Исключения
Просмотры страницы
Запросы
Трассировки
ASP.NET Core
OpenTelemetry API
Да
Да
Да
Да
API ILogger
Да
Классический API ИИ
Java
OpenTelemetry API
Да
Да
Да
Да
Logback, Log4j, JUL
Да
Да
Метрики Micrometer
Да
Классический API ИИ
Да
Да
Да
Да
Да
Да
Да
Node.js
OpenTelemetry API
Да
Да
Да
Да
Python
OpenTelemetry API
Да
Да
Да
Да
Модуль ведения журнала Python
Да
Расширение событий
Да
Да
Примечание.
Application Insights Java 3.x прослушивает данные телеметрии, отправляемые в классический API Application Insights. Аналогичным образом Application Insights Node.js 3.x собирает события, созданные с помощью классического API Application Insights. Это упрощает обновление и заполняет пробел в нашей пользовательской поддержке телеметрии до тех пор, пока все пользовательские типы телеметрии не будут поддерживаться через API OpenTelemetry.
Добавление пользовательских метрик
В этом контексте пользовательские метрики ссылаются на ручное инструментирование кода для сбора дополнительных метрик за пределами того, что библиотеки инструментирования OpenTelemetry автоматически собирают.
API OpenTelemetry предлагает шесть инструментов для покрытия различных сценариев метрик и необходимо выбрать правильный тип агрегирования при визуализации метрик в обозревателе метрик. Это требование верно при использовании API метрик OpenTelemetry для отправки метрик и при использовании библиотеки инструментирования.
В следующей таблице показаны рекомендуемые типы агрегирования для каждого из инструментов метрик OpenTelemetry.
Инструмент OpenTelemetry
Тип агрегирования Azure Monitor
Счетчик
Sum
Асинхронный счетчик
Sum
Гистограмма
Min, Max, Average, Sum и Count
Асинхронный датчик
По средней
UpDownCounter
Sum
Асинхронный upDownCounter
Sum
Внимание
Типы агрегирования за пределами того, что показано в таблице, обычно не являются значимыми.
Спецификация OpenTelemetry описывает инструменты и приводит примеры использования каждого из них.
Совет
Гистограмма является наиболее универсальным и наиболее тесно эквивалентным классическому API Application Insights GetMetric. Azure Monitor в настоящее время сглаживает инструмент гистограммы в наших пяти поддерживаемых типах агрегирования и поддерживает процентиль. Хотя и менее универсальный, другие инструменты OpenTelemetry оказывают меньшее влияние на производительность вашего приложения.
Запуск приложения должен подписаться на счетчик по имени:
// 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 инициализироваться с помощью этого же имени:
// 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()
Запуск приложения должен подписаться на счетчик по имени:
// 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 инициализироваться с помощью этого же имени:
// 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()
Запуск приложения должен подписаться на счетчик по имени:
// 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 инициализироваться с помощью этого же имени:
// 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()
Добавление настраиваемых исключений
Выберите библиотеки инструментирования автоматически сообщать об исключениях в Application Insights.
Однако может потребоваться вручную сообщать об исключениях за пределами отчетов библиотек инструментирования.
Например, исключения, пойманные кодом, обычно не сообщаются. Вы можете сообщить о них, чтобы привлечь внимание к соответствующим интерфейсам, включая разделы сбоев и сквозные представления транзакций.
// 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);
}
}
Регистрация исключения с помощью 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" });
}
Чтобы записать исключение с помощью действия:
// 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);
}
}
Регистрация исключения с помощью 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" });
}
Можно использовать opentelemetry-api для обновления состояния исключений диапазона и записи.
Добавьте opentelemetry-api-1.0.0.jar (или более поздней версии) в приложение:
// 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");
// 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);
}
Пакет SDK Для Python OpenTelemetry реализуется таким образом, чтобы исключения были автоматически записаны и записаны. Пример этого поведения см. в следующем примере кода:
# 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")
Если вы хотите записать исключения вручную, можно отключить этот параметр в диспетчере контекстов и использовать record_exception() непосредственно, как показано в следующем примере:
...
# 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)
...
Добавление настраиваемых диапазонов
Может потребоваться добавить пользовательский диапазон в двух сценариях. Во-первых, когда запрос на зависимость еще не собирается библиотекой инструментирования. Во-вторых, когда вы хотите моделировать процесс приложения в виде диапазона в сквозном представлении транзакций.
Классы Activity и ActivitySource из пространства имен System.Diagnostics представляют собой концепции OpenTelemetry Span и Tracer соответственно. Вы создаете ActivitySource непосредственно с помощью конструктора, а не с помощью TracerProvider. Каждый класс ActivitySource должен быть явно подключен к TracerProvider с помощью AddSource(). Это обусловлено тем, что части API трассировки OpenTelemetry включены непосредственно в среду выполнения .NET. Дополнительные сведения см. в разделе Введение в API трассировки .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 значение ActivityKind.Internalпо умолчанию, но можно указать любое другое ActivityKind.
ActivityKind.Client, ActivityKind.Producerи ActivityKind.Internal сопоставляются с Application Insights dependencies.
ActivityKind.Server и ActivityKind.Consumer сопоставляются с Application Insights requests.
Примечание.
Классы Activity и ActivitySource из пространства имен System.Diagnostics представляют собой концепции OpenTelemetry Span и Tracer соответственно. Вы создаете ActivitySource непосредственно с помощью конструктора, а не с помощью TracerProvider. Каждый класс ActivitySource должен быть явно подключен к TracerProvider с помощью AddSource(). Это обусловлено тем, что части API трассировки OpenTelemetry включены непосредственно в среду выполнения .NET. Дополнительные сведения см. в разделе Введение в API трассировки .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 значение ActivityKind.Internalпо умолчанию, но можно указать любое другое ActivityKind.
ActivityKind.Client, ActivityKind.Producerи ActivityKind.Internal сопоставляются с Application Insights dependencies.
ActivityKind.Server и ActivityKind.Consumer сопоставляются с Application Insights requests.
Использование заметки OpenTelemetry
Самый простой способ добавления собственных диапазонов — с помощью заметки OpenTelemetry @WithSpan .
Диапазоны заполняют таблицы requests и dependencies в Application Insights.
Добавьте opentelemetry-instrumentation-annotations-1.32.0.jar (или более поздней версии) в приложение:
По умолчанию диапазон заканчивается в таблице с типом dependenciesInProcзависимостей.
Для методов, представляющих фоновое задание, не захваченное автоинструментацией, рекомендуется применить атрибут kind = SpanKind.SERVER к @WithSpan заметке, чтобы убедиться, что они отображаются в таблице Application Insights requests .
Использование API OpenTelemetry
Если предыдущая заметка OpenTelemetry @WithSpan не соответствует вашим потребностям, можно добавить диапазоны с помощью API OpenTelemetry.
Добавьте opentelemetry-api-1.0.0.jar (или более поздней версии) в приложение:
import io.opentelemetry.api.trace.Tracer;
static final Tracer tracer = openTelemetry.getTracer("com.example");
Создайте диапазон, сделайте его текущим, а затем завершите его:
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();
API OpenTelemetry можно использовать для добавления собственных диапазонов, которые отображаются в requests таблицах и dependencies таблицах в Application Insights.
В примере кода показано, как использовать tracer.start_as_current_span() метод для запуска, сделать диапазон текущим и завершить диапазон в его контексте.
...
# 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)
...
По умолчанию диапазон находится в dependencies таблице с типом InProcзависимостей.
Если метод представляет фоновое задание, которое еще не записано автоинструментацией, рекомендуется задать атрибут kind = SpanKind.SERVER , чтобы он отображался в таблице 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.
...
Отправка пользовательской телеметрии с помощью классического API Application Insights
Мы рекомендуем использовать API OpenTelemetry по возможности, но некоторые сценарии могут возникнуть при использовании классического API Application Insights.
Невозможно отправлять пользовательские данные телеметрии с помощью классического API Application Insights в собственном коде Java.
Если вы хотите добавить пользовательские события или получить доступ к API Application Insights, замените @azure/monitor-opentelemetry пакет пакетом applicationinsightsбета-версии 3. Он предлагает одни и те же методы и интерфейсы, и весь пример кода для @azure/monitor-opentelemetry применения к пакету бета-версии 3.
// Import the TelemetryClient class from the Application Insights SDK for JavaScript.
const { TelemetryClient } = require("applicationinsights");
// Create a new TelemetryClient instance.
const telemetryClient = new TelemetryClient();
Затем используйте для отправки пользовательской TelemetryClient телеметрии:
События
// Create an event telemetry object.
let eventTelemetry = {
name: "testEvent"
};
// Send the event telemetry object to Azure Monitor Application Insights.
telemetryClient.trackEvent(eventTelemetry);
Журналы
// Create a trace telemetry object.
let traceTelemetry = {
message: "testMessage",
severity: "Information"
};
// Send the trace telemetry object to Azure Monitor Application Insights.
telemetryClient.trackTrace(traceTelemetry);
Исключения
// 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);
}
В отличие от других языков, Python не имеет пакета SDK Application Insights. Вы можете удовлетворить все потребности мониторинга с помощью дистрибутива OpenTelemetry в Azure Monitor, за исключением отправки customEvents. Пока API событий OpenTelemetry не стабилизируется, используйте расширение событий Azure Monitor с дистрибутивом OpenTelemetry Azure Monitor для отправки customEvents в Application Insights.
Используйте API, предлагаемый track_event в расширении, для отправки пользовательских событий:
...
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()
...
Изменение телеметрии
В этом разделе описано, как изменить телеметрию.
Добавление атрибутов диапазона
Эти атрибуты могут включать в себя добавление пользовательского свойства в данные телеметрии. Можно также использовать атрибуты для задания необязательных полей в схеме Application Insights, например "IP-адрес клиента".
Добавление настраиваемого свойства в диапазон
Все атрибуты, добавляемые в диапазоны, экспортируются как пользовательские свойства. Они заполняют поле customDimensions в таблице запросов, зависимостей, трассировок или исключений.
Преимущество использования параметров, предоставляемых библиотеками инструментирования, когда они доступны, заключается в том, что доступен весь контекст. В результате пользователи могут добавить или отфильтровать дополнительные атрибуты. Например, параметр обогащения в библиотеке инструментирования HttpClient предоставляет пользователям доступ к HttpRequestMessage и самому HttpResponseMessage. Они могут выбрать что-нибудь из него и сохранить его как атрибут.
Многие библиотеки инструментирования предоставляют параметр обогащения. Инструкции см. в файлах сведений отдельных библиотек инструментирования:
Добавьте процессор, показанный здесь перед добавлением Azure Monitor.
// 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();
Добавьте ActivityEnrichingProcessor.cs в проект, используя следующий код:
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");
}
}
Чтобы добавить атрибуты диапазона, используйте один из следующих двух способов:
Преимущество использования параметров, предоставляемых библиотеками инструментирования, когда они доступны, заключается в том, что доступен весь контекст. В результате пользователи могут добавить или отфильтровать дополнительные атрибуты. Например, параметр обогащения в библиотеке инструментирования HttpClient предоставляет пользователям доступ к самому httpRequestMessage. Они могут выбрать что-нибудь из него и сохранить его как атрибут.
Многие библиотеки инструментирования предоставляют параметр обогащения. Инструкции см. в файлах сведений отдельных библиотек инструментирования:
Добавьте показанный здесь процессор перед средством экспорта Azure Monitor.
// 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();
Добавьте ActivityEnrichingProcessor.cs в проект, используя следующий код:
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");
}
}
Для добавления атрибутов в диапазоны можно использовать opentelemetry-api.
Добавление одного или нескольких атрибутов диапазона заполняет customDimensions поле в requestsdependenciesтаблице или tracesexceptions поле.
Добавьте opentelemetry-api-1.0.0.jar (или более поздней версии) в приложение:
...
# 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],
)
...
Добавьте SpanEnrichingProcessor в проект, используя следующий код:
# 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"
Задание IP-адреса пользователя
Поле client_IP для запросов можно заполнить, задав атрибут в диапазоне. Application Insights использует IP-адрес для создания атрибутов расположения пользователей, а затем по умолчанию отменяет его.
Используйте пример добавления пользовательского свойства, но замените следующие строки кода в 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>");
Используйте пример добавления пользовательского свойства, но замените следующие строки кода в 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>");
...
// 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>";
}
}
Используйте пример добавления пользовательского свойства, но замените следующие строки кода в SpanEnrichingProcessor.py:
# Set the `http.client_ip` attribute of the span to the specified IP address.
span._attributes["http.client_ip"] = "<IP Address>"
Установка идентификатора пользователя или идентификатора пользователя, прошедшего проверку подлинности
Вы можете заполнить поле user_Id или user_AuthenticatedId для запросов с помощью следующего руководства. Идентификатор пользователя — это анонимный идентификатор пользователя. Идентификатор пользователя, прошедший проверку подлинности, является известным идентификатором пользователя.
Внимание
Перед настройкой идентификатора пользователя с проверкой подлинности обратитесь к применимым законам о конфиденциальности.
...
// 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>";
}
}
Библиотека ведения журнала Python автоматически используется. Вы можете присоединить пользовательские измерения к журналам, передав словарь в extra аргумент журналов:
...
# Create a warning log message with the properties "key1" and "value1".
logger.warning("WARNING: Warning log with properties", extra={"key1": "value1"})
...
Фильтрация данных телеметрии
Отфильтровать телеметрию до выхода из приложения можно следующими способами.
Добавьте процессор, показанный здесь перед добавлением Azure Monitor.
// 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();
Добавьте ActivityFilteringProcessor.cs в проект, используя следующий код:
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;
}
}
}
Если конкретный источник не добавляется явным образом с помощью AddSource("ActivitySourceName"), то никакие действия, созданные с помощью этого источника, экспортируются.
Многие библиотеки инструментирования предоставляют вариант фильтрования. Инструкции см. в файлах сведений отдельных библиотек инструментирования:
// 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();
Добавьте ActivityFilteringProcessor.cs в проект, используя следующий код:
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;
}
}
}
Если конкретный источник не добавляется явным образом с помощью AddSource("ActivitySourceName"), то никакие действия, созданные с помощью этого источника, экспортируются.
// 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);
Используйте пользовательский процессор. Для исключения определенных диапазонов из экспорта можно использовать процессор пользовательского диапазона. Чтобы пометить диапазоны как не подлежащие экспорту, задайте для TraceFlag значение DEFAULT.
Это исключает конечную точку, показанную в следующем примере Flask:
...
# 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."
...
Используйте пользовательский процессор. Для исключения определенных диапазонов из экспорта можно использовать процессор пользовательского диапазона. Чтобы пометить диапазоны, которые не экспортируются, установите значение TraceFlagDEFAULT:
...
# 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],
)
...
Добавьте SpanFilteringProcessor в проект, используя следующий код:
# 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,
)
Получение идентификатора трассировки или идентификатора диапазона
Вы можете получить Trace ID и Span ID текущее активное диапазон, выполнив следующие действия.
Классы Activity и ActivitySource из пространства имен System.Diagnostics представляют собой концепции OpenTelemetry Span и Tracer соответственно. Это обусловлено тем, что части API трассировки OpenTelemetry включены непосредственно в среду выполнения .NET. Дополнительные сведения см. в разделе Введение в API трассировки .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();
Примечание.
Классы Activity и ActivitySource из пространства имен System.Diagnostics представляют собой концепции OpenTelemetry Span и Tracer соответственно. Это обусловлено тем, что части API трассировки OpenTelemetry включены непосредственно в среду выполнения .NET. Дополнительные сведения см. в разделе Введение в API трассировки .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();
Для получения идентификатора трассировки или идентификатора диапазона можно использовать opentelemetry-api.
Добавьте opentelemetry-api-1.0.0.jar (или более поздней версии) в приложение:
Получите идентификатор трассировки запроса и идентификатор диапазона в коде:
// 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;
Получите идентификатор трассировки запроса и идентификатор диапазона в коде:
# 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
Чтобы установить пакет NuGet, проверить наличие обновлений или просмотреть заметки о выпуске, ознакомьтесь со страницей пакета NuGet Для Azure Monitor AspNetCore.
Дополнительные сведения об Azure Monitor и OpenTelemetry см. в примере приложения Azure Monitor.
В этом разделы приводятся ответы на часто задаваемые вопросы.
Что такое OpenTelemetry?
Это новый стандарт с открытым исходным кодом для наблюдения. Дополнительные сведения см. в openTelemetry.
Почему Microsoft Azure Monitor инвестирует в OpenTelemetry?
Корпорация Майкрософт инвестирует в OpenTelemetry по следующим причинам:
Он нейтрализуется поставщиком и предоставляет согласованные API/пакеты SDK на разных языках.
Со временем мы считаем, что OpenTelemetry позволит клиентам Azure Monitor наблюдать за приложениями, написанными на языках за пределами поддерживаемых языков.
Он расширяет типы данных, которые можно собирать с помощью расширенного набора библиотек инструментирования.
Наборы средств разработки программного обеспечения OpenTelemetry (ПАКЕТЫ SDK), как правило, являются более производительными, чем их предшественники, пакеты SDK Application Insights.
Что такое дистрибутив Azure Monitor OpenTelemetry?
Вы можете подумать о нем как тонкой оболочке, которая объединяет все компоненты OpenTelemetry для первого класса в Azure. Эта оболочка также называется распределением в OpenTelemetry.
Почему следует использовать дистрибутив Azure Monitor OpenTelemetry?
Существует несколько преимуществ использования дистрибутива OpenTelemetry в Azure Monitor по сравнению с собственной платформой OpenTelemetry из сообщества:
Сокращение усилий по включению
Поддерживается корпорацией Майкрософт
Включает такие функции Azure, как:
Выборка, совместимая с классическими пакетами SDK Application Insights
В духе OpenTelemetry мы разработали дистрибутив, чтобы быть открытым и расширяемым. Например, можно добавить следующее:
Экспортер протокола OpenTelemetry (OTLP) и отправка в другое место одновременно
Другие библиотеки инструментирования, не включенные в дистрибутив
Так как дистрибутив предоставляет распределение OpenTelemetry, дистрибутив поддерживает все, что поддерживается OpenTelemetry. Например, можно добавить дополнительные процессоры телеметрии, экспортеры или библиотеки инструментирования, если OpenTelemetry поддерживает их.
Примечание.
Дистрибутив задает образец для пользовательского с фиксированной скоростью выборки для Application Insights. Это можно изменить на другой образец, но это может отключить некоторые из включенных возможностей дистрибутива.
Дополнительные сведения о поддерживаемом образце см. в разделе "Включение выборки " в разделе "Настройка Azure Monitor OpenTelemetry".
Для языков без поддерживаемого автономного экспортера OpenTelemetry дистрибутив Azure Monitor OpenTelemetry является единственным поддерживаемым в настоящее время способом использования OpenTelemetry с Azure Monitor. Для языков с поддерживаемым автономным экспортером OpenTelemetry вы можете использовать дистрибутив Azure Monitor OpenTelemetry или соответствующий автономный экспортер OpenTelemetry в зависимости от сценария телеметрии. Дополнительные сведения см. в статье "Когда следует использовать экспортер OpenTelemetry Azure Monitor?".
Как протестировать дистрибутив OpenTelemetry в Azure Monitor?
Внедрение OpenTelemetry теперь предотвращает перенос на более позднюю дату.
Когда следует использовать экспортер OpenTelemetry в Azure Monitor?
Для ASP.NET Core, Java, Node.js и Python рекомендуется использовать дистрибутив OpenTelemetry в Azure Monitor. Это одна строка кода для начала работы.
Для всех других сценариев .NET, включая классические ASP.NET, консольные приложения, Windows Forms (WinForms) и т. д., мы рекомендуем использовать экспортер OpenTelemetry .NET в Azure Monitor: Azure.Monitor.OpenTelemetry.Exporter
Для более сложных сценариев телеметрии Python, требующих расширенной настройки, рекомендуется использовать экспортер OpenTelemetry Для Python Monitor.
Что такое текущее состояние выпуска функций в дистрибутиве OpenTelemetry в Azure Monitor?
На следующей диаграмме описана поддержка функций OpenTelemetry для каждого языка.
Можно ли использовать OpenTelemetry для веб-браузеров?
Да, но мы не рекомендуем его, и Azure не поддерживает его. JavaScript OpenTelemetry оптимизирован для Node.js. Вместо этого рекомендуется использовать пакет SDK JavaScript для Application Insights.
Когда можно ожидать, что пакет SDK OpenTelemetry будет доступен для использования в веб-браузерах?
Веб-пакет SDK OpenTelemetry не имеет определенной временной шкалы доступности. Скорее всего, несколько лет от пакета SDK для браузера, который является жизнеспособной альтернативой пакету SDK JavaScript для Application Insights.
Можно ли протестировать OpenTelemetry в веб-браузере сегодня?
Веб-песочница OpenTelemetry — это вилка, предназначенная для работы OpenTelemetry в браузере. Пока невозможно отправить данные телеметрии в Application Insights. Пакет SDK не определяет общие события клиента.
Поддерживается ли Application Insights вместе с агентами конкурентов, такими как AppDynamics, DataDog и NewRelic?
Эта практика не является тем, что мы планируем протестировать или поддерживать, хотя наши дистрибутивы позволяют экспортировать в конечную точку OTLP вместе с Azure Monitor одновременно.
Можно ли использовать предварительные версии функций в рабочих средах?
Какова разница между ручной и автоматической инструментированием?
Ознакомьтесь с обзором OpenTelemetry.
Можно ли использовать сборщик OpenTelemetry?
Некоторые клиенты используют сборщик OpenTelemetry в качестве альтернативы агенту, хотя корпорация Майкрософт официально не поддерживает подход на основе агента для мониторинга приложений. В то же время сообщество с открытым кодом внесло вклад в сборщик Azure Monitor OpenTelemetry, который некоторые клиенты используют для отправки данных в Azure Monitor Application Insights. Это не поддерживается корпорацией Майкрософт.
Чем отличается OpenCensus от OpenTelemetry?
OpenCensus — это предшественник OpenTelemetry. Корпорация Майкрософт способствовала объединению OpenTracing с OpenCensus для создания OpenTelemetry, единого в мире стандарта наблюдаемости. Текущий рабочий пакет SDK для Python для Azure Monitor основан на OpenCensus. Корпорация Майкрософт стремится сделать Azure Monitor на основе OpenTelemetry.
В Grafana, почему я вижу Status: 500. Can't visualize trace events using the trace visualizer?
Вы можете попытаться визуализировать необработанные текстовые журналы, а не трассировки OpenTelemetry.
В Application Insights таблица Traces хранит необработанные текстовые журналы для диагностических целей. Они помогают определить и сопоставить трассировки, связанные с запросами пользователей, другими событиями и отчетами об исключениях. Однако таблица Traces не напрямую способствует представлению сквозных транзакций (каскадной диаграмме) в средствах визуализации, таких как Grafana.
Благодаря растущему внедрению облачных методик существует эволюция в коллекции и терминологии телеметрии. OpenTelemetry стал стандартом для сбора и инструментирования данных телеметрии. В этом контексте термин "Трассировка" взял на себя новое значение. Вместо необработанных журналов "Трассировка" в OpenTelemetry относится к более богатой структурированной форме телеметрии, которая включает диапазоны, представляющие отдельные единицы работы. Эти диапазоны важны для создания подробных представлений транзакций, что позволяет лучше отслеживать и диагностика облачных приложений.
Экспортер Azure Monitor использует EventSource для внутреннего ведения журнала. Журналы экспортера доступны любому EventListener, выбрав источник, который называется OpenTelemetry-AzureMonitor-Exporter. Инструкции по устранению неполадок см. в разделе "Устранение неполадок OpenTelemetry" на сайте GitHub.
Шаг 2. Тестирование подключения между узлом приложения и службой приема
Пакеты SDK и агенты Application Insights отправляют данные телеметрии для приема в качестве вызовов REST в конечных точках приема. Чтобы проверить подключение с веб-сервера или хост-компьютера приложения к конечным точкам службы приема, используйте команды cURL или необработанные запросы REST из PowerShell. Дополнительные сведения см. в статье "Устранение неполадок с отсутствующими данными телеметрии приложения" в Azure Monitor Application Insights.
Известные проблемы
Ниже перечислены известные проблемы для экспортеров OpenTelemetry в Azure Monitor:
Имя операции отсутствует в телеметрии зависимостей. Отсутствует имя операции приводит к сбоям и негативно влияет на работу вкладки производительности.
Модель устройства отсутствует в телеметрии запросов и зависимостей. Недостающая модель устройства негативно влияет на анализ когорты устройств.
Шаг 1. Включение ведения журнала диагностики
Экспортер Azure Monitor использует EventSource для внутреннего ведения журнала. Журналы экспортера доступны любому EventListener, выбрав источник, который называется OpenTelemetry-AzureMonitor-Exporter. Инструкции по устранению неполадок см. в разделе "Устранение неполадок OpenTelemetry" на сайте GitHub.
Шаг 2. Тестирование подключения между узлом приложения и службой приема
Пакеты SDK и агенты Application Insights отправляют данные телеметрии для приема в качестве вызовов REST в конечных точках приема. Чтобы проверить подключение с веб-сервера или хост-компьютера приложения к конечным точкам службы приема, используйте команды cURL или необработанные запросы REST из PowerShell. Дополнительные сведения см. в статье "Устранение неполадок с отсутствующими данными телеметрии приложения" в Azure Monitor Application Insights.
Известные проблемы
Ниже перечислены известные проблемы для экспортеров OpenTelemetry в Azure Monitor:
Имя операции отсутствует в телеметрии зависимостей. Отсутствует имя операции приводит к сбоям и негативно влияет на работу вкладки производительности.
Модель устройства отсутствует в телеметрии запросов и зависимостей. Недостающая модель устройства негативно влияет на анализ когорты устройств.
Шаг 2. Тестирование подключения между узлом приложения и службой приема
Пакеты SDK и агенты Application Insights отправляют данные телеметрии для приема в качестве вызовов REST в конечных точках приема. Чтобы проверить подключение с веб-сервера или хост-компьютера приложения к конечным точкам службы приема, используйте команды cURL или необработанные запросы REST из PowerShell. Дополнительные сведения см. в статье "Устранение неполадок с отсутствующими данными телеметрии приложения" в Azure Monitor Application Insights.
Примеры вызовов команд применяются к Application Insights для Java версии 3.4.11. Сведения о том, как найти номер версии и URL-адрес текущего выпуска Application Insights для Java, см. в статье https://github.com/microsoft/ApplicationInsights-Java/releases.
Следующие шаги применимы к собственным приложениям Spring Boot.
Шаг 1. Проверка версии OpenTelemetry
Во время запуска приложения может появиться следующее сообщение:
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>
В этом случае необходимо импортировать счета за материалы OpenTelemetry, следуя документации По OpenTelemetry в начальном средстве Spring Boot.
Шаг 2. Включение самостоятельного диагностика
Если что-то не работает должным образом, вы можете включить самостоятельное диагностика на уровне, чтобы получить некоторые DEBUG аналитические сведения. Для этого задайте для самостоятельного диагностика уровень ERROR, WARNили TRACEINFODEBUGс помощью переменной APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL среды.
Чтобы включить самостоятельную диагностика на DEBUG уровне при запуске контейнера Docker, выполните следующую команду:
docker run -e APPLICATIONINSIGHTS_SELF_DIAGNOSTICS_LEVEL=DEBUG <image-name>
Примечание.
Замените <image-name> соответствующим образом имя образа Docker.
Заявление об отказе от ответственности за сведения о продуктах сторонних производителей
В этой статье упомянуты программные продукты независимых производителей. Корпорация Microsoft не дает никаких гарантий, подразумеваемых и прочих, относительно производительности и надежности этих продуктов.
Шаг 1. Включение ведения журнала диагностики
Экспортер Azure Monitor использует средство ведения журнала API OpenTelemetry для внутренних журналов. Чтобы включить средство ведения журнала, выполните следующий фрагмент кода:
Шаг 2. Тестирование подключения между узлом приложения и службой приема
Пакеты SDK и агенты Application Insights отправляют данные телеметрии для приема в качестве вызовов REST в конечных точках приема. Чтобы проверить подключение с веб-сервера или хост-компьютера приложения к конечным точкам службы приема, используйте команды cURL или необработанные запросы REST из PowerShell. Дополнительные сведения см. в статье "Устранение неполадок с отсутствующими данными телеметрии приложения" в Azure Monitor Application Insights.
Известные проблемы
Ниже перечислены известные проблемы для экспортеров OpenTelemetry в Azure Monitor:
Имя операции отсутствует в телеметрии зависимостей. Отсутствует имя операции приводит к сбоям и негативно влияет на работу вкладки производительности.
Модель устройства отсутствует в телеметрии запросов и зависимостей. Недостающая модель устройства негативно влияет на анализ когорты устройств.
Имя сервера базы данных отсутствует в имени зависимости. Так как имя сервера базы данных не включено, Средства экспорта OpenTelemetry неправильно агрегируют таблицы с одинаковыми именами на разных серверах.
Шаг 1. Включение ведения журнала диагностики
Экспортер Microsoft Azure Monitor использует стандартную библиотеку ведения журналов Python для внутреннего ведения журнала. API OpenTelemetry и журналы экспортера Azure Monitor назначают уровень WARNING серьезности или ERROR для нерегулярных действий. Уровень INFO серьезности используется для регулярного или успешного действия.
По умолчанию библиотека ведения журнала Python задает уровень WARNINGсерьезности. Поэтому необходимо изменить уровень серьезности, чтобы просмотреть журналы в этом параметре серьезности. В следующем примере кода показано, как выводить журналы всех уровней серьезности в консоль и файл:
Шаг 2. Тестирование подключения между узлом приложения и службой приема
Пакеты SDK и агенты Application Insights отправляют данные телеметрии для приема в качестве вызовов REST в конечных точках приема. Чтобы проверить подключение с веб-сервера или хост-компьютера приложения к конечным точкам службы приема, используйте команды cURL или необработанные запросы REST из PowerShell. Дополнительные сведения см. в статье "Устранение неполадок с отсутствующими данными телеметрии приложения" в Azure Monitor Application Insights.
Шаг 3. Избегайте дублирования телеметрии
Повторяющиеся данные телеметрии часто вызываются при создании нескольких экземпляров процессоров или экспортеров. Убедитесь, что вы запускаете только один экспортер и процессор за раз для каждого компонента телеметрии (журналы, метрики и распределенная трассировка).
В следующих разделах описаны сценарии, которые могут привести к дублированию данных телеметрии.
Повторяющиеся журналы трассировки в Функции Azure
Если вы видите пару записей для каждого журнала трассировки в Application Insights, вероятно, вы включили следующие типы инструментирования ведения журнала:
Встроенная инструментирование ведения журнала в Функции Azure
Инструментирование azure-monitor-opentelemetry ведения журнала в дистрибутиве
Чтобы предотвратить дублирование, можно отключить ведение журнала дистрибутива, но оставить собственный инструмент ведения журнала в Функции Azure включен. Для этого задайте для переменной OTEL_LOGS_EXPORTER среды значение None.
Повторяющиеся данные телеметрии в Функции Azure AlwaysOn
Если параметр AlwaysOn в Функции Azure имеет значение On, Функции Azure сохраняет некоторые процессы, выполняемые в фоновом режиме после завершения каждого запуска. Например, предположим, что у вас есть пятиминутная функция таймера, которая вызывается configure_azure_monitor каждый раз. Через 20 минут у вас могут быть четыре экспортера метрик, которые работают одновременно. Эта ситуация может быть источником данных телеметрии повторяющихся метрик.
В этой ситуации задайте для параметра AlwaysOn значение Off или попробуйте вручную завершить работу поставщиков между каждым configure_azure_monitor вызовом. Чтобы завершить работу каждого поставщика, выполните вызовы завершения работы для каждого текущего счетчика, трассировщика и поставщика средства ведения журнала, как показано в следующем коде:
Книги Azure и Jupyter Notebook могут поддерживать процессы экспорта в фоновом режиме. Чтобы предотвратить дублирование данных телеметрии, очистите кэш перед выполнением дополнительных вызовов configure_azure_monitor.
Шаг 4. Убедитесь, что данные запроса Flask собираются
Если вы реализуете приложение Flask, вы можете обнаружить, что вы не можете собирать данные таблицы запросов из Application Insights при использовании клиентской библиотеки Azure Monitor OpenTelemetry Distro для Python. Эта проблема может возникнуть, если вы неправильно структурируете import объявления. Вы можете импортировать платформу flask.Flask веб-приложения перед вызовом configure_azure_monitor функции для инструментирования библиотеки Flask. Например, следующий код не успешно инструментирование приложения Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
from flask import Flask
configure_azure_monitor()
app = Flask(__name__)
Вместо этого рекомендуется импортировать flask модуль в целом, а затем вызвать configure_azure_monitor настройку OpenTelemetry для использования Azure Monitor перед доступом flask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
import flask
configure_azure_monitor()
app = flask.Flask(__name__)
Кроме того, можно вызвать configure_azure_monitor перед импортом flask.Flask:
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor()
from flask import Flask
app = Flask(__name__)
Поддержка
Выберите вкладку для выбранного языка, чтобы узнать параметры поддержки.