Tato příručka vysvětluje, jak nakonfigurovat OpenTelemetry (OTel) ve službě Azure Monitor Application Insights pomocí distribuce OpenTelemetry služby Azure Monitor. Správná konfigurace zajišťuje konzistentní shromažďování telemetrických dat napříč aplikacemi .NET, Java, Node.jsa Python, což umožňuje spolehlivější monitorování a diagnostiku.
Řetězec připojení
Připojovací řetězec v Application Insights definuje cílové umístění pro odesílání telemetrických dat.
Pro nastavení připojovacího stringu použijte jeden ze tří následujících způsobů:
Přidejte UseAzureMonitor() do program.cs souboru.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
options.ConnectionString = "<YOUR-CONNECTION-STRING>";
});
var app = builder.Build();
app.Run();
Nastavte proměnnou prostředí.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Do konfiguračního souboru přidejte následující část appsettings.json .
{
"AzureMonitor": {
"ConnectionString": "<YOUR-CONNECTION-STRING>"
}
}
Poznámka:
Pokud nastavíte připojovací řetězec na více než jednom místě, dodržujeme následující prioritu:
- Code
- Proměnná prostředí
- Konfigurační soubor
Ke konfiguraci řetězce připojení použijte jeden z následujících dvou způsobů.
Přidejte exportér Azure Monitoru do každého signálu OpenTelemetry při spuštění aplikace.
// Create a new OpenTelemetry tracer provider.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(options =>
{
options.ConnectionString = "<YOUR-CONNECTION-STRING>";
})
.Build();
// Create a new OpenTelemetry meter provider.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter(options =>
{
options.ConnectionString = "<YOUR-CONNECTION-STRING>";
})
.Build();
// Create a new logger factory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(logging =>
{
logging.AddAzureMonitorLogExporter(options =>
{
options.ConnectionString = "<YOUR-CONNECTION-STRING>";
});
});
});
Nastavte proměnnou prostředí.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Poznámka:
Pokud nastavíte připojovací řetězec na více než jednom místě, dodržujeme následující prioritu:
- Code
- Proměnná prostředí
Ke konfiguraci řetězce připojení použijte jeden z následujících dvou způsobů.
Nastavte proměnnou prostředí.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Nastavte vlastnost.
applicationinsights.connection.string=<YOUR-CONNECTION-STRING>
Ke konfiguraci řetězce připojení použijte jeden z následujících dvou způsobů.
Nastavte proměnnou prostředí.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Použijte objekt konfigurace.
export class BasicConnectionSample {
static async run() {
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const options = {
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
};
const monitor = useAzureMonitor(options);
console.log("Azure Monitor initialized");
}
}
Ke konfiguraci řetězce připojení použijte jeden z následujících dvou způsobů.
Nastavte proměnnou prostředí.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
configure_azure_monitor Použijte funkci.
# Import the `configure_azure_monitor()` function from the `azure.monitor.opentelemetry` package.
from azure.monitor.opentelemetry import configure_azure_monitor
# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<YOUR-CONNECTION-STRING>` with the connection string of your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
)
Nastavení názvu cloudové role a instance cloudové role
V případě podporovaných jazyků distro Služby Azure Monitor OpenTelemetry automaticky rozpozná kontext prostředku a poskytuje výchozí hodnoty pro název cloudové role a vlastnosti instance cloudové role vaší komponenty. Můžete ale chtít přepsat výchozí hodnoty na něco, co dává vašemu týmu smysl. Hodnota názvu cloudové role se zobrazí na mapě aplikace jako název zobrazený pod uzlem.
Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá atributy service.namespace a service.name, a pokud není service.name nastaven, použije se service.namespace. Cloudová instance role používá hodnotu atributu service.instance.id. Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence OpenTelemetry.
// Setting role name and role instance
// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
{ "service.name", "my-service" },
{ "service.namespace", "my-namespace" },
{ "service.instance.id", "my-instance" }};
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry()
.UseAzureMonitor()
// Configure the ResourceBuilder to add the custom resource attributes to all signals.
// Custom resource attributes should be added AFTER AzureMonitor to override the default ResourceDetectors.
.ConfigureResource(resourceBuilder => resourceBuilder.AddAttributes(resourceAttributes));
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá atributy service.namespace a service.name, a pokud není service.name nastaven, použije se service.namespace. Cloudová instance role používá hodnotu atributu service.instance.id. Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence OpenTelemetry.
// Setting role name and role instance
// Create a dictionary of resource attributes.
var resourceAttributes = new Dictionary<string, object> {
{ "service.name", "my-service" },
{ "service.namespace", "my-namespace" },
{ "service.instance.id", "my-instance" }};
// Create a resource builder.
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);
// Create a new OpenTelemetry tracer provider and set the resource builder.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
// Set ResourceBuilder on the TracerProvider.
.SetResourceBuilder(resourceBuilder)
.AddAzureMonitorTraceExporter()
.Build();
// Create a new OpenTelemetry meter provider and set the resource builder.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
// Set ResourceBuilder on the MeterProvider.
.SetResourceBuilder(resourceBuilder)
.AddAzureMonitorMetricExporter()
.Build();
// Create a new logger factory and add the OpenTelemetry logger provider with the resource builder.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(logging =>
{
// Set ResourceBuilder on the Logging config.
logging.SetResourceBuilder(resourceBuilder);
logging.AddAzureMonitorLogExporter();
});
});
Nastavení názvu cloudové role:
- Použijte
spring.application.name pro nativní obrazové aplikace Spring Bootu.
- Použijte
quarkus.application.name pro nativní obrazové aplikace Quarkus.
Poznámka:
Komunita Quarkus podporuje a udržuje rozšíření Quarkus. Pokud potřebujete pomoc, použijte kanály podpory komunity Quarkus. Microsoft neposkytuje technickou podporu pro tuto integraci.
Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá atributy service.namespace a service.name, a pokud není service.name nastaven, použije se service.namespace. Cloudová instance role používá hodnotu atributu service.instance.id. Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence OpenTelemetry.
export class CloudRoleSample {
static async run() {
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const { resourceFromAttributes } = await import("@opentelemetry/resources");
const { ATTR_SERVICE_NAME } = await import("@opentelemetry/semantic-conventions");
const { ATTR_SERVICE_NAMESPACE, ATTR_SERVICE_INSTANCE_ID } =
await import("@opentelemetry/semantic-conventions/incubating");
const customResource = resourceFromAttributes({
[ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "my-service",
[ATTR_SERVICE_NAMESPACE]: process.env.OTEL_SERVICE_NAMESPACE || "my-namespace",
[ATTR_SERVICE_INSTANCE_ID]: process.env.OTEL_SERVICE_INSTANCE_ID || "my-instance",
});
const options = {
resource: customResource,
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
};
const monitor = useAzureMonitor(options);
console.log("Azure Monitor initialized (custom resource)");
}
}
Nastavte název cloudové role a instanci cloudové role prostřednictvím atributů prostředků . Název cloudové role používá atributy service.namespace a service.name, a pokud není service.name nastaven, použije se service.namespace. Cloudová instance role používá hodnotu atributu service.instance.id. Informace o standardních atributech pro prostředky naleznete v tématu sémantické konvence OpenTelemetry.
Nastavte atributy prostředku pomocí proměnných prostředí OTEL_RESOURCE_ATTRIBUTES a/nebo OTEL_SERVICE_NAME.
OTEL_RESOURCE_ATTRIBUTES přebírá řadu párů klíč-hodnota oddělených čárkami. Pokud například chcete nastavit název cloudové role jako my-namespace.my-helloworld-service a instanci cloudové role jako my-instance, můžete nastavit OTEL_RESOURCE_ATTRIBUTES a OTEL_SERVICE_NAME takto:
export OTEL_RESOURCE_ATTRIBUTES="service.namespace=my-namespace,service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"
Pokud nenastavíte atribut service.namespace Resource, můžete místo toho nastavit název cloudové role pomocí proměnné prostředí OTEL_SERVICE_NAME nebo atributu service.name Resource. Pokud například chcete nastavit název cloudové role jako my-helloworld-service a instanci cloudové role jako my-instance, můžete nastavit OTEL_RESOURCE_ATTRIBUTES a OTEL_SERVICE_NAME takto:
export OTEL_RESOURCE_ATTRIBUTES="service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"
Povolení vzorkování
Vzorkování snižuje objem a náklady na příjem telemetrie. Distribuce OpenTelemetry služby Azure Monitor podporuje dvě strategie vzorkování trasování a (volitelně) umožňuje sladit protokoly aplikací s rozhodováním o vzorkování trasování. Sampler připojí vybraný poměr vzorkování nebo míru k exportovaným rozsahům, aby Application Insights mohl upravit počty zkušeností přesně. Koncepční přehled najdete v tématu Další informace o vzorkování.
Důležité
- Rozhodnutí o vzorkování se vztahují na stopy (rozsahy).
-
Metriky se nikdy neprovádí vzorkování.
-
Protokoly nejsou ve výchozím nastavení vzorkovány. Můžete se přihlásit k trasování protokolů pomocí vzorkování, aby se zahodily protokoly, které patří k nesledovaným trasám. Další podrobnosti najdete v Konfiguraci trasového vzorkování pro protokoly.
Pomocí standardních proměnných prostředí OpenTelemetry vyberte sampler a zadejte jeho argument:
Následující příklady ukazují, jak nakonfigurovat vzorkování pomocí proměnných prostředí.
Vzorkování s pevným procentem (~10%)
export OTEL_TRACES_SAMPLER="microsoft.fixed.percentage"
export OTEL_TRACES_SAMPLER_ARG=0.1
Vzorkování omezené rychlostí (přibližně 1,5 trasování za sekundu)
export OTEL_TRACES_SAMPLER="microsoft.rate_limited"
export OTEL_TRACES_SAMPLER_ARG=1.5
Poznámka:
Pokud jsou nakonfigurované možnosti na úrovni kódu i proměnné prostředí, mají proměnné prostředí přednost. Výchozí chování sampleru se může lišit podle jazyka, viz následující karty.
Pevné procento vzorkování
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.SamplingRatio = 0.1F; // ~10%
});
var app = builder.Build();
app.Run();
Vzorkování s omezením rychlosti
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.TracesPerSecond = 1.5; // ~1.5 traces/sec
});
var app = builder.Build();
app.Run();
Poznámka:
Pokud v kódu nebo prostřednictvím proměnných prostředí nenastavíte sampler, Azure Monitor ve výchozím nastavení použije ApplicationInsightsSampler .
Pevné procento vzorkování
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.SamplingRatio = 0.1F)
.Build();
Vzorkování s omezením rychlosti
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.TracesPerSecond = 1.5F)
.Build();
Poznámka:
Pokud v kódu nebo prostřednictvím proměnných prostředí nenastavíte sampler, Azure Monitor ve výchozím nastavení použije ApplicationInsightsSampler .
Od verze 3.4.0 je výchozím nastavením vzorkování omezené rychlosti. Informace o možnostech konfigurace a příkladech najdete v části Vzorkování v Javě.
Pevné procento vzorkování
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
samplingRatio: 0.1, // ~10%
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
});
Vzorkování s omezením rychlosti
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
tracesPerSecond: 1.5, // ~1.5 traces/sec
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
});
Poznámka:
Pokud v kódu nebo prostřednictvím proměnných prostředí nenastavíte sampler, Azure Monitor ve výchozím nastavení použije ApplicationInsightsSampler .
Pevné procento vzorkování
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
sampling_ratio=0.1, # 0.1 = 10% of traces sampled
)
Vzorkování s omezením rychlosti
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
traces_per_second=1.5, # ~1.5 traces/sec
)
Poznámka:
Pokud nenastavíte žádné proměnné prostředí nebo neposkytnete ani sampling_ratio ani traces_per_second, ve výchozím nastavení se použije configure_azure_monitor()ApplicationInsightsSampler.
Návod
Pokud používáte vzorkování s pevným procentem a nevíte, jak nastavit vzorkovací frekvenci, začněte na 5% (0.05). Upravte rychlost podle přesnosti operací zobrazených v oknech selhání a výkonu. Jakékoli vzorkování snižuje přesnost, proto doporučujeme upozorňovat na metriky OpenTelemetry, které nejsou ovlivněné vzorkováním.
Pokud je tato možnost povolená, protokolové záznamy patřící k nevzorkovaným trasám se zahodí, aby vaše protokoly byly sladěny s vzorkováním tras.
- Záznam protokolu se považuje za součást sledování, pokud má platný
SpanId.
- Pokud přidružené trasování indikuje
TraceFlags, že není vzorkováno, záznam protokolu se zahodí.
- Záznamy protokolu bez kontextu trasování nejsou ovlivněny.
- Funkce je ve výchozím nastavení zakázaná. Povolení je jazyk, viz následující karty.
Pomocí následujícího nastavení v konfiguraci povolte vzorkování protokolů na základě trasování:
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.EnableTraceBasedLogsSampler = true;
});
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.EnableTraceBasedLogsSampler = true)
.Build();
U aplikací v Javě je ve výchozím nastavení povolené vzorkování založené na trasování.
Pro nativní aplikace Spring Boot a nativní aplikace Quarkus je ve výchozím nastavení povolené vzorkování založené na trasování.
Poznámka:
Komunita Quarkus podporuje a udržuje rozšíření Quarkus. Pokud potřebujete pomoc, použijte kanály podpory komunity Quarkus. Microsoft neposkytuje technickou podporu pro tuto integraci.
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
enableTraceBasedSamplingForLogs: true,
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
});
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
enable_trace_based_sampling_for_logs=True,
)
Živé metriky
Živé metriky poskytují řídicí panel analýzy v reálném čase pro přehled o aktivitě a výkonu aplikací.
Tato funkce je ve výchozím nastavení povolena.
Uživatelé můžou při konfiguraci distribuce zakázat živé metriky.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
// Disable the Live Metrics feature.
options.EnableLiveMetrics = false;
});
Tato funkce není k dispozici ve exportéru .NET služby Azure Monitor.
Živé metriky nejsou dnes k dispozici pro nativní aplikace GraalVM.
Uživatelé mohou povolit nebo zakázat živé metriky při konfiguraci distribuce pomocí enableLiveMetrics vlastnosti.
export class LiveMetricsSample {
static async run() {
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const options = {
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
enableLiveMetrics: true, // set to false to disable
};
const monitor = useAzureMonitor(options);
console.log("Azure Monitor initialized (live metrics enabled)");
}
}
Živé metriky můžete povolit pomocí distribuce OpenTelemetry pro Azure Monitor pro Python následujícím způsobem:
...
configure_azure_monitor(
enable_live_metrics=True
)
...
Možná budete chtít povolit ověřování Microsoft Entra pro bezpečnější připojení k Azure, které brání neoprávněné telemetrii v ingestování do vašeho předplatného.
Další informace najdete na naší vyhrazené ověřovací stránce Microsoft Entra propojené pro každý podporovaný jazyk.
Ověřování Microsoft Entra ID není dostupné pro nativní aplikace GraalVM.
Offline úložiště a automatické opakování
Nabídky založené na OpenTelemetry služby Azure Monitor ukládají telemetrii do mezipaměti, když se aplikace odpojí od Application Insights a opakuje odesílání po dobu až 48 hodin. Doporučení pro zpracování dat najdete v tématu Export a odstranění privátních dat. Aplikace s vysokým zatížením občas zahazují telemetrii ze dvou důvodů: překročení povolené doby nebo překročení maximální velikosti souboru. V případě potřeby produkt upřednostňuje nedávné události oproti starým událostem.
Balíček Distro obsahuje AzureMonitorExporter, který ve výchozím nastavení používá pro offline úložiště jedno z následujících umístění (v pořadí podle priority):
Windows
- %LOCALAPPDATA%\Microsoft\AzureMonitor
- %TEMP%\Microsoft\AzureMonitor
Jiné než Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
- /tmp/Microsoft/AzureMonitor
Pokud chcete přepsat výchozí adresář, měli byste nastavit AzureMonitorOptions.StorageDirectory.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any telemetry data that can't be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Chcete-li tuto funkci zakázat, měli byste nastavit AzureMonitorOptions.DisableOfflineStorage = true.
AzureMonitorExporter ve výchozím nastavení používá pro offline úložiště jedno z následujících umístění (v pořadí podle priority):
Windows
- %LOCALAPPDATA%\Microsoft\AzureMonitor
- %TEMP%\Microsoft\AzureMonitor
Jiné než Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
- /tmp/Microsoft/AzureMonitor
Pokud chcete přepsat výchozí adresář, měli byste nastavit AzureMonitorExporterOptions.StorageDirectory.
// Create a new OpenTelemetry tracer provider and set the storage directory.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any trace data that can't be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
})
.Build();
// Create a new OpenTelemetry meter provider and set the storage directory.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any metric data that can't be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
})
.Build();
// Create a new logger factory and add the OpenTelemetry logger provider with the storage directory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(logging =>
{
logging.AddAzureMonitorLogExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any log data that can't be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
});
});
Chcete-li tuto funkci zakázat, měli byste nastavit AzureMonitorExporterOptions.DisableOfflineStorage = true.
Když agent nemůže odesílat telemetrii do služby Azure Monitor, ukládá na disk soubory telemetrie. Soubory jsou uloženy ve telemetry složce pod adresářem určeným java.io.tmpdir systémovou vlastností. Každý název souboru začíná časovým razítkem a končí příponou .trn . Tento offline mechanismus úložiště pomáhá zajistit zachování telemetrie během dočasných výpadků sítě nebo selhání příjmu dat.
Agent ve výchozím nastavení ukládá až 50 MB telemetrických dat a umožňuje konfiguraci limitu úložiště. Pokusy o odesílání uložených telemetrických dat se pravidelně provádějí. Soubory telemetrie starší než 48 hodin se odstraní a při dosažení limitu úložiště se nejstarší události zahodí.
Úplný seznam dostupných konfigurací najdete v tématu Možnosti konfigurace.
Když agent nemůže odesílat telemetrii do služby Azure Monitor, ukládá na disk soubory telemetrie. Soubory jsou uloženy ve telemetry složce pod adresářem určeným java.io.tmpdir systémovou vlastností. Každý název souboru začíná časovým razítkem a končí příponou .trn . Tento offline mechanismus úložiště pomáhá zajistit zachování telemetrie během dočasných výpadků sítě nebo selhání příjmu dat.
Agent ve výchozím nastavení ukládá až 50 MB telemetrických dat. Pokusy o odesílání uložených telemetrických dat se pravidelně provádějí. Soubory telemetrie starší než 48 hodin se odstraní a při dosažení limitu úložiště se nejstarší události zahodí.
Ve výchozím nastavení azureMonitorExporter používá pro offline úložiště jednu z následujících umístění.
Windows
- %TEMP%\Microsoft\AzureMonitor
Jiné než Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
Pokud chcete přepsat výchozí adresář, měli byste nastavit storageDirectory.
Příklad:
export class OfflineStorageSample {
static async run() {
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const options = {
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
storageDirectory: "C:\\\\SomeDirectory",
disableOfflineStorage: false, // set to true to disable
},
};
const monitor = useAzureMonitor(options);
console.log("Azure Monitor initialized (offline storage configured)");
}
}
Chcete-li tuto funkci zakázat, měli byste nastavit disableOfflineStorage = true.
Ve výchozím nastavení používají exportéři služby Azure Monitor následující cestu:
<tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>
Chcete-li přepsat výchozí adresář, měli byste nastavit storage_directory na požadovaný adresář.
Příklad:
...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and storage directory.
# Replace `<YOUR-CONNECTION-STRING>` with the connection string to your Azure Monitor Application Insights resource.
# Replace `C:\\SomeDirectory` with the directory where you want to store the telemetry data before it is sent to Azure Monitor.
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
storage_directory="C:\\SomeDirectory",
)
...
Chcete-li tuto funkci zakázat, měli byste nastavit disable_offline_storage hodnotu True. Výchozí hodnota je False.
Příklad:
...
# Configure OpenTelemetry to use Azure Monitor with the specified connection string and disable offline storage.
# Replace `<YOUR-CONNECTION-STRING>` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
disable_offline_storage=True,
)
...
Povolení vývozce OTLP
Možná budete chtít povolit exportér openTelemetry Protocol (OTLP) společně s exportérem služby Azure Monitor, aby odesílal telemetrická data do dvou umístění.
Poznámka:
Vývozce OTLP se zobrazuje pouze pro usnadnění. Oficiálně nepodporujeme vývozce OTLP ani žádné komponenty nebo zážitky třetích stran, které na něj navazují.
Do projektu nainstalujte balíček OpenTelemetry.Exporter.OpenTelemetryProtocol.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v příkladu na GitHubu.
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);
// Add the OpenTelemetry telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();
// Add the OpenTelemetry OTLP exporter to the application.
// This exporter will send telemetry data to an OTLP receiver, such as Prometheus
builder.Services.AddOpenTelemetry().WithTracing(builder => builder.AddOtlpExporter());
builder.Services.AddOpenTelemetry().WithMetrics(builder => builder.AddOtlpExporter());
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Do projektu nainstalujte balíček OpenTelemetry.Exporter.OpenTelemetryProtocol.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v příkladu na GitHubu.
// Create a new OpenTelemetry tracer provider and add the Azure Monitor trace exporter and the OTLP trace exporter.
// It is important to keep the TracerProvider instance active throughout the process lifetime.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter()
.AddOtlpExporter()
.Build();
// Create a new OpenTelemetry meter provider and add the Azure Monitor metric exporter and the OTLP metric exporter.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter()
.AddOtlpExporter()
.Build();
Nemůžete povolit exportér protokolu OpenTelemetry (OTLP) společně s exportérem služby Azure Monitor, aby odesílal telemetrická data do dvou umístění.
Nainstalujte si v projektu exportér tras kolektoru OpenTelemetry a další balíčky OpenTelemetry.
npm install @opentelemetry/api
npm install @opentelemetry/exporter-trace-otlp-http
npm install @opentelemetry/sdk-trace-base
npm install @opentelemetry/sdk-trace-node
Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v příkladu na GitHubu.
export class OtlpExporterSample {
static async run() {
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const { BatchSpanProcessor } = await import("@opentelemetry/sdk-trace-base");
const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");
// Create an OTLP trace exporter (set 'url' if your collector isn't on the default endpoint).
const otlpExporter = new OTLPTraceExporter({
// url: "http://localhost:4318/v1/traces",
});
// Configure Azure Monitor and add the OTLP exporter as an additional span processor.
const options = {
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
spanProcessors: [new BatchSpanProcessor(otlpExporter)],
};
const monitor = useAzureMonitor(options);
console.log("Azure Monitor initialized (OTLP exporter added)");
}
}
Nainstalujte balíček opentelemetry-export-otlp.
Přidejte následující fragment kódu. Tento příklad předpokládá, že máte kolektor OpenTelemetry se spuštěným přijímačem OTLP. Podrobnosti najdete v tomto souboru README.
# Import the `configure_azure_monitor()`, `trace`, `OTLPSpanExporter`, and `BatchSpanProcessor` classes from the appropriate packages.
from azure.monitor.opentelemetry import configure_azure_monitor
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor
# Configure OpenTelemetry to use Azure Monitor with the specified connection string.
# Replace `<YOUR-CONNECTION-STRING>` with the connection string to your Azure Monitor Application Insights resource.
configure_azure_monitor(
connection_string="<YOUR-CONNECTION-STRING>",
)
# Get the tracer for the current module.
tracer = trace.get_tracer(__name__)
# Create an OTLP span exporter that sends spans to the specified endpoint.
# Replace `http://localhost:4317` with the endpoint of your OTLP collector.
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317")
# Create a batch span processor that uses the OTLP span exporter.
span_processor = BatchSpanProcessor(otlp_exporter)
# Add the batch span processor to the tracer provider.
trace.get_tracer_provider().add_span_processor(span_processor)
# Start a new span with the name "test".
with tracer.start_as_current_span("test"):
print("Hello world!")
Konfigurace OpenTelemetry
K následujícím konfiguracím OpenTelemetry je možné přistupovat prostřednictvím proměnných prostředí při použití distros openTelemetry služby Azure Monitor.
| Proměnná prostředí |
Popis |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Nastavte jej na připojovací řetězec prostředku Application Insights. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Nastavte ji na true, aby se zrušil interní sběr metrik. |
OTEL_RESOURCE_ATTRIBUTES |
Páry klíčů a hodnot určené k použití jako atributy prostředků. Další informace o atributech prostředků najdete ve specifikaci Resource SDK. |
OTEL_SERVICE_NAME |
Nastaví hodnotu atributu service.name prostředku. Pokud service.name je také uveden v OTEL_RESOURCE_ATTRIBUTES, pak OTEL_SERVICE_NAME má přednost. |
| Proměnná prostředí |
Popis |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Nastavte jej na připojovací řetězec prostředku Application Insights. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Nastavte ji na true, aby se zrušil interní sběr metrik. |
OTEL_RESOURCE_ATTRIBUTES |
Páry klíčů a hodnot určené k použití jako atributy prostředků. Další informace o atributech prostředků najdete ve specifikaci Resource SDK. |
OTEL_SERVICE_NAME |
Nastaví hodnotu atributu service.name prostředku. Pokud service.name je také uveden v OTEL_RESOURCE_ATTRIBUTES, pak OTEL_SERVICE_NAME má přednost. |
| Proměnná prostředí |
Popis |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Nastavte jej na připojovací řetězec prostředku Application Insights. |
Pro nativní aplikace Spring Boot jsou k dispozici konfigurace sady Java SDK OpenTelemetry.
Informace o nativních aplikacích Quarkus najdete v dokumentaci Quarkus OpenTelemetry.
Poznámka:
Komunita Quarkus podporuje a udržuje rozšíření Quarkus. Pokud potřebujete pomoc, použijte kanály podpory komunity Quarkus. Microsoft neposkytuje technickou podporu pro tuto integraci.
Další informace o konfiguraci sady OpenTelemetry SDK najdete v dokumentaci k OpenTelemetry.
Další informace o konfiguraci sady OpenTelemetry SDK najdete v dokumentaci k OpenTelemetry a využití distribuce služby Azure Monitor.
Redigovat dotazy URL
Pokud chcete odstranit řetězce dotazů v adresách URL, vypněte sběr řetězců dotazů. Toto nastavení doporučujeme, pokud voláte úložiště Azure pomocí tokenu SAS.
Pokud používáte balíček distribuce Azure.Monitor.OpenTelemetry.AspNetCore , jsou zahrnuty knihovny instrumentace ASP.NET Core i HttpClient .
Náš distribuční balíček vypne ve výchozím nastavení redakci řetězce dotazu.
Chcete-li toto chování změnit, je nutné nastavit proměnnou prostředí na true nebo false.
ASP.NET základní instrumentace: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION Ve výchozím nastavení je redakce řetězce dotazu zakázaná. Chcete-li tuto proměnnou prostředí povolit, nastavte ji na falsehodnotu .
Instrumentace klienta HTTP: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION Redigování řetězce dotazu je standardně zakázáno. Chcete-li tuto proměnnou prostředí povolit, nastavte ji na falsehodnotu .
Pokud používáte Azure.Monitor.OpenTelemetry.Exportér, musíte do konfigurace OpenTelemetry zahrnout knihovny ASP.NET Core nebo HttpClient Instrumentation.
Tyto knihovny instrumentace mají ve výchozím nastavení povolenou funkci QueryString Redaction.
Chcete-li toto chování změnit, je nutné nastavit proměnnou prostředí na true nebo false.
ASP.NET základní instrumentace: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION Ve výchozím nastavení je povolená redakce řetězce dotazu. Chcete-li zakázat, nastavte tuto proměnnou prostředí na true.
Instrumentace klienta HTTP: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION Redakce řetězce dotazu je ve výchozím nastavení povolena. Chcete-li zakázat, nastavte tuto proměnnou prostředí na true.
Do konfiguračního applicationinsights.json souboru přidejte následující:
{
"preview": {
"processors": [
{
"type": "attribute",
"actions": [
{
"key": "url.query",
"pattern": "^.*$",
"replace": "REDACTED",
"action": "mask"
}
]
},
{
"type": "attribute",
"actions": [
{
"key": "url.full",
"pattern": "[?].*$",
"replace": "?REDACTED",
"action": "mask"
}
]
}
]
}
}
Aktivně pracujeme v komunitě OpenTelemetry na podporu redakce.
Při použití balíčku distribuce OpenTelemetry služby Azure Monitor je možné řetězce dotazů redactovat prostřednictvím vytvoření a použití procesoru span na konfiguraci distribuce.
export class RedactQueryStringsSample {
static async run() {
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const { SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_URL } =
await import("@opentelemetry/semantic-conventions");
class RedactQueryStringProcessor {
forceFlush() { return Promise.resolve(); }
onStart() {}
shutdown() { return Promise.resolve(); }
onEnd(span: any) {
const route = String(span.attributes[SEMATTRS_HTTP_ROUTE] ?? "");
const url = String(span.attributes[SEMATTRS_HTTP_URL] ?? "");
const target = String(span.attributes[SEMATTRS_HTTP_TARGET] ?? "");
const strip = (s: string) => {
const i = s.indexOf("?");
return i === -1 ? s : s.substring(0, i);
};
if (route) span.attributes[SEMATTRS_HTTP_ROUTE] = strip(route);
if (url) span.attributes[SEMATTRS_HTTP_URL] = strip(url);
if (target) span.attributes[SEMATTRS_HTTP_TARGET] = strip(target);
}
}
const options = {
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
spanProcessors: [new RedactQueryStringProcessor()],
};
const monitor = useAzureMonitor(options);
console.log("Azure Monitor initialized (query strings redacted)");
}
}
Aktivně pracujeme v komunitě OpenTelemetry na podporu redakce.
Interval exportu metriky
Interval exportu metrik můžete nakonfigurovat pomocí proměnné prostředí OTEL_METRIC_EXPORT_INTERVAL.
OTEL_METRIC_EXPORT_INTERVAL=60000
Výchozí hodnota je 60000 milisekundy (60 sekund). Toto nastavení určuje, jak často sada OpenTelemetry SDK exportuje metriky.
Návod
Metriky Azure Monitor a pracovní prostor Azure Monitor ingestují vlastní metriky v pevném 60sekundovém intervalu. Metriky odeslané častěji se ukládají do vyrovnávací paměti a zpracovávají se jednou za 60 sekund. Log Analytics zaznamenává metriky v intervalu, v jakém se odesílají, což může zvýšit náklady v kratších intervalech a zpozdit viditelnost u delších.
Referenční informace najdete v následujících specifikacích OpenTelemetry: