Ez az útmutató az OpenTelemetria (OTel) Azure Monitor Application Insights Azure Monitor OpenTelemetria-disztribúcióval történő konfigurálását ismerteti. A megfelelő konfiguráció konzisztens telemetriai adatgyűjtést biztosít .NET, Java, Node.jsés Python alkalmazásokban, így megbízhatóbb monitorozást és diagnosztikát tesz lehetővé.
Kapcsolati karakterlánc
Az Application Insightsban egy kapcsolati karakterlánc határozza meg a telemetriai adatok küldésének célhelyét.
Az alábbi három módszer egyikével konfigurálhatja a kapcsolati karakterlánc:
Adja hozzá a UseAzureMonitor() elemet a program.cs fájljához.
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();
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Adja hozzá a következő szakaszt a appsettings.json konfigurációs fájlhoz.
{
"AzureMonitor": {
"ConnectionString": "<YOUR-CONNECTION-STRING>"
}
}
Feljegyzés
Ha a kapcsolati karakterláncot egynél több helyen állítja be, a következő sorrend vonatkozik ezekre:
- Kód
- Környezeti változó
- Konfigurációs fájl
A kapcsolati karakterlánc az alábbi két módszer egyikével konfigurálhatja:
Adja hozzá a Azure Monitor-exportőrt az alkalmazás indításakor az egyes OpenTelemetry-jelekhez.
// 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>";
});
});
});
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Feljegyzés
Ha a kapcsolati karakterláncot egynél több helyen állítja be, a következő sorrend vonatkozik ezekre:
- Kód
- Környezeti változó
Az alábbi három módszer egyikével konfigurálhatja a kapcsolati karakterlánc:
Adja hozzá a következő szakaszt a applicationinsights.json konfigurációs fájlhoz.
{
"connectionString": "..."
}
A kapcsolati karakterlánc úgy is beállíthatja, hogy megad egy fájlt, amelyből betölti. A fájlnak csak a kapcsolati karakterlánc és semmi mást kell tartalmaznia. Ha relatív elérési utat ad meg, az a könyvtárhoz képest oldódik fel, ahol applicationinsights-agent-3.7.8.jar található.
{
"connectionString": "${file:connection-string-file.txt}"
}
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING
Adja hozzá a applicationinsights.connection.string értéket rendszertulajdonságként.
java -javaagent:/path/to/applicationinsights-agent-3.7.8.jar \
-Dapplicationinsights.connection.string="<YOUR-CONNECTION-STRING>" \
-jar myapp.jar
Feljegyzés
Ha a kapcsolati karakterláncet több helyen állítja be, az alábbi sorrendet követjük:
- Rendszer-tulajdonság
- Környezeti változó
- Konfigurációs fájl
Ha több alkalmazást helyez üzembe ugyanabban a Java virtuális gépen (JVM), és azt szeretné, hogy telemetriát küldjenek különböző kapcsolati sztringeknek, tekintse meg a Kapcsolódási sztring felülbírálásait (előzetes verzió).
A kapcsolati karakterlánc konfigurálásához használja az alábbi két módszer egyikét:
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Adjon meg egy tulajdonságot.
applicationinsights.connection.string=<YOUR-CONNECTION-STRING>
A kapcsolati karakterlánc konfigurálásához használja az alábbi két módszer egyikét:
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Használjon konfigurációs objektumot.
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");
}
}
A kapcsolati karakterlánc konfigurálásához használja az alábbi két módszer egyikét:
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING=<YOUR-CONNECTION-STRING>
Használja a függvényt configure_azure_monitor .
# 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>",
)
A felhőbeli szerepkör nevének és a felhőbeli szerepkörpéldánynak a beállítása
A támogatott nyelvek esetében a Azure Monitor OpenTelemetry Distro automatikusan észleli az erőforrás-környezetet, és alapértelmezett értékeket biztosít a Cloud szerepkörnév és az összetevő felhőbeli szerepkörpéldány-tulajdonságaihoz. Előfordulhat azonban, hogy felül szeretné bírálni az alapértelmezett értékeket a csapat számára értelmes értékekkel. A felhőbeli szerepkörnév értéke az alkalmazástérképen a csomópont alatti névként jelenik meg.
Állítsa be a Cloud szerepkör nevét és a Cloud szerepkör példányát az erőforrás attribútumokon keresztül. A felhőszerepkör neve service.namespace és service.name attribútumokat használ, de service.name-t alkalmaz, ha service.namespace nincs beállítva. A felhőbeli szerepkör-példány az attribútumértéket service.instance.id használja. Az erőforrások szabványos attribútumairól az OpenTelemetry Szemantikai Konvenciók című témakörben olvashat bővebben.
// 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();
Állítsa be a Cloud szerepkör nevét és a Cloud szerepkör példányát az erőforrás attribútumokon keresztül. A felhőszerepkör neve service.namespace és service.name attribútumokat használ, de service.name-t alkalmaz, ha service.namespace nincs beállítva. A felhőbeli szerepkör-példány az attribútumértéket service.instance.id használja. Az erőforrások szabványos attribútumairól az OpenTelemetry Szemantikai Konvenciók című témakörben olvashat bővebben.
// 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();
});
});
Feljegyzés
Ha nem állítja be a felhőbeli szerepkör nevét és a felhőbeli szerepkörpéldányt, a felhőbeli szerepkör neve alapértelmezés szerint az Application Insights-erőforrás neve lesz, a felhőbeli szerepkörpéldány pedig alapértelmezés szerint a gép neve.
A következő három módszer egyikével konfigurálhatja a felhőbeli szerepkör nevét és a felhőbeli szerepkörpéldányt:
Adja hozzá a következő szakaszt a applicationinsights.json konfigurációs fájlhoz.
{
"role": {
// Set the cloud role name
"name": "my cloud role name",
// Set the cloud role instance
"instance": "my cloud role instance"
}
}
Környezeti változók beállítása.
APPLICATIONINSIGHTS_ROLE_NAME
APPLICATIONINSIGHTS_ROLE_INSTANCE
Adja hozzá a applicationinsights.role.name és a applicationinsights.role.instance rendszertulajdonságként.
java -javaagent:/path/to/applicationinsights-agent-3.7.8.jar \
-Dapplicationinsights.role.name="my-cloud-role-name" \
-Dapplicationinsights.role.instance="my-cloud-role-instance" \
-jar myapp.jar
Feljegyzés
Ha a felhőbeli szerepkör nevét és a felhőbeli szerepkörpéldányt több helyen állítja be, a következő sorrend érvényes:
- Rendszer-tulajdonság
- Környezeti változó
- Konfigurációs fájl
Ha több alkalmazást helyez üzembe ugyanabban a JVM-ben, és azt szeretné, hogy telemetriát küldjenek különböző felhőbeli szerepkörnevekre, tekintse meg a felhőszerepkör-név felülbírálásait (előzetes verzió).
A felhőbeli szerepkör nevének beállítása:
- Használja a
spring.application.name a Spring Boot natív image alkalmazásaihoz.
- Használjon
quarkus.application.name Quarkus natív image alkalmazásokhoz.
Feljegyzés
A Quarkus-közösség támogatja és fenntartja a Quarkus-bővítményeket. Segítségért használja a Quarkus közösségi támogatási csatornáját. Microsoft nem nyújt technikai támogatást ehhez az integrációhoz.
Állítsa be a Cloud szerepkör nevét és a Cloud szerepkör példányát az erőforrás attribútumokon keresztül. A felhőszerepkör neve service.namespace és service.name attribútumokat használ, de service.name-t alkalmaz, ha service.namespace nincs beállítva. A felhőbeli szerepkör-példány az attribútumértéket service.instance.id használja. Az erőforrások szabványos attribútumairól az OpenTelemetry Szemantikai Konvenciók című témakörben olvashat bővebben.
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)");
}
}
Állítsa be a felhőbeli szerepkör nevét és a felhőbeli szerepkörpéldányt erőforrásattribútumokon keresztül. A felhő szerepkör neve használja a service.namespace és service.name attribútumokat, bár a service.name-t használja helyette, ha a service.namespace nincs beállítva. A felhőbeli szerepkör-példány az attribútumértéket service.instance.id használja. Az erőforrások szabványos attribútumairól az OpenTelemetry Szemantikai Konvenciók című témakörben olvashat bővebben.
Állítsa be az erőforrásattribútumokat a OTEL_RESOURCE_ATTRIBUTES és/vagy a OTEL_SERVICE_NAME környezeti változók használatával.
OTEL_RESOURCE_ATTRIBUTES vesszővel elválasztott kulcs-érték párok sorozatát veszi fel. Például, ha a Felhő Szerepkör Nevet my-namespace.my-helloworld-service-ra szeretné állítani és a Felhő Szerepkör Példányt my-instance-ra, akkor az alábbiak szerint állíthatja be OTEL_RESOURCE_ATTRIBUTES és OTEL_SERVICE_NAME:
export OTEL_RESOURCE_ATTRIBUTES="service.namespace=my-namespace,service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"
Ha nem állítja be az service.namespace Erőforrás attribútumot, a felhőalapú szerepkör nevét is beállíthatja csak a OTEL_SERVICE_NAME környezeti változóval vagy az service.name Erőforrás attribútummal. Például, ha a Felhő Szerepkör Nevet my-helloworld-service-ra szeretné állítani és a Felhő Szerepkör Példányt my-instance-ra, akkor az alábbiak szerint állíthatja be OTEL_RESOURCE_ATTRIBUTES és OTEL_SERVICE_NAME:
export OTEL_RESOURCE_ATTRIBUTES="service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"
Erőforrásattribútumok beállítása
Az automatikus instrumentáció és az Azure Monitor disztribúciók lehetővé teszik az erőforrás-észlelést azokban az Azure környezetekben, ahol támogatott. További információ: Automatikus adatgyűjtés és erőforrás-detektorok az Azure Monitor OpenTelemetry.
Manuális beállítások esetén állítsa be közvetlenül az erőforrásattribútumokat a standard OpenTelemetry-beállítások használatával:
# Applies to .NET (ASP.NET/ASP.NET Core), Java, Node.js, and Python
export OTEL_SERVICE_NAME="my-service"
export OTEL_RESOURCE_ATTRIBUTES="cloud.provider=azure,cloud.region=westus,cloud.resource_id=/subscriptions/<SUB>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<APP>"
Windows PowerShellen:
$Env:OTEL_SERVICE_NAME="my-service"
$Env:OTEL_RESOURCE_ATTRIBUTES="cloud.provider=azure,cloud.region=westus,cloud.resource_id=/subscriptions/<SUB>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<APP>"
Mintavételezés engedélyezése
A mintavételezés csökkenti a telemetriai betöltési mennyiséget és a költségeket. Azure Monitor OpenTelemetria disztribúciója két nyomkövetési mintavételi stratégiát támogat, és (opcionálisan) lehetővé teszi az alkalmazásnaplóknak a nyomkövetési mintavételezési döntésekhez való igazítását. A mintavevő az exportált tartományokhoz csatolja a kiválasztott mintavételezési arányt vagy arányt, hogy az Application Insights pontosan tudja módosítani a felhasználói élmények számát. Fogalmi áttekintésért tekintse meg a mintavételezéssel kapcsolatos további tudnivalókat.
Fontos
- A mintavételezési döntések a nyomokra (hatókörökre) vonatkoznak.
- A nem felügyelt nyomkövetésekhez tartozó naplók alapértelmezés szerint el lesznek dobva, de a naplók nyomkövetésalapú mintavételezését letilthatja.
-
A metrikák soha nem lesznek mintavételezettek.
Feljegyzés
Ha váratlan díjakat vagy magas költségeket lát az Application Insightsban, a gyakori okok közé tartozik a magas telemetriai mennyiség, az adatbetöltési csúcsok és a helytelenül konfigurált mintavételezés. A hibaelhárítás megkezdéséhez tekintse meg az Application Insights magas adatbetöltésének hibaelhárítását.
A mintavevő kiválasztásához és argumentumának megadásához használjon standard OpenTelemetry környezeti változókat. Az OpenTelemetry-mintavevők típusairól további információt a OTEL_TRACES_SAMPLER talál.
Feljegyzés
A Java ügynök 3.4.0-s verziójától kezdve a sebességkorlátos mintavételezés elérhető, és most már az alapértelmezett.
A mintavételezés csak a kérésen belüli naplókra vonatkozik. A kérésben nem található naplókat (például indítási naplókat) a rendszer alapértelmezés szerint mindig összegyűjti. Ha mintát szeretne venni ezekből a naplókból, használjon mintavételezési felülbírálásokat.
Rögzített százalékos mintavételezés
-
APPLICATIONINSIGHTS_SAMPLING_PERCENTAGE â €" mintavételi százalék
- Az érték egy százalék (például
33.333 = ~33,333%).
Sebességkorlátos mintavételezés
-
APPLICATIONINSIGHTS_SAMPLING_REQUESTS_PER_SECOND â € " maximális kérések másodpercenként
A konfigurációs beállításokról és példákról a mintavételezési felülbírálások konfigurálása című témakörben olvashat.
Az alábbi példák bemutatják, hogyan konfigurálhatja a mintavételezést környezeti változók használatával.
Feljegyzés
Az alábbi példák nem érvényesek Java. A megfelelő környezeti változókért tekintse meg az előző Java lapot.
Rögzített százalékos mintavételezés (~10%)
export OTEL_TRACES_SAMPLER="microsoft.fixed_percentage"
export OTEL_TRACES_SAMPLER_ARG=0.1
Sebességkorlátos mintavételezés (~1,5 nyomkövetés/mp)
export OTEL_TRACES_SAMPLER="microsoft.rate_limited"
export OTEL_TRACES_SAMPLER_ARG=1.5
Feljegyzés
Ha a kódszintű beállítások és a környezeti változók is konfigurálva vannak, a környezeti változók elsőbbséget élveznek. Az alapértelmezett mintavevő viselkedése nyelv szerint eltérhet.
Rögzített százalékos mintavételezés
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.SamplingRatio = 0.1F; // ~10%
});
var app = builder.Build();
app.Run();
Sebességkorlátos mintavételezés
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.TracesPerSecond = 1.5; // ~1.5 traces/sec
});
var app = builder.Build();
app.Run();
Feljegyzés
Ha nem állít be mintavevőt kódban vagy környezeti változókon keresztül, Azure Monitor alapértelmezés szerint ApplicationInsightsSampler használ.
Rögzített százalékos mintavételezés
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.SamplingRatio = 0.1F)
.Build();
Sebességkorlátos mintavételezés
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.TracesPerSecond = 1.5F)
.Build();
Feljegyzés
Ha nem állít be mintavevőt kódban vagy környezeti változókon keresztül, Azure Monitor alapértelmezés szerint ApplicationInsightsSampler használ.
A Java nem konfigurálhatja a mintavételezést a kódban.
Az 1.16.0-tól kezdődően a sebességkorlátozott mintavételezés az alapértelmezett.
Rögzített százalékos mintavételezés
const { useAzureMonitor } = await import("@azure/monitor-opentelemetry");
const monitor = useAzureMonitor({
samplingRatio: 0.1, // ~10%
azureMonitorExporterOptions: {
connectionString:
process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR-CONNECTION-STRING>",
},
});
Sebességkorlátos mintavételezés
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>",
},
});
Feljegyzés
Ha nem állít be mintavevőt kódban vagy környezeti változókon keresztül, Azure Monitor alapértelmezés szerint RateLimitedSampler használ.
Az 1.8.6-tól kezdődően a sebességkorlátozott mintavételezés az alapértelmezett.
Rögzített százalékos mintavételezés
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
)
Sebességkorlátos mintavételezés
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
)
Feljegyzés
Ha nem állít be környezeti változókat, vagy nem ad meg egyiket sem sampling_ratiotraces_per_second, configure_azure_monitor() alapértelmezés szerint a RateLimitedSamplert használja.
Tipp.
Ha rögzített százalékos mintavételezést használ, és nem biztos benne, hogy milyen értéket kell beállítania a mintavételezési sebességhez, kezdje 5% (0.05). A sebesség beállítása a hibák és a teljesítménypaneleken látható műveletek pontossága alapján. A mintavételezés csökkenti a pontosságot, ezért az OpenTelemetry-metrikákra vonatkozó riasztások nem érintik a mintavételezést.
A ASP.NET Core nem támogatja a mintavételezés konfigurációs fájlban való konfigurálását. A mintavételezés konfigurálásához használjon inkább kód- vagy környezeti változókat.
A .NET nem támogatja a mintavételezés konfigurációs fájlban való konfigurálását. A mintavételezés konfigurálásához használjon inkább kód- vagy környezeti változókat.
Feljegyzés
A Java ügynök 3.4.0-s verziójától kezdve a sebességkorlátos mintavételezés elérhető, és most már az alapértelmezett.
A mintavételezés csak a kérésen belüli naplókra vonatkozik. A kérésben nem található naplókat (például indítási naplókat) a rendszer alapértelmezés szerint mindig összegyűjti. Ha mintát szeretne venni ezekből a naplókból, használjon mintavételezési felülbírálásokat.
Ha nem konfigurálja a mintavételezést, az alapértelmezett beállítás jelenleg a másodpercenként legfeljebb (körülbelül) öt kérelem rögzítésére konfigurált sebességkorlátozott mintavételezés, valamint a kérelmek összes függősége és naplója.
Ez a konfiguráció felülírja a korábbi alapértelmezett beállítást, amely az összes kérés rögzítését jelentette. Ha továbbra is rögzíteni szeretné az összes kérést, használjon rögzített százalékos mintavételezést, és állítsa a mintavételezési százalékot 100-ra.
Rögzített százalékos mintavételezés
Ez a példa bemutatja, hogyan állíthatja be a mintavételezést az összes kérelem körülbelül egyharmadának rögzítésére:
{
"sampling": {
"percentage": 33.333
}
}
Állítsa be a mintavételi százalékot a környezeti változó használatával. Elsőbbséget élvez a JSON-konfigurációban megadott mintavételezési százalékkal szemben.
Tipp.
A mintavételi százalékértékhez válasszon egy 100/N-hez közeli százalékot, ahol az N egész szám. A mintavételezés jelenleg nem támogat más értékeket.
Sebességkorlátos mintavételezés
Feljegyzés
A sebességkorlátos mintavételezés hozzávetőleges, mivel belsőleg egy "rögzített" mintavételi százalékot kell módosítania az idő függvényében, hogy pontos tételszámokat adjon ki az egyes telemetriarekordokon. Belsőleg a sebességkorlátozott mintavételezés úgy van hangolva, hogy gyorsan (0,1 másodperc) alkalmazkodjon az új alkalmazásbetöltésekhez. Ezért nem szabad azt látnia, hogy az jelentősen vagy nagyon hosszú ideig meghaladja a konfigurált arányt.
Ez a példa bemutatja, hogyan állíthatja be a mintavételezést másodpercenként legfeljebb (körülbelül) egy kérés rögzítésére:
{
"sampling": {
"requestsPerSecond": 1.0
}
}
Az requestsPerSecond érték lehet decimális, így konfigurálhatja úgy, hogy másodpercenként egynél kevesebb kérést rögzítsen. Egy érték 0.5 például legfeljebb 2 másodpercenként rögzít egy kérést.
Állítsa be a sebességkorlátot a környezeti változó használatával. Elsőbbséget élvez a JSON-konfigurációban megadott sebességkorlátnál.
Java natív nem támogatja a mintavételezés konfigurációs fájlban való konfigurálását. A mintavételezés konfigurálásához használjon kód- vagy környezeti változókat.
Az 1.16.0-tól kezdődően a sebességkorlátozott mintavételezés az alapértelmezett.
Állítsa be a mintavételezési konfigurációt a applicationinsights.json fájlban. Ez a fájl a @azure/monitor-opentelemetry csomagtelepítési mappa gyökérmappájában található, például node_modules/@azure/monitor-opentelemetry. Minden AzureMonitorOpenTelemetryClient példány ezeket a konfigurációs értékeket használja.
Rögzített százalékos mintavételezés
{
"samplingRatio": 0.1, // ~10%
}
Sebességkorlátos mintavételezés
{
"samplingRatio": 1.5, // ~1.5 traces/sec
}
Python nem támogatja a mintavételezés konfigurációs fájlban való konfigurálását. A mintavételezés konfigurálásához használjon kód- vagy környezeti változókat.
Ha engedélyezi ezt a funkciót, a rendszer elveti a nem felügyelt nyomkövetésekhez tartozó naplórekordokat , hogy a naplók igazodjanak a nyomkövetési mintavételezéshez.
- A naplórekordok akkor részei a nyomkövetésnek, ha érvényes
SpanId.
- Ha a társított nyomkövetés azt jelzi, hogy
TraceFlagsnincs mintavétel, a szolgáltatás elveti a naplórekordot.
- Az nyomkövetési környezet nélkülinaplórekordokat nem érinti.
- A funkció alapértelmezés szerint engedélyezve van.
A nyomkövetési alapú naplómintavétel konfigurálásához használja az alábbi beállításokat:
builder.Services.AddOpenTelemetry().UseAzureMonitor(o =>
{
o.EnableTraceBasedLogsSampler = true;
});
var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddAzureMonitorTraceExporter(o => o.EnableTraceBasedLogsSampler = true)
.Build();
Az Java alkalmazások esetében a nyomkövetési alapú mintavételezés alapértelmezés szerint engedélyezve van.
A Spring Boot natív és a Quarkus natív alkalmazásai esetében alapértelmezés szerint engedélyezve van a nyomkövetési alapú mintavételezés.
Feljegyzés
A Quarkus-közösség támogatja és fenntartja a Quarkus-bővítményeket. Segítségért használja a Quarkus közösségi támogatási csatornáját. Microsoft nem nyújt technikai támogatást ehhez az integrációhoz.
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,
)
Élő metrikák
Az élő metrikák valós idejű elemzési irányítópultot biztosítanak az alkalmazástevékenység és a teljesítmény elemzéséhez.
Alapértelmezetten ez a funkció engedélyezett.
A felhasználók letilthatják az élő metrikákat a disztribúció konfigurálásakor.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
// Disable the Live Metrics feature.
options.EnableLiveMetrics = false;
});
Ez a funkció nem érhető el az Azure Monitor .NET-exportőrben.
Az élő metrikák nem érhetők el a GraalVM natív alkalmazásaihoz.
A felhasználók engedélyezhetik vagy letilthatják a Live Metrics-t, amikor a disztribúciót a enableLiveMetrics tulajdonság segítségével konfigurálják.
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)");
}
}
Az élő metrikákat az Python Azure Monitor OpenTelemetry Distro használatával engedélyezheti az alábbiak szerint:
...
configure_azure_monitor(
enable_live_metrics=True
)
...
Ha biztonságosabb kapcsolatot szeretne létrehozni Azure, engedélyezze Microsoft Entra hitelesítést. Ez a hitelesítési módszer megakadályozza a jogosulatlan telemetriai adatok betöltését az előfizetésbe.
További információkért tekintse meg az egyes támogatott nyelvekhez csatolt dedikált Microsoft Entra hitelesítési oldalt.
Microsoft Entra ID hitelesítés nem érhető el a GraalVM natív alkalmazásaihoz.
Offline tárolás és automatikus újrapróbálás
Azure Monitor OpenTelemetry-alapú ajánlatok telemetriát gyorsítótáraznak, amikor egy alkalmazás kapcsolata megszűnik az Application Insights szolgáltatással, és megkísérli a küldést újra akár 48 órán keresztül. Az adatkezelési javaslatokért tekintse meg a személyes adatok exportálását és törlését. A nagy terhelésű alkalmazások esetenként két okból szüneteltethetik a telemetriaadatok küldését: ha túllépik a megengedett időkeretet, vagy ha meghaladják a maximális fájlméretet. Szükség esetén a termék rangsorolja a legutóbbi eseményeket a régiekkel szemben.
A disztribúciós csomag tartalmazza az AzureMonitorExportert, amely alapértelmezés szerint az alábbi helyek egyikét használja offline tároláshoz (sorrendben felsorolva):
Windows
- %LOCALAPPDATA%\Microsoft\AzureMonitor
- %TEMP%\Microsoft\AzureMonitor
Nem Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
- /tmp/Microsoft/AzureMonitor
Az alapértelmezett könyvtár felülbírálásához be kell állítania 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();
A funkció letiltásához állítsa be a következőt AzureMonitorOptions.DisableOfflineStorage = true:
Alapértelmezés szerint az AzureMonitorExporter az alábbi helyek egyikét használja offline tároláshoz, sorrendben felsorolva:
Windows
- %LOCALAPPDATA%\Microsoft\AzureMonitor
- %TEMP%\Microsoft\AzureMonitor
Nem Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
- /tmp/Microsoft/AzureMonitor
Az alapértelmezett könyvtár felülbírálásához be kell állítania 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";
});
});
});
A funkció letiltásához állítsa be a következőt AzureMonitorExporterOptions.DisableOfflineStorage = true:
Ha az ügynök nem tud telemetriát küldeni a Azure Monitor, telemetriai fájlokat tárol a lemezen. A fájlok a telemetry mappában vannak mentve a java.io.tmpdir rendszertulajdonság által megadott könyvtárban. Minden fájlnév időbélyeggel kezdődik, és a .trn kiterjesztéssel végződik. Ez az offline tárolási mechanizmus segít biztosítani, hogy a telemetriai adatok megmaradnak az ideiglenes hálózati kimaradások vagy betöltési hibák során.
Az ügynök alapértelmezés szerint legfeljebb 50 MB telemetriai adatot tárol, és lehetővé teszi a tárterületkorlát konfigurálását. Az ügynök rendszeresen megkísérli a tárolt telemetriai adatok küldését. A rendszer törli a 48 óránál régebbi telemetriai fájlokat, és a legrégebbi eseményeket elveti a tárterületkorlát elérésekor.
Az elérhető konfigurációk teljes listájáért tekintse meg a konfigurációs beállításokat.
Ha az ügynök nem tud telemetriát küldeni a Azure Monitor, telemetriai fájlokat tárol a lemezen. A fájlok a telemetry mappában vannak mentve a java.io.tmpdir rendszertulajdonság által megadott könyvtárban. Minden fájlnév időbélyeggel kezdődik, és a .trn kiterjesztéssel végződik. Ez az offline tárolási mechanizmus segít biztosítani, hogy a telemetriai adatok megmaradnak az ideiglenes hálózati kimaradások vagy betöltési hibák során.
Az ügynök alapértelmezés szerint legfeljebb 50 MB telemetriai adatot tárol. A tárolt telemetriai adatok küldésére tett kísérletek rendszeresek. A rendszer törli a 48 óránál régebbi telemetriai fájlokat, és a legrégebbi eseményeket elveti a tárterületkorlát elérésekor.
Alapértelmezés szerint az AzureMonitorExporter az alábbi helyek egyikét használja offline tároláshoz.
- Windows
- %TEMP%\Microsoft-AzureMonitor-
<unique-identifier>\opentelemetry-nodejs-<your-instrumentation-key>
- Nem Windows
- %TMPDIR%/Microsoft/Microsoft-AzureMonitor-
<unique-identifier>/opentelemetry-nodejs-<your-instrumentation-key>
- /var/tmp/Microsoft/Microsoft-AzureMonitor-
<unique-identifier>/opentelemetry-nodejs-<your-instrumentation-key>
Ez <unique-identifier> egy hash, amely a felhasználói környezet attribútumaiból, például az instrumentációs kulcsból, a folyamat nevéből, a felhasználónévből és az alkalmazáskönyvtárból jön létre. Ez az azonosító egy gyakori többfelhasználós rendszerproblémát old meg: amikor az első felhasználó létrehozza a tárkönyvtárat, a fájlengedélyek (umask-beállítások) megakadályozhatják, hogy más felhasználók is hozzáférjenek ugyanahhoz az elérési úthoz. Az egyes felhasználói környezetekhez tartozó egyedi címtárak biztosítják, hogy minden felhasználó megkapja a saját tárolási helyét a megfelelő hozzáférési engedélyekkel.
Az alapértelmezett könyvtár felülbírálásához be kell állítania storageDirectory.
Példa:
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)");
}
}
A funkció letiltásához be kell állítania a beállítást disableOfflineStorage = true.
Alapértelmezés szerint Azure Monitor exportőrök a következő útvonalat használják:
<tempfile.gettempdir()>/Microsoft-AzureMonitor-<unique-identifier>/opentelemetry-python-<your-instrumentation-key>
Ez <unique-identifier> egy hash, amely a felhasználói környezet attribútumaiból, például az instrumentációs kulcsból, a folyamat nevéből, a felhasználónévből és az alkalmazáskönyvtárból jön létre. Ez az azonosító egy gyakori többfelhasználós rendszerproblémát old meg: amikor az első felhasználó létrehozza a tárkönyvtárat, a fájlengedélyek (umask-beállítások) megakadályozhatják, hogy más felhasználók is hozzáférjenek ugyanahhoz az elérési úthoz. Az egyes felhasználói környezetekhez tartozó egyedi címtárak biztosítják, hogy minden felhasználó megkapja a saját tárolási helyét a megfelelő hozzáférési engedélyekkel.
Az alapértelmezett könyvtár felülbírálásához állítsa be a storage_directory értékét a kívánt könyvtárra.
Példa:
...
# 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",
)
...
A funkció letiltásához állítsa be a következőt disable_offline_storageTrue: . Alapértelmezett érték: False.
Példa:
...
# 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,
)
...
Az OTLP-exportőr engedélyezése
Előfordulhat, hogy engedélyezni szeretné az OpenTelemetry Protocol (OTLP) exportőrt az Azure Monitor Exportőr mellett, hogy a telemetriát két helyre küldje.
Feljegyzés
Az OTLP-exportőr csak kényelmi okokból jelenik meg. Microsoft hivatalosan nem támogatja az OTLP-exportőrt, sem az azt követő összetevőket vagy harmadik féltől származó tapasztalatokat.
Telepítse az OpenTelemetry.Exporter.OpenTelemetryProtocol csomagot a projektbe.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Adja hozzá a következő kódrészletet. Ez a példa feltételezi, hogy rendelkezik egy OpenTelemetria-gyűjtővel, amelyen egy OTLP-fogadó fut. További részletekért lásd a példát a GitHub-on.
// 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();
Telepítse az OpenTelemetry.Exporter.OpenTelemetryProtocol csomagot a projektbe.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Adja hozzá a következő kódrészletet. Ez a példa feltételezi, hogy rendelkezik egy OpenTelemetria-gyűjtővel, amelyen egy OTLP-fogadó fut. További részletekért lásd a példát a GitHub-on.
// 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();
Az Application Insights Java-ügynök nem támogatja az OTLP-t.
A támogatott konfigurációkkal kapcsolatos további információkért tekintse meg a Java kiegészítő dokumentációt.
Nem engedélyezheti az OpenTelemetry Protocol (OTLP) exportőrt az Azure Monitor Exportőr mellett, hogy a telemetriát két helyre küldje.
Telepítse az OpenTelemetry Collector Trace-exportőrt és más OpenTelemetry-csomagokat a projektben.
npm install @opentelemetry/api
npm install @opentelemetry/exporter-trace-otlp-http
npm install @opentelemetry/sdk-trace-base
npm install @opentelemetry/sdk-trace-node
Adja hozzá a következő kódrészletet. Ez a példa feltételezi, hogy rendelkezik egy OpenTelemetria-gyűjtővel, amelyen egy OTLP-fogadó fut. További részletekért lásd a példát a GitHub-on.
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)");
}
}
Telepítse az opentelemetry-exporter-otlp csomagot.
Adja hozzá a következő kódrészletet. Ez a példa feltételezi, hogy rendelkezik egy OpenTelemetria-gyűjtővel, amelyen egy OTLP-fogadó fut. További részletekért lásd ezt a 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!")
OpenTelemetria-konfigurációk
Az alábbi OpenTelemetria-konfigurációkat környezeti változókon keresztül érheti el az Azure Monitor OpenTelemetria-disztribúciók használatakor.
| Környezeti változó |
Leírás |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Állítsa be ezt a változót az Application Insights erőforráshoz tartozó kapcsolati karakterlánccal. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Állítsa be ezt a változót úgy, hogy true kikapcsolja a belső metrikák gyűjteményét. |
OTEL_RESOURCE_ATTRIBUTES |
Erőforrásattribútumként használandó kulcs-érték párok. Az erőforrásattribútumokról további információt az Erőforrás SDK specifikációjában talál. |
OTEL_SERVICE_NAME |
Beállítja service.name az erőforrásattribútum értékét. Ha service.name is meg van adva OTEL_RESOURCE_ATTRIBUTES-ben, akkor OTEL_SERVICE_NAME elsőbbséget élvez. |
| Környezeti változó |
Leírás |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Állítsa be ezt a változót az Application Insights erőforráshoz tartozó kapcsolati karakterlánccal. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Állítsa be ezt a változót úgy, hogy true kikapcsolja a belső metrikák gyűjteményét. |
OTEL_RESOURCE_ATTRIBUTES |
Erőforrásattribútumként használandó kulcs-érték párok. Az erőforrásattribútumokról további információt az Erőforrás SDK specifikációjában talál. |
|
OTEL_SERVICE_NAME | Beállítja service.name az erőforrásattribútum értékét. Ha service.name is meg van adva OTEL_RESOURCE_ATTRIBUTES-ben, akkor OTEL_SERVICE_NAME elsőbbséget élvez. |
URL-lekérdezési sztringek újbóli létrehozása
Az URL-lekérdezési sztringek eltávolításához kapcsolja ki a lekérdezési sztringgyűjtést. Ez a beállítás akkor ajánlott, ha SAS-jogkivonattal hívja meg Azure tárterületet.
Amikor használja az Azure.Monitor.OpenTelemetry.AspNetCore distro csomagot, az tartalmazza az ASP.NET Core és HttpClient Instrumentation könyvtárakat.
A disztribúciós csomag alapértelmezés szerint kikapcsolja a lekérdezési sztring kitakarását.
A viselkedés módosításához állítson be egy környezeti változót vagy true, vagy false.
ASP.NET Core Instrumentation: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION A lekérdezési sztring kitakarás alapértelmezésben nincs engedélyezve. Az engedélyezéshez állítsa ezt a környezeti változót a következőre false: .
Http-ügyfélrendszerezés: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION A lekérdezési sztring újrahívása alapértelmezés szerint le van tiltva. Az engedélyezéshez állítsa ezt a környezeti változót a következőre false: .
A Azure.Monitor.OpenTelemetry.Exporter használatakor kézzel kell felvennie az ASP.NET Core vagy HttpClient Instrumentation könyvtárakat az OpenTelemetry-konfigurációba.
Ezek az instrumentációs könyvtárakban alapértelmezés szerint engedélyezve van a lekérdezési sztringek elrejtése.
A viselkedés módosításához állítson be egy környezeti változót vagy true, vagy false.
ASP.NET Core Instrumentation: OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION A lekérdezési sztring újrafedése alapértelmezés szerint engedélyezve van. A letiltáshoz állítsa be ezt a környezeti változót a következőre true: .
Http-ügyfél-rendszerállapot: OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION A lekérdezési sztring újrahívása alapértelmezés szerint engedélyezve van. A letiltáshoz állítsa be ezt a környezeti változót a következőre true: .
Adja hozzá a következőket a applicationinsights.json konfigurációs fájlhoz:
{
"preview": {
"processors": [
{
"type": "attribute",
"actions": [
{
"key": "url.query",
"pattern": "^.*$",
"replace": "REDACTED",
"action": "mask"
}
]
},
{
"type": "attribute",
"actions": [
{
"key": "url.full",
"pattern": "[?].*$",
"replace": "?REDACTED",
"action": "mask"
}
]
}
]
}
}
Az OpenTelemetry közösség aktívan dolgozik az anonimizálás támogatásán.
A Azure Monitor OpenTelemetry distro csomag használatakor a lekérdezési sztringek anonimizálhatók úgy, hogy létrehoz egy span processzort, és alkalmazza a disztribúciós konfigurációra.
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)");
}
}
Az OpenTelemetry közösség aktívan dolgozik a kitakarás támogatásán.
Metrika exportálási időköz
A metrika exportálási időközét a OTEL_METRIC_EXPORT_INTERVAL környezeti változóval konfigurálhatja.
OTEL_METRIC_EXPORT_INTERVAL=60000
Az alapértelmezett érték ezredmásodperc 60000 (60 másodperc). Ez a beállítás szabályozza, hogy az OpenTelemetry SDK milyen gyakran exportálja a metrikákat.
Tipp.
Az Azure Monitor metrikái és az Azure Monitor munkaterület 60 másodperces rögzített időközönként dolgozza fel az egyéni metrikákat. A gyakrabban küldött metrikák pufferelése és feldolgozása 60 másodpercenként történik. Log Analytics a metrikákat az elküldött időközönként rögzíti, ami növelheti a költségeket rövidebb időközönként, és késleltetheti a láthatóságot a hosszabbaknál.
További információt a következő OpenTelemetry-specifikációkban talál:
Hibaelhárítás, visszajelzés és támogatás
Tipp.
A következő szakaszok az OpenTelemetry Distro összes cikkében elérhetők.
Hibaelhárítás
OpenTelemetry visszajelzés
Visszajelzés küldése:
Támogatás
Válasszon egy lapot a választott nyelvhez a támogatási lehetőségek felderítéséhez.
Feljegyzés
A Quarkus-közösség támogatja és fenntartja a Quarkus-bővítményeket. Segítségért használja a Quarkus közösségi támogatási csatornáját. Microsoft nem nyújt technikai támogatást ehhez az integrációhoz.
Következő lépések