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.
// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
// Create a new AzureMonitorOpenTelemetryOptions object.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString: "<your connection string>"
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
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 aplikace Spring Boot s nativními obrazy.
- Použijte nativní image
quarkus.application.name
pro aplikace Quarkus
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.
// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, the Resource class, and the SemanticResourceAttributes class from the @azure/monitor-opentelemetry, @opentelemetry/resources, and @opentelemetry/semantic-conventions packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { Resource } = require("@opentelemetry/resources");
const { SemanticResourceAttributes } = require("@opentelemetry/semantic-conventions");
// Create a new Resource object with the following custom resource attributes:
//
// * service_name: my-service
// * service_namespace: my-namespace
// * service_instance_id: my-instance
const customResource = new Resource({
[SemanticResourceAttributes.SERVICE_NAME]: "my-service",
[SemanticResourceAttributes.SERVICE_NAMESPACE]: "my-namespace",
[SemanticResourceAttributes.SERVICE_INSTANCE_ID]: "my-instance",
});
// Create a new AzureMonitorOpenTelemetryOptions object and set the resource property to the customResource object.
const options: AzureMonitorOpenTelemetryOptions = {
resource: customResource
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
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í
Můžete chtít povolit vzorkování, abyste snížili objem příjmu dat, což snižuje náklady. Azure Monitor poskytuje vlastní sampler s pevnou sazbou, který vybavuje události vzorkovacím poměrem, který Application Insights převede na ItemCount
. Vzorkovník s pevnou rychlostí zajišťuje přesné zkušenosti a počty událostí. Sampler je navržen, aby zachoval vaše stopy mezi službami a je interoperabilní se staršími sadami Application Insights Software Development Kits (SDK). Další informace najdete v tématu Další informace o vzorkování.
Poznámka:
Na metriky a protokoly nemá vzorkování vliv.
Pokud se vám v Application Insights zobrazují neočekávané poplatky nebo vysoké náklady, může vám pomoct tento průvodce. Zahrnuje běžné příčiny, jako jsou vysoké objemy telemetrie, špičky příjmu dat a chybně nakonfigurované vzorkování. Je zvlášť užitečné, pokud řešíte problémy související se špičkami nákladů, objemem telemetrie, nefunkčním vzorkováním, limity dat, vysokým příjmem dat nebo neočekávanou fakturací. Pokud chcete začít, přečtěte si téma Řešení potíží s vysokým příjmem dat ve službě Application Insights.
Vzorkovač očekává vzorkovací poměr od 0 do 1 včetně. Míra 0,1 znamená, že se odesílá přibližně 10 % vašich trasování.
// 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 sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
options.SamplingRatio = 0.1F;
});
// Build the ASP.NET Core web application.
var app = builder.Build();
// Start the ASP.NET Core web application.
app.Run();
Vzorkovač očekává vzorkovací poměr od 0 do 1 včetně. Míra 0,1 znamená, že se odesílá přibližně 10 % vašich trasování.
// 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 =>
{
// Set the sampling ratio to 10%. This means that 10% of all traces will be sampled and sent to Azure Monitor.
options.SamplingRatio = 0.1F;
})
.Build();
Od verze 3.4.0 je k dispozici vzorkování s omezením rychlosti a je teď výchozí. Další informace o vzorkování najdete v tématu Vzorkování v Javě.
Pro nativní aplikace Spring Boot platí konfigurace vzorkování sady OpenTelemetry Java SDK.
Informace o nativních aplikacích Quarkus najdete v dokumentaci Quarkus OpenTelemetry.
Vzorkovač očekává vzorkovací poměr od 0 do 1 včetně. Míra 0,1 znamená, že se odesílá přibližně 10 % vašich trasování.
// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
// Create a new AzureMonitorOpenTelemetryOptions object and set the samplingRatio property to 0.1.
const options: AzureMonitorOpenTelemetryOptions = {
samplingRatio: 0.1
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
Funkce configure_azure_monitor()
automaticky využívá ApplicationInsightsSampler pro zajištění kompatibility se sadami Application Insights SDK a ukázkovou telemetrii. Proměnnou OTEL_TRACES_SAMPLER_ARG
prostředí lze použít k určení vzorkovací frekvence s platným rozsahem 0 až 1, kde 0 je 0 % a 1 je 100 %.
Například hodnota 0,1 znamená, že se odešle 10 % vašich stop.
export OTEL_TRACES_SAMPLER_ARG=0.1
Návod
Pokud používáte vzorkování s pevnou rychlostí nebo procentem a nevíte, jak nastavit vzorkovací frekvenci, začněte na 5 %. (Poměr vzorkování 0,05) Upravte míru na základě přesnosti operací zobrazených v panelech selhání a výkonu. Vyšší míra obecně vede k vyšší přesnosti. Vzorkování jakékoliv má ale vliv na 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.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString:
process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
},
enableLiveMetrics: false
};
useAzureMonitor(options);
Ž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:
// Import the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions class from the @azure/monitor-opentelemetry package.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
// Create a new AzureMonitorOpenTelemetryOptions object and set the azureMonitorExporterOptions property to an object with the following properties:
//
// * connectionString: The connection string for your Azure Monitor Application Insights resource.
// * storageDirectory: The directory where the Azure Monitor OpenTelemetry exporter will store telemetry data when it is offline.
// * disableOfflineStorage: A boolean value that specifies whether to disable offline storage.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString: "<Your Connection String>",
storageDirectory: "C:\\SomeDirectory",
disableOfflineStorage: false
}
};
// Enable Azure Monitor integration using the useAzureMonitor function and the AzureMonitorOpenTelemetryOptions object.
useAzureMonitor(options);
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.
// Import the useAzureMonitor function, the AzureMonitorOpenTelemetryOptions class, the trace module, the ProxyTracerProvider class, the BatchSpanProcessor class, the NodeTracerProvider class, and the OTLPTraceExporter class from the @azure/monitor-opentelemetry, @opentelemetry/api, @opentelemetry/sdk-trace-base, @opentelemetry/sdk-trace-node, and @opentelemetry/exporter-trace-otlp-http packages, respectively.
const { useAzureMonitor, AzureMonitorOpenTelemetryOptions } = require("@azure/monitor-opentelemetry");
const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
// Create a new OTLPTraceExporter object.
const otlpExporter = new OTLPTraceExporter();
// Enable Azure Monitor integration.
const options: AzureMonitorOpenTelemetryOptions = {
// Add the SpanEnrichingProcessor
spanProcessors: [new BatchSpanProcessor(otlpExporter)]
}
useAzureMonitor(options);
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.
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 false
hodnotu .
- 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 false
hodnotu .
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.
import { useAzureMonitor, AzureMonitorOpenTelemetryOptions } from "@azure/monitor-opentelemetry";
import { Context } from "@opentelemetry/api";
import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
import { SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_URL } from "@opentelemetry/semantic-conventions";
class RedactQueryStringProcessor implements SpanProcessor {
forceFlush(): Promise<void> {
return Promise.resolve();
}
onStart(span: Span, parentContext: Context): void {
return;
}
shutdown(): Promise<void> {
return Promise.resolve();
}
onEnd(span: ReadableSpan) {
const httpRouteIndex: number = String(span.attributes[SEMATTRS_HTTP_ROUTE]).indexOf('?');
const httpUrlIndex: number = String(span.attributes[SEMATTRS_HTTP_URL]).indexOf('?');
const httpTargetIndex: number = String(span.attributes[SEMATTRS_HTTP_TARGET]).indexOf('?');
if (httpRouteIndex !== -1) {
span.attributes[SEMATTRS_HTTP_ROUTE] = String(span.attributes[SEMATTRS_HTTP_ROUTE]).substring(0, httpRouteIndex);
}
if (httpUrlIndex !== -1) {
span.attributes[SEMATTRS_HTTP_URL] = String(span.attributes[SEMATTRS_HTTP_URL]).substring(0, httpUrlIndex);
}
if (httpTargetIndex !== -1) {
span.attributes[SEMATTRS_HTTP_TARGET] = String(span.attributes[SEMATTRS_HTTP_TARGET]).substring(0, httpTargetIndex);
}
}
}
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString: <YOUR_CONNECTION_STRING>,
},
spanProcessors: [new RedactQueryStringProcessor()]
};
useAzureMonitor(options);
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: