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>
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_monitorPouž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 aplikace Spring Boot s nativními obrazy.
- Použijte nativní image
quarkus.application.name pro 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é
Rozsah vzorkování
- Rozhodnutí o vzorkování se vztahují na stopy (rozsahy).
-
Metriky se nikdy nevzorkují.
- Protokoly nejsou ve výchozím nastavení vzorkovány. Můžete se rozhodnout pro vzorkování založené na trasách pro protokoly tak, aby byly protokoly, které patří k nevzorkovaným trasám, vyřazeny (podrobnosti níže).
Pomocí standardních proměnných prostředí OpenTelemetry vyberte sampler a zadejte jeho argument:
-
OTEL_TRACES_SAMPLER — typ vzorkovníku
-
microsoft.fixed.percentage — vybrat zlomek tras.
-
microsoft.rate_limited — maximální počet stop za sekundu.
-
OTEL_TRACES_SAMPLER_ARG — argument vzorkovníku
- Pro
microsoft.fixed.percentage: hodnota v rozmezí 0,0–1,0 (například 0.1 = ~10%).
- Pro
microsoft.rate_limited: maximální počet trasování za sekundu (například 1.5).
Examples
# Fixed percentage (~10%)
export OTEL_TRACES_SAMPLER="microsoft.fixed.percentage"
export OTEL_TRACES_SAMPLER_ARG=0.1
# Rate-limited (~1.5 traces/sec)
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 – podívejte se na karty.
Vzorkování pomocí trasování pro záznamy
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.
Chování
- 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í funkce je specifické pro jazyk – viz karty.
Vzorkování můžete nakonfigurovat v kódu nebo pomocí výše uvedených proměnných prostředí.
Pevné procento
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.SamplingRatio = 0.1F; // ~10%
});
var app = builder.Build();
app.Run();
Omezení 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 .
Vzorkování pomocí trasování pro záznamy
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.EnableTraceBasedLogsSampler = true;
});
Vzorkování můžete nakonfigurovat v kódu nebo pomocí výše uvedených proměnných prostředí.
Pevné procento
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.SamplingRatio = 0.1F)
.Build();
Omezení 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 .
Vzorkování pomocí trasování pro záznamy
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.EnableTraceBasedLogsSampler = true)
.Build();
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ě.
Nakonfigurujte vzorkování v kódu nebo pomocí výše uvedených proměnných prostředí.
Pevné procento
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
samplingRatio: 0.1, // ~10%
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
},
});
Omezení 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 .
Vzorkování pomocí trasování pro záznamy
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
enableTraceBasedSamplingForLogs: true,
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<your-connection-string>",
},
});
Nakonfigurujte vzorkování v kódu nebo pomocí výše uvedených proměnných prostředí.
Pevné procento
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
)
Omezení 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í ani nezadáte sampling_ratio nebo traces_per_second, configure_azure_monitor() ve výchozím nastavení použije ApplicationInsightsSampler.
Vzorkování pomocí trasování pro záznamy
from azure.monitor.opentelemetry import configure_azure_monitor
configure_azure_monitor(
connection_string="<your-connection-string>",
enable_trace_based_sampling_for_logs=True,
)
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.
Ž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 cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
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 cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
})
.Build();
// Create a new OpenTelemetry meter provider and set the storage directory.
// It is important to keep the MetricsProvider instance active throughout the process lifetime.
var metricsProvider = Sdk.CreateMeterProviderBuilder()
.AddAzureMonitorMetricExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any metric data that cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
})
.Build();
// Create a new logger factory and add the OpenTelemetry logger provider with the storage directory.
// It is important to keep the LoggerFactory instance active throughout the process lifetime.
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(logging =>
{
logging.AddAzureMonitorLogExporter(options =>
{
// Set the Azure Monitor storage directory to "C:\\SomeDirectory".
// This is the directory where the OpenTelemetry SDK will store any log data that cannot be sent to Azure Monitor immediately.
options.StorageDirectory = "C:\\SomeDirectory";
});
});
});
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: