Ez az útmutató bemutatja, hogyan konfigurálhatja az OpenTelemetryt (OTel) az Azure Monitor Application Insightsban az Azure Monitor OpenTelemetry disztribúcióval. 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 Insights egy kapcsolati sztring határozza meg a telemetriai adatok küldésének célhelyét.
A kapcsolati sztring konfigurálásához használja az alábbi három módszer egyikét:
Adja hozzá a UseAzureMonitor()
elemet a program.cs
fájlhoz:
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 sztringet egynél több helyen állítja be, a következő sorrendet tartjuk be:
- Kód
- Környezeti változó
- Konfigurációs fájl
A kapcsolati sztring az alábbi két módon konfigurálható:
Adja hozzá az Azure Monitor-exportőrt minden OpenTelemetria-jelhez az alkalmazás indításakor.
// 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 sztringet egynél több helyen állítja be, a következő sorrendet tartjuk be:
- Kód
- Környezeti változó
A kapcsolati sztring az alábbi két módon konfigurálható:
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 sztring az alábbi két módon konfigurálható:
Környezeti változó beállítása.
APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
Használjon konfigurációs objektumot.
// 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);
A kapcsolati sztring az alábbi két módon konfigurálható:
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
Támogatott nyelvek esetén az Azure Monitor OpenTelemetry Disztribúció automatikusan észleli az erőforrás-környezetet, és alapértelmezett értékeket biztosít az összetevő felhőszerepkör-neve és felhőbeli szerepkörpéldány-tulajdonságai számára. 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 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.
// 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 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.
// 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();
});
});
A felhőbeli szerepkör nevének beállítása:
-
spring.application.name
A Spring Boot natív rendszerkép-alkalmazásainak használata
-
quarkus.application.name
A Quarkus natív képalkalmazásainak használata
Á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.
// 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);
Á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"
Mintavételezés engedélyezése
Érdemes lehet engedélyezni a mintavételezést az adatbetöltés mennyiségének csökkentése érdekében, ami csökkenti a költségeket. Az Azure Monitor egy egyéni rögzített sebességű mintavevőt biztosít, amely mintavételezési aránnyal tölti fel az eseményeket, amelyet az Application Insights átalakít ItemCount
. A rögzített arányú mintavevő pontos élményeket és eseményszámokat biztosít. A mintavevőt úgy tervezték, hogy megőrizze a nyomkövetéseket a szolgáltatások között, és együttműködik a régebbi Application Insights szoftverfejlesztői készletekkel (SDK-kkal). További információ: További információ a mintavételezésről.
Feljegyzés
A metrikákat és naplókat a mintavételezés nem érinti.
Ha váratlan díjakat vagy magas költségeket lát az Application Insightsban, ez az útmutató segíthet. Olyan gyakori okokra terjed ki, mint a magas telemetriai mennyiség, az adatbetöltési csúcsok és a helytelenül konfigurált mintavételezés. Különösen hasznos, ha a költségnövekedéssel, a telemetriai forgalommal, a nem működő mintavételezéssel, az adatkorlátokkal, a magas adatbevitelnél vagy a váratlan számlázással kapcsolatos problémákat hárítja el. Első lépésként tekintse meg az Application Insights magas adatbetöltésének hibaelhárításával foglalkozó témakört.
A mintavevő 0 és 1 közötti mintaarányt vár. A 0,1 arány azt jelenti, hogy a nyomok körülbelül 10%-át küldi el a rendszer.
// 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();
A mintavevő 0 és 1 közötti mintaarányt vár. A 0,1 arány azt jelenti, hogy a nyomok körülbelül 10%-át küldi el a rendszer.
// 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();
A 3.4.0-tól kezdődően a sebességkorlátos mintavételezés jelenleg az alapértelmezett. További információ a mintavételezésről: Java-mintavételezés.
A mintavevő 0 és 1 közötti mintaarányt vár. A 0,1 arány azt jelenti, hogy a nyomok körülbelül 10%-át küldi el a rendszer.
// 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);
A configure_azure_monitor()
függvény automatikusan az ApplicationInsightsSamplert használja az Application Insights SDK-kkal való kompatibilitáshoz és a telemetriai adatok mintavételéhez. A OTEL_TRACES_SAMPLER_ARG
környezeti változóval megadhatja a mintavételezési gyakoriságot, amelynek érvényes tartománya 0 és 1 között van, ahol 0% és 1 100%.
A 0,1 érték például azt jelenti, hogy a rendszer a nyomkövetések 10%-át küldi el.
export OTEL_TRACES_SAMPLER_ARG=0.1
Tipp.
Ha rögzített/százalékos mintavételezést használ, és nem tudja, hogy mi legyen a mintavételezési sebesség beállítása, kezdje 5%-kal. (0,05 mintavételezési arány) A sebesség beállítása a hibák és a teljesítménypaneleken látható műveletek pontossága alapján. A magasabb sebesség általában nagyobb pontosságot eredményez. A mintavételezés azonban befolyásolja a pontosságot, ezért azt javasoljuk, hogy riasztást küldjön az OpenTelemetry-metrikákra, amelyeket a mintavételezés nem érint.
É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 ma 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.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString:
process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
},
enableLiveMetrics: false
};
useAzureMonitor(options);
Az élő metrikákat az Azure Monitor OpenTelemetry Distro for Python használatával engedélyezheti az alábbiak szerint:
...
configure_azure_monitor(
enable_live_metrics=True
)
...
Érdemes lehet engedélyezni a Microsoft Entra-hitelesítést az Azure-hoz való biztonságosabb kapcsolat érdekében, amely 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.
A Microsoft Entra ID-hitelesítés nem érhető el a GraalVM natív alkalmazásaihoz.
Offline tárolás és automatikus újrapróbálkozás
Az Azure Monitor OpenTelemetry-alapú ajánlatai tárolják a telemetriai adatokat, amikor egy alkalmazás megszakítja a kapcsolatot az Application Insightsszal, és akár 48 órán keresztül újra próbálja elküldeni azokat. 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 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();
A funkció letiltásához be kell állítania a beállítást 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 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";
});
});
});
A funkció letiltásához be kell állítania a beállítást AzureMonitorExporterOptions.DisableOfflineStorage = true
.
Ha az ügynök nem tud telemetriát küldeni az Azure Monitorba, 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. 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.
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 az Azure Monitorba, 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
- Nem Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
Az alapértelmezett könyvtár felülbírálásához be kell állítania storageDirectory
.
Példa:
// 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);
A funkció letiltásához be kell állítania a beállítást disableOfflineStorage = true
.
Alapértelmezés szerint az Azure Monitor-exportőrök a következő elérési utat használják:
<tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>
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_storage
True
: . 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
Érdemes engedélyeznie 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. Hivatalosan nem támogatjuk az OTLP-exportőrt, illetve annak bármely összetevőjét vagy harmadik féltől származó tapasztalatait.
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 tekintse meg a GitHubon található példát.
// 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 tekintse meg a GitHubon található példát.
// 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óját.
Nem engedélyezheti az OpenTelemetry Protocol (OTLP) exportőrt az Azure Monitor-exportőr mellett, hogy két helyre küldje a telemetriát.
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 tekintse meg a GitHubon található példát.
// 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);
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 tekintse meg ezt a README-et.
# 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ók környezeti változókon keresztül érhetők el az Azure Monitor OpenTelemetry Distros használata közben.
Környezeti változó |
Leírás |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Állítsa be az Application Insights-erőforrásának kapcsolati karakterláncát. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Állítsa be ú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 OTEL_RESOURCE_ATTRIBUTES is meg van adva, akkor OTEL_SERVICE_NAME elsőbbséget élvez. |
Környezeti változó |
Leírás |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Állítsa be az Application Insights-erőforrásának kapcsolati karakterláncát. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Állítsa be ú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 OTEL_RESOURCE_ATTRIBUTES is meg van adva, 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. Ezt a beállítást akkor javasoljuk, ha SAS-jogkivonattal hívja meg az Azure Storage-t.
Az Azure.Monitor.OpenTelemetry.AspNetCore disztribúciós csomag használatakor a ASP.NET Core - és HttpClient Instrumentation-kódtárak is elérhetők.
A disztribúciós csomag alapértelmezés szerint kikapcsolja a lekérdezési sztring újraműveltségét.
A viselkedés módosításához be kell állítania egy környezeti változót a következőre: vagy true
false
.
- ASP.NET Core Instrumentation:
OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION
A lekérdezési sztring kitakarása alapértelmezés szerint ki van kapcsolva. 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
: .
Az Azure.Monitor.OpenTelemetry.Exporter használatakor manuálisan kell hozzáadnia az ASP.NET Core vagy HttpClient instrumentációs könyvtárakat az OpenTelemetry konfigurációjához.
Ezekben az Instrumentation könyvtárakban a QueryString szerkesztés alapértelmezés szerint van engedélyezve.
A viselkedés módosításához be kell állítania egy környezeti változót a következőre: vagy true
false
.
- ASP.NET Core Instrumentation:
OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION
A lekérdezési sztring kihagyá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
: .
- 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"
}
]
}
]
}
}
Aktívan dolgozunk az OpenTelemetry-közösségben a szerkesztés támogatásán.
Az Azure Monitor OpenTelemetry disztribúciós csomag használatakor a lekérdezési sztringek eltávolíthatók egy span processzor létrehozásával és alkalmazásával, amelyet a disztribúció konfigurációjára alkalmaznak.
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);
Aktívan dolgozunk az OpenTelemetry-közösségben a szerkeszté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 Metrics és az Azure Monitor Workspace rögzített 60 másodperces időközzel betölti az egyéni metrikákat. A gyakrabban küldött metrikák pufferelése és feldolgozása 60 másodpercenként történik. A Log Analytics az elküldött időközön rögzíti a metrikákat, ami rövidebb időközönként növelheti a költségeket, és késleltetheti a hosszabbaknál a láthatóságot.
További információt a következő OpenTelemetry-specifikációkban talál: