W tym przewodniku wyjaśniono, jak skonfigurować bibliotekę OpenTelemetry (OTel) w usłudze Azure Monitor Application Insights przy użyciu dystrybucji OpenTelemetry usługi Azure Monitor. Właściwa konfiguracja zapewnia spójne zbieranie danych telemetrycznych w aplikacjach .NET, Java, Node.jsi Python, co zapewnia bardziej niezawodne monitorowanie i diagnostykę.
Ciąg połączenia
Parametry połączenia w usłudze Application Insights definiuje lokalizację docelową wysyłania danych telemetrycznych.
Aby skonfigurować parametry połączenia, użyj jednego z następujących trzech sposobów:
Dodaj UseAzureMonitor()
do program.cs
pliku:
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();
Ustaw zmienną środowiskową.
APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
Dodaj następującą sekcję do appsettings.json
pliku konfiguracji.
{
"AzureMonitor": {
"ConnectionString": "<Your Connection String>"
}
}
Uwaga
Jeśli ustawisz parametry połączenia w więcej niż jednym miejscu, przestrzegamy następującego pierwszeństwa:
- Kod
- Zmienna środowiskowa
- Plik konfiguracji
Aby skonfigurować parametry połączenia, użyj jednego z następujących dwóch sposobów:
Dodaj eksportera usługi Azure Monitor do każdego sygnału OpenTelemetry podczas uruchamiania aplikacji.
// 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>";
});
});
});
Ustaw zmienną środowiskową.
APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
Uwaga
Jeśli ustawisz parametry połączenia w więcej niż jednym miejscu, przestrzegamy następującego pierwszeństwa:
- Kod
- Zmienna środowiskowa
Aby skonfigurować parametry połączenia, użyj jednego z następujących dwóch sposobów:
Ustaw zmienną środowiskową.
APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
Ustaw właściwość.
applicationinsights.connection.string=<Your Connection String>
Aby skonfigurować parametry połączenia, użyj jednego z następujących dwóch sposobów:
Ustaw zmienną środowiskową.
APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
Użyj obiektu konfiguracji.
// 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);
Aby skonfigurować parametry połączenia, użyj jednego z następujących dwóch sposobów:
Ustaw zmienną środowiskową.
APPLICATIONINSIGHTS_CONNECTION_STRING=<Your Connection String>
Użyj funkcji 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>",
)
Ustaw nazwę roli chmurowej i instancję roli chmurowej
W przypadku obsługiwanych języków dystrybucja OpenTelemetry Azure Monitor automatycznie wykrywa kontekst zasobu i ustawia wartości domyślne dla właściwości Nazwa roli chmury i Właściwość wystąpienia roli chmury składnika. Możesz jednak zastąpić wartości domyślne na wartości, które będą sensowne dla Twojego zespołu. Wartość nazwy roli chmury jest wyświetlana na mapie aplikacji jako nazwa poniżej węzła.
Ustaw nazwę roli chmury i instancję roli chmury za pomocą atrybutów Resource. Nazwa roli chmury używa atrybutów service.namespace
i service.name
, ale przechodzi na service.name
jeśli service.namespace
nie jest ustawiony. Wystąpienie roli w chmurze używa wartości atrybutu service.instance.id
. Aby uzyskać informacje na temat atrybutów standardowych dla zasobów, zobacz OpenTelemetry Semantic Conventions (Konwencje semantyczne protokołu 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();
Ustaw nazwę roli chmury i instancję roli chmury za pomocą atrybutów Resource. Nazwa roli chmury używa atrybutów service.namespace
i service.name
, ale przechodzi na service.name
jeśli service.namespace
nie jest ustawiony. Wystąpienie roli w chmurze używa wartości atrybutu service.instance.id
. Aby uzyskać informacje na temat atrybutów standardowych dla zasobów, zobacz OpenTelemetry Semantic Conventions (Konwencje semantyczne protokołu 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();
});
});
Aby ustawić nazwę roli chmury:
- Użyj
spring.application.name
dla aplikacji obrazów natywnych Spring Boot
- Używaj
quarkus.application.name
dla natywnych obrazów aplikacji Quarkus.
Ustaw nazwę roli chmury i instancję roli chmury za pomocą atrybutów Resource. Nazwa roli chmury używa atrybutów service.namespace
i service.name
, ale przechodzi na service.name
jeśli service.namespace
nie jest ustawiony. Wystąpienie roli w chmurze używa wartości atrybutu service.instance.id
. Aby uzyskać informacje na temat atrybutów standardowych dla zasobów, zobacz OpenTelemetry Semantic Conventions (Konwencje semantyczne protokołu 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);
Ustaw nazwę roli chmury i instancję roli chmury za pomocą atrybutów Resource. Nazwa roli chmury używa atrybutów service.namespace
i service.name
, ale przechodzi na service.name
jeśli service.namespace
nie jest ustawiony. Wystąpienie roli w chmurze używa wartości atrybutu service.instance.id
. Aby uzyskać informacje na temat atrybutów standardowych dla zasobów, zobacz OpenTelemetry Semantic Conventions (Konwencje semantyczne protokołu OpenTelemetry).
Ustaw atrybuty zasobu przy użyciu zmiennych środowiskowych OTEL_RESOURCE_ATTRIBUTES
i/lub OTEL_SERVICE_NAME
.
OTEL_RESOURCE_ATTRIBUTES
pobiera serię par klucz-wartość rozdzielaną przecinkami. Aby na przykład ustawić nazwę roli w chmurze na my-namespace.my-helloworld-service
i wystąpienie roli w chmurze na my-instance
, można ustawić OTEL_RESOURCE_ATTRIBUTES
i OTEL_SERVICE_NAME
w następujący sposób:
export OTEL_RESOURCE_ATTRIBUTES="service.namespace=my-namespace,service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"
Jeśli nie ustawisz atrybutu service.namespace
Zasób, możesz również ustawić nazwę roli chmury tylko za pomocą zmiennej środowiskowej OTEL_SERVICE_NAME lub atrybutu service.name
Zasobu. Aby na przykład ustawić nazwę roli w chmurze na my-helloworld-service
i wystąpienie roli w chmurze na my-instance
, można ustawić OTEL_RESOURCE_ATTRIBUTES
i OTEL_SERVICE_NAME
w następujący sposób:
export OTEL_RESOURCE_ATTRIBUTES="service.instance.id=my-instance"
export OTEL_SERVICE_NAME="my-helloworld-service"
Włączanie próbkowania
Możesz włączyć próbkowanie, aby zmniejszyć ilość pozyskiwania danych, co zmniejsza koszt. Usługa Azure Monitor udostępnia niestandardowy próbnik o stałej stopy, który wypełnia zdarzenia współczynnikiem próbkowania, a usługa Application Insights konwertuje ten współczynnik na wartość ItemCount
. Próbkator o stałej wartości zapewnia dokładne doświadczenia i liczbę zdarzeń. Próbnik został zaprojektowany tak, aby zachować ślady pomiędzy usługami i jest zgodny ze starszymi zestawami SDK (Software Development Kits) usługi Application Insights. Aby uzyskać więcej informacji, zobacz Dowiedz się więcej o próbkowaniu.
Uwaga
Metryki i dzienniki są niezależne od próbkowania.
Jeśli widzisz nieoczekiwane opłaty lub wysokie koszty w usłudze Application Insights, ten przewodnik może pomóc. Obejmuje ona typowe przyczyny, takie jak duża ilość danych telemetrycznych, skoki pozyskiwania danych i błędnie skonfigurowane próbkowanie. Jest to szczególnie przydatne, jeśli rozwiązujesz problemy związane ze wzrostem kosztów, ilością danych telemetrycznych, niedziałającym próbkowaniem, limitami danych, wysokim pozyskiwaniem lub nieoczekiwanymi rozliczeniami. Aby rozpocząć, zobacz Rozwiązywanie problemów z wysokim poziomem pobierania danych w usłudze Application Insights.
Próbkator oczekuje częstotliwości próbkowania z zakresu od 0 do 1 włącznie. Szybkość 0,1 oznacza, że wysyłane są około 10% śladów.
// 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();
Próbkator oczekuje częstotliwości próbkowania z zakresu od 0 do 1 włącznie. Szybkość 0,1 oznacza, że wysyłane są około 10% śladów.
// 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();
Począwszy od wersji 3.4.0, próbkowanie z ograniczoną szybkością jest dostępne i jest teraz domyślne. Aby uzyskać więcej informacji na temat próbkowania, zobacz Próbkowanie w języku Java.
Próbkator oczekuje częstotliwości próbkowania z zakresu od 0 do 1 włącznie. Szybkość 0,1 oznacza, że wysyłane są około 10% śladów.
// 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);
Funkcja configure_azure_monitor()
automatycznie korzysta z elementu ApplicationInsightsSampler w celu zapewnienia zgodności z zestawami SDK usługi Application Insights i próbkowania danych telemetrycznych. Zmienna OTEL_TRACES_SAMPLER_ARG
środowiskowa może służyć do określenia częstotliwości próbkowania z prawidłowym zakresem od 0 do 1, gdzie 0 wynosi 0%, a 1 to 100%.
Na przykład wartość 0,1 oznacza, że wysyłane są 10% śladów.
export OTEL_TRACES_SAMPLER_ARG=0.1
Napiwek
W przypadku korzystania z próbkowania o stałej stawce lub procentowej, jeśli nie jesteś pewien, jaką ustawić częstotliwość próbkowania, zacznij od 5%. (Współczynnik próbkowania 0,05) Dostosuj szybkość na podstawie dokładności operacji wyświetlanych w okienkach błędów i wydajności. Wyższa stawka zwykle skutkuje wyższą dokładnością. Jednak każde próbkowanie ma wpływ na dokładność, dlatego zalecamy zgłaszanie alertów dotyczących metryk OpenTelemetry, które nie mają wpływu na próbkowanie.
Metryki na żywo
Metryki na żywo udostępnia pulpit nawigacyjny analizy w czasie rzeczywistym umożliwiający wgląd w aktywność aplikacji i wydajność.
Ten funkcjonalność jest włączona domyślnie.
Użytkownicy mogą wyłączyć Live Metrics podczas konfigurowania dystrybucji.
builder.Services.AddOpenTelemetry().UseAzureMonitor(options => {
// Disable the Live Metrics feature.
options.EnableLiveMetrics = false;
});
Ta funkcja nie jest dostępna w eksporterze .NET usługi Azure Monitor.
Uwaga
Zalecamy eksportera Azure Monitor OpenTelemetry dla aplikacji konsolowych i usług roboczych, które nie zawierają metryk na żywo.
Metryki na żywo nie są obecnie dostępne dla aplikacji natywnych GraalVM.
Użytkownicy mogą włączać lub wyłączać Live Metrics podczas konfigurowania Distro przy użyciu ustawienia enableLiveMetrics
.
const options: AzureMonitorOpenTelemetryOptions = {
azureMonitorExporterOptions: {
connectionString:
process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"] || "<your connection string>",
},
enableLiveMetrics: false
};
useAzureMonitor(options);
Możesz włączyć metryki na żywo, korzystając z OpenTelemetry Distro dla Python w usłudze Azure Monitor w następujący sposób:
...
configure_azure_monitor(
enable_live_metrics=True
)
...
Możesz włączyć uwierzytelnianie Entra firmy Microsoft, aby uzyskać bezpieczniejsze połączenie z platformą Azure, co zapobiega przetwarzaniu nieautoryzowanych danych telemetrycznych w Twojej subskrypcji.
Aby uzyskać więcej informacji, zobacz dedykowaną stronę uwierzytelniania Entra firmy Microsoft, połączoną z każdą obsługiwaną wersją językową.
Uwierzytelnianie identyfikatora Entra firmy Microsoft nie jest dostępne dla aplikacji natywnych GraalVM.
Przechowywanie w trybie offline i automatyczne ponawianie prób
Usługi Azure Monitor oparte na OpenTelemetry buforują dane telemetryczne, gdy aplikacja rozłącza się z usługą Application Insights i przez maksymalnie 48 godzin ponawiają próby ich wysłania. Aby uzyskać zalecenia dotyczące obsługi danych, zobacz Eksportowanie i usuwanie danych prywatnych. Aplikacje o dużym obciążeniu od czasu do czasu upuszczają dane telemetryczne z dwóch powodów: przekroczenie dozwolonego czasu lub przekroczenie maksymalnego rozmiaru pliku. W razie potrzeby produkt określa priorytety ostatnich zdarzeń nad starymi.
Pakiet Distro zawiera eksporter AzureMonitorExporter, który domyślnie używa jednej z następujących lokalizacji do przechowywania offline (wymienionych w kolejności pierwszeństwa):
- Windows
- %LOCALAPPDATA%\Microsoft\AzureMonitor
- %TEMP%\Microsoft\AzureMonitor
- Nie-Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
- /tmp/Microsoft/AzureMonitor
Aby zastąpić katalog domyślny, należy ustawić wartość 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();
Aby wyłączyć tę funkcję, należy ustawić wartość AzureMonitorOptions.DisableOfflineStorage = true
.
Domyślnie usługa AzureMonitorExporter używa jednej z następujących lokalizacji dla magazynu offline (wymienionego w kolejności pierwszeństwa):
- Windows
- %LOCALAPPDATA%\Microsoft\AzureMonitor
- %TEMP%\Microsoft\AzureMonitor
- Nie-Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
- /tmp/Microsoft/AzureMonitor
Aby zastąpić katalog domyślny, należy ustawić wartość 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";
});
});
});
Aby wyłączyć tę funkcję, należy ustawić wartość AzureMonitorExporterOptions.DisableOfflineStorage = true
.
Gdy agent nie może wysyłać danych telemetrycznych do usługi Azure Monitor, przechowuje pliki telemetryczne na dysku. Pliki są zapisywane w telemetry
folderze w katalogu określonym przez właściwość systemową java.io.tmpdir
. Każda nazwa pliku rozpoczyna się od znacznika czasu i kończy się .trn
rozszerzeniem. Ten mechanizm przechowywania w trybie offline pomaga zagwarantować, że dane telemetryczne są zachowywane podczas tymczasowych awarii sieci lub niepowodzeń pozyskiwania.
Agent domyślnie przechowuje do 50 MB danych telemetrycznych i zezwala na konfigurację limitu przechowywania. Próby wysyłania przechowywanych danych telemetrycznych są okresowo wykonywane. Pliki telemetryczne starsze niż 48 godzin są usuwane, a najstarsze zdarzenia są odrzucane po osiągnięciu limitu magazynu.
Aby uzyskać pełną listę dostępnych konfiguracji, zobacz Opcje konfiguracji.
Gdy agent nie może wysyłać danych telemetrycznych do usługi Azure Monitor, przechowuje pliki telemetryczne na dysku. Pliki są zapisywane w telemetry
folderze w katalogu określonym przez właściwość systemową java.io.tmpdir
. Każda nazwa pliku rozpoczyna się od znacznika czasu i kończy się .trn
rozszerzeniem. Ten mechanizm przechowywania w trybie offline pomaga zagwarantować, że dane telemetryczne są zachowywane podczas tymczasowych awarii sieci lub niepowodzeń pozyskiwania.
Agent domyślnie przechowuje do 50 MB danych telemetrycznych. Próby wysyłania przechowywanych danych telemetrycznych są okresowo wykonywane. Pliki telemetryczne starsze niż 48 godzin są usuwane, a najstarsze zdarzenia są odrzucane po osiągnięciu limitu magazynu.
Domyślnie usługa AzureMonitorExporter używa jednej z następujących lokalizacji do przechowywania w trybie offline.
- Windows
- %TEMP%\Microsoft\AzureMonitor
- Nie-Windows
- %TMPDIR%/Microsoft/AzureMonitor
- /var/tmp/Microsoft/AzureMonitor
Aby zastąpić katalog domyślny, należy ustawić wartość storageDirectory
.
Na przykład:
// 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);
Aby wyłączyć tę funkcję, należy ustawić wartość disableOfflineStorage = true
.
Domyślnie eksporterzy usługi Azure Monitor używają następującej ścieżki:
<tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>
Aby zastąpić katalog domyślny, należy ustawić storage_directory
na katalog, który chcesz.
Na przykład:
...
# 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",
)
...
Aby wyłączyć tę funkcję, należy ustawić wartość disable_offline_storage
True
. Wartość domyślna to False
.
Na przykład:
...
# 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,
)
...
Włączanie eksportera OTLP
Możesz włączyć eksportera protokołu OpenTelemetry Protocol (OTLP) wraz z eksporterem usługi Azure Monitor w celu wysłania danych telemetrycznych do dwóch lokalizacji.
Uwaga
Eksporter OTLP jest wyświetlany tylko dla wygody. Nie wspieramy oficjalnie eksportera OTLP ani żadnych jego składników, ani doświadczeń innych firm, które na nim bazują.
Zainstaluj pakiet OpenTelemetry.Exporter.OpenTelemetryProtocol w projekcie.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Dodaj następujący fragment kodu. W tym przykładzie założono, że masz moduł zbierający OpenTelemetry z uruchomionym odbiornikiem OTLP. Aby uzyskać szczegółowe informacje, zobacz przykład w witrynie GitHub.
// 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();
Zainstaluj pakiet OpenTelemetry.Exporter.OpenTelemetryProtocol w projekcie.
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
Dodaj następujący fragment kodu. W tym przykładzie założono, że masz moduł zbierający OpenTelemetry z uruchomionym odbiornikiem OTLP. Aby uzyskać szczegółowe informacje, zobacz przykład w witrynie GitHub.
// 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();
Nie można włączyć eksportera protokołu OpenTelemetry Protocol (OTLP) wraz z eksporterem usługi Azure Monitor w celu wysłania danych telemetrycznych do dwóch lokalizacji.
Zainstaluj moduł zbierający eksportera śladów OpenTelemetry oraz inne pakiety OpenTelemetry w projekcie.
npm install @opentelemetry/api
npm install @opentelemetry/exporter-trace-otlp-http
npm install @opentelemetry/sdk-trace-base
npm install @opentelemetry/sdk-trace-node
Dodaj następujący fragment kodu. W tym przykładzie założono, że masz moduł zbierający OpenTelemetry z uruchomionym odbiornikiem OTLP. Aby uzyskać szczegółowe informacje, zobacz przykład w witrynie GitHub.
// 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);
Zainstaluj pakiet opentelemetry-exporter-otlp .
Dodaj następujący fragment kodu. W tym przykładzie założono, że masz moduł zbierający OpenTelemetry z uruchomionym odbiornikiem OTLP. Aby uzyskać szczegółowe informacje, zobacz ten plik 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!")
Konfiguracje OpenTelemetry
Następujące konfiguracje biblioteki OpenTelemetry można uzyskać za pośrednictwem zmiennych środowiskowych podczas korzystania z dystrybucji OpenTelemetry usługi Azure Monitor.
Zmienna środowiskowa |
opis |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Ustaw go na parametry połączenia dla zasobu usługi Application Insights. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Aby zrezygnować z wewnętrznego zbierania metryk, ustaw to na true . |
OTEL_RESOURCE_ATTRIBUTES |
Pary klucz-wartość, które mają być używane jako atrybuty zasobów. Aby uzyskać więcej informacji na temat atrybutów zasobów, zobacz specyfikację zestawu Resource SDK. |
OTEL_SERVICE_NAME |
Ustawia wartość atrybutu service.name zasobu. Jeśli service.name jest również podany w OTEL_RESOURCE_ATTRIBUTES , OTEL_SERVICE_NAME ma pierwszeństwo. |
Zmienna środowiskowa |
opis |
APPLICATIONINSIGHTS_CONNECTION_STRING |
Ustaw go na parametry połączenia dla zasobu usługi Application Insights. |
APPLICATIONINSIGHTS_STATSBEAT_DISABLED |
Aby zrezygnować z wewnętrznego zbierania metryk, ustaw to na true . |
OTEL_RESOURCE_ATTRIBUTES |
Pary klucz-wartość, które mają być używane jako atrybuty zasobów. Aby uzyskać więcej informacji na temat atrybutów zasobów, zobacz specyfikację zestawu Resource SDK. |
OTEL_SERVICE_NAME |
Ustawia wartość atrybutu service.name zasobu. Jeśli service.name jest również podany w OTEL_RESOURCE_ATTRIBUTES , OTEL_SERVICE_NAME ma pierwszeństwo. |
Redaguj ciągi zapytań URL
Aby zredagować ciągi zapytania adresu URL, wyłącz zbieranie ciągów zapytania. Zalecamy to ustawienie, jeśli wywołasz usługę Azure Storage przy użyciu tokenu SAS.
W przypadku korzystania z pakietu dystrybucyjnego Azure.Monitor.OpenTelemetry.AspNetCore zawiera zarówno biblioteki ASP.NET Core, jak i HttpClient Instrumentation.
Nasz pakiet dystrybucyjny domyślnie wyłącza anonimizację ciągów zapytań.
Aby zmienić to zachowanie, należy ustawić zmienną środowiskową na wartość true
lub false
.
- ASP.NET Instrumentacja podstawowa:
OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION
redakcja ciągu zapytania jest domyślnie wyłączona. Aby włączyć, ustaw tę zmienną środowiskową na false
wartość .
- Instrumentacja klienta HTTP:
OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION
redakcja ciągu zapytania jest domyślnie wyłączona. Aby włączyć, ustaw tę zmienną środowiskową na false
wartość .
Korzystając z Azure.Monitor.OpenTelemetry.Exporter, musisz ręcznie dołączyć biblioteki instrumentacji ASP.NET Core lub HttpClient do swojej konfiguracji OpenTelemetry.
Te biblioteki instrumentacji mają domyślnie włączoną funkcję Redaction queryString.
Aby zmienić to zachowanie, należy ustawić zmienną środowiskową na wartość true
lub false
.
- ASP.NET Podstawowe instrumentacja:
OTEL_DOTNET_EXPERIMENTAL_ASPNETCORE_DISABLE_URL_QUERY_REDACTION
redakcja ciągu zapytania jest domyślnie włączona. Aby wyłączyć, ustaw tę zmienną środowiskową na true
wartość .
- Instrumentacja klienta HTTP:
OTEL_DOTNET_EXPERIMENTAL_HTTPCLIENT_DISABLE_URL_QUERY_REDACTION
redakcja ciągu zapytania jest domyślnie włączona. Aby wyłączyć, ustaw tę zmienną środowiskową na true
wartość .
Dodaj następujące elementy do applicationinsights.json
pliku konfiguracji:
{
"preview": {
"processors": [
{
"type": "attribute",
"actions": [
{
"key": "url.query",
"pattern": "^.*$",
"replace": "REDACTED",
"action": "mask"
}
]
},
{
"type": "attribute",
"actions": [
{
"key": "url.full",
"pattern": "[?].*$",
"replace": "?REDACTED",
"action": "mask"
}
]
}
]
}
}
Aktywnie pracujemy w społeczności OpenTelemetry, aby obsłużyć redakcję.
Korzystając z pakietu dystrybucji OpenTelemetry usługi Azure Monitor, ciągi zapytań można redagować przez utworzenie i zastosowanie procesora rozpiętości do konfiguracji dystrybucji.
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);
Aktywnie pracujemy w społeczności OpenTelemetry, aby obsłużyć redakcję.