Megosztás a következőn keresztül:


OpenTelemetria hozzáadása, módosítása és szűrése

Ez a cikk útmutatást nyújt az OpenTelemetria Azure Monitor Application Insights használatával történő hozzáadásához, módosításához és szűréséhez.

Az OpenTelemetry fogalmaival kapcsolatos további információkért tekintse meg az OpenTelemetria áttekintését vagy az OpenTelemetria gyiket.

Automatikus adatgyűjtés

A disztribúciók automatikusan gyűjtenek adatokat az OpenTelemetry-eszközkódtárak összekapcsolásával.

Belefoglalt rendszerállapot-kódtárak

maximális száma

Függőségek

Naplózás

  • ILogger

További információ: ILoggerNaplózás c# és .NET nyelven, valamint kód példák.

Lábjegyzetek

  • ¹: Támogatja a nem kezelt/nem kezelt kivételek automatikus jelentését
  • ²: Támogatja az OpenTelemetry-metrikákat
  • ³: Alapértelmezés szerint a naplózás csak infoszinten vagy magasabb szinten történik. A beállítás módosításához tekintse meg a konfigurációs beállításokat.
  • ⁴: Alapértelmezés szerint a naplózás csak akkor lesz összegyűjtve, ha a naplózás a FIGYELMEZTETÉS vagy magasabb szinten történik.

Feljegyzés

Az Azure Monitor OpenTelemetry Distros egyéni leképezést és logikát tartalmaz az Application Insights standard metrikák automatikus kibocsájtásához.

Tipp.

A rendszerállapot-kódtárakból automatikusan gyűjtött vagy az egyéni kódolásból manuálisan gyűjtött OpenTelemetry-metrikák jelenleg az Application Insights "egyéni mérőszámainak" számítanak számlázási célokra. További információ.

Közösségi rendszerállapot-kódtár hozzáadása

Az OpenTelemetry-közösség rendszerállapot-kódtárainak felvételekor automatikusan további adatokat gyűjthet.

Figyelemfelhívás

Nem támogatjuk és nem garantáljuk a közösségi eszközkódtárak minőségét. Javasoljuk, hogy egy a mi disztribúció, post vagy up-vote a mi visszajelzési közösség. Vegye figyelembe, hogy egyes adatok kísérleti OpenTelemetria-specifikációkon alapulnak, és jövőbeli kompatibilitástörő változásokat eredményezhetnek.

Közösségi kódtár hozzáadásához használja azokat vagy ConfigureOpenTelemetryMeterProviderConfigureOpenTelemetryTracerProvider metódusokat, miután hozzáadta a nuget-csomagot a tárhoz.

Az alábbi példa bemutatja, hogyan adható hozzá a futtatókörnyezeti rendszerállapot a további metrikák gyűjtéséhez.

dotnet add package OpenTelemetry.Instrumentation.Runtime 
// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add runtime instrumentation.
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddRuntimeInstrumentation());

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Egyéni telemetriai adatok gyűjtése

Ez a szakasz bemutatja, hogyan gyűjthet egyéni telemetriát az alkalmazásból.

A nyelvtől és a jeltípustól függően különböző módokon gyűjthet egyéni telemetriát, például:

  • OpenTelemetry API
  • Nyelvspecifikus naplózási/metrikakódtárak
  • Klasszikus Application Insights API

Az alábbi táblázat a jelenleg támogatott egyéni telemetriai típusokat jelöli:

Nyelv Egyéni események Egyéni metrikák Függőségek Kivételek Lapmegtekintések maximális száma Hívásláncok
ASP.NET Core
   OpenTelemetry API Igen Igen Igen Igen
   ILogger API Igen
   Klasszikus AI API
Java
   OpenTelemetry API Igen Igen Igen Igen
   Logback, Log4j, JUL Igen Igen
   Mikrométeres metrikák Igen
   Klasszikus AI API Igen Igen Igen Igen Igen Igen Igen
Node.js
   OpenTelemetry API Igen Igen Igen Igen
Python
   OpenTelemetry API Igen Igen Igen Igen
   Python-naplózási modul Igen
   Eseménybővítmény Igen Igen

Feljegyzés

Az Application Insights Java 3.x figyeli a klasszikus Application Insights API-nak küldött telemetriát. Hasonlóképpen, az Application Insights Node.js 3.x gyűjti a klasszikus Application Insights API-val létrehozott eseményeket. Ez megkönnyíti a frissítést, és betölt egy rést az egyéni telemetriai támogatásban, amíg az OpenTelemetry API nem támogatja az összes egyéni telemetriai típust.

Egyéni metrikák hozzáadása

Ebben az összefüggésben az egyéni metrikák a kód manuális rendszerezésére utalnak, hogy további metrikákat gyűjtsenek az OpenTelemetry Instrumentation Libraries automatikus gyűjtésén túl.

Az OpenTelemetry API hat metrika "eszközt" kínál a különböző metrikaforgatókönyvek lefedéséhez, és a metrikák vizualizációja során a megfelelő "Aggregációs típust" kell választania. Ez a követelmény akkor érvényes, ha az OpenTelemetry Metric API használatával metrikákat küld, és rendszerállapot-kódtárat használ.

Az alábbi táblázat az Egyes OpenTelemetry Metric Instruments ajánlott összesítési típusait mutatja be.

OpenTelemetry Instrument Azure Monitor aggregáció típusa
Számláló Sum
Aszinkron számláló Sum
Hisztogram Min, Max, Average, Sum and Count
Aszinkron mérőműszer Átlag
UpDownCounter Sum
Aszinkron UpDownCounter Sum

Figyelemfelhívás

A táblázatban láthatónál több aggregációtípus általában nem értelmezhető.

Az OpenTelemetria specifikációja ismerteti az eszközöket, és példákat tartalmaz arra, hogy mikor használhatja az egyes eszközöket.

Tipp.

A hisztogram a legsokoldalúbb és legszorosabb egyenértékű az Application Insights GetMetric classic API-val. Az Azure Monitor jelenleg az öt támogatott összesítési típusba simítja a hisztogram-eszközt, és a percentilisek támogatása folyamatban van. Bár kevésbé sokoldalú, más OpenTelemetry-eszközök kevésbé befolyásolják az alkalmazás teljesítményét.

Példa hisztogramra

Az alkalmazásindításnak elő kell fizetnie egy meter név alapján.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Az Meter inicializálást ugyanazzal a névvel kell elvégezni.

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new histogram metric named "FruitSalePrice".
Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

// Create a new Random object.
var rand = new Random();

// Record a few random sale prices for apples and lemons, with different colors.
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "green"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "apple"), new("color", "red"));
myFruitSalePrice.Record(rand.Next(1, 1000), new("name", "lemon"), new("color", "yellow"));

Példa számlálóra

Az alkalmazásindításnak elő kell fizetnie egy meter név alapján.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Az Meter inicializálást ugyanazzal a névvel kell elvégezni.

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new counter metric named "MyFruitCounter".
Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

// Record the number of fruits sold, grouped by name and color.
myFruitCounter.Add(1, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(2, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(1, new("name", "lemon"), new("color", "yellow"));
myFruitCounter.Add(2, new("name", "apple"), new("color", "green"));
myFruitCounter.Add(5, new("name", "apple"), new("color", "red"));
myFruitCounter.Add(4, new("name", "lemon"), new("color", "yellow"));

Példa mérőműszerre

Az alkalmazásindításnak elő kell fizetnie egy meter név alapján.

// Create a new ASP.NET Core web application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry meter provider to add a meter named "OTel.AzureMonitor.Demo".
builder.Services.ConfigureOpenTelemetryMeterProvider((sp, builder) => builder.AddMeter("OTel.AzureMonitor.Demo"));

// Add the Azure Monitor telemetry service to the application.
// This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core web application.
var app = builder.Build();

// Start the ASP.NET Core web application.
app.Run();

Az Meter inicializálást ugyanazzal a névvel kell elvégezni.

// Get the current process.
var process = Process.GetCurrentProcess();

// Create a new meter named "OTel.AzureMonitor.Demo".
var meter = new Meter("OTel.AzureMonitor.Demo");

// Create a new observable gauge metric named "Thread.State".
// This metric will track the state of each thread in the current process.
ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

private static IEnumerable<Measurement<int>> GetThreadState(Process process)
{
    // Iterate over all threads in the current process.
    foreach (ProcessThread thread in process.Threads)
    {
        // Create a measurement for each thread, including the thread state, process ID, and thread ID.
        yield return new((int)thread.ThreadState, new("ProcessId", process.Id), new("ThreadId", thread.Id));
    }
}

Egyéni kivételek hozzáadása

A rendszerállapot-kódtárak kiválasztása automatikusan jelenti az Application Insights kivételeit. Előfordulhat azonban, hogy manuálisan szeretné jelenteni a kivételeket a rendszerállapot-kódtárak jelentéseien túl. A kód által észlelt kivételeket például általában nem jelenti a rendszer. Előfordulhat, hogy fel szeretné őket jelenteni, hogy felhívják a figyelmet a releváns élményekre, beleértve a hibák szakaszt és a végpontok közötti tranzakciónézeteket.

  • Kivétel naplózása tevékenység használatával:
    // Start a new activity named "ExceptionExample".
    using (var activity = activitySource.StartActivity("ExceptionExample"))
    {
        // Try to execute some code.
        try
        {
            throw new Exception("Test exception");
        }
        // If an exception is thrown, catch it and set the activity status to "Error".
        catch (Exception ex)
        {
            activity?.SetStatus(ActivityStatusCode.Error);
            activity?.RecordException(ex);
        }
    }
    
  • Kivétel naplózása a következővel ILogger:
    // Create a logger using the logger factory. The logger category name is used to filter and route log messages.
    var logger = loggerFactory.CreateLogger(logCategoryName);
    
    // Try to execute some code.
    try
    {
        throw new Exception("Test Exception");
    }
    catch (Exception ex)
    {
        // Log an error message with the exception. The log level is set to "Error" and the event ID is set to 0.
        // The log message includes a template and a parameter. The template will be replaced with the value of the parameter when the log message is written.
        logger.Log(
            logLevel: LogLevel.Error,
            eventId: 0,
            exception: ex,
            message: "Hello {name}.",
            args: new object[] { "World" });
    }
    

Egyéni spanok hozzáadása

Előfordulhat, hogy két forgatókönyvben szeretne egyéni tartományt hozzáadni. Először is, ha van egy olyan függőségi kérés, amelyet még nem gyűjtött össze egy eszközkódtár. Másodszor, ha egy alkalmazásfolyamatot szeretne modellezni a teljes körű tranzakciós nézetben.

Feljegyzés

A Activity névtérből származó System.Diagnostics osztályok és ActivitySource osztályok az OpenTelemetry fogalmaitSpan, illetve Tracerazokat jelölik. Közvetlenül a konstruktor használatával hozhat létre ActivitySource , nem pedig a használatával TracerProvider. Minden ActivitySource osztályhoz explicit módon kell kapcsolódni TracerProvider a használatával AddSource(). Ennek az az oka, hogy az OpenTelemetry tracing API egyes részei közvetlenül a .NET-futtatókörnyezetbe vannak beépítve. További információ: Bevezetés az OpenTelemetry .NET Tracing API használatába.

// Define an activity source named "ActivitySourceName". This activity source will be used to create activities for all requests to the application.
internal static readonly ActivitySource activitySource = new("ActivitySourceName");

// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a source named "ActivitySourceName". This will ensure that all activities created by the activity source are traced.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

// Map a GET request to the root path ("/") to the specified action.
app.MapGet("/", () =>
{
    // Start a new activity named "CustomActivity". This activity will be traced and the trace data will be sent to Azure Monitor.
    using (var activity = activitySource.StartActivity("CustomActivity"))
    {
        // your code here
    }

    // Return a response message.
    return $"Hello World!";
});

// Start the ASP.NET Core application.
app.Run();

StartActivity alapértelmezett érték, ActivityKind.Internalde bármely más ActivityKindelemet megadhat. ActivityKind.Client, ActivityKind.Producerés ActivityKind.Internal az Application Insightsra dependenciesvan leképezve. ActivityKind.Server és ActivityKind.Consumer az Application Insightsra requestsvan leképezve.

Egyéni telemetriai adatok küldése a Klasszikus Application Insights API használatával

Javasoljuk, hogy amikor csak lehetséges, használja az OpenTelemetry API-kat, de előfordulhatnak forgatókönyvek, amikor a klasszikus Application Insights API-t kell használnia.

esemény
  1. Adja hozzá Microsoft.ApplicationInsights az alkalmazáshoz.

  2. Hozzon létre egy példányt TelemetryClient .

Feljegyzés

Fontos, hogy alkalmazásonként csak egyszer hozzon létre TelemetryClient-példányt.

var telemetryConfiguration = new TelemetryConfiguration { ConnectionString = "" };
var telemetryClient = new TelemetryClient(telemetryConfiguration);
  1. Az ügyfél használatával egyéni telemetriát küldhet.
telemetryClient.TrackEvent("testEvent");

Telemetria módosítása

Ez a szakasz bemutatja, hogyan módosíthatja a telemetriát.

Span attribútumok hozzáadása

Ezek az attribútumok közé tartozhat egy egyéni tulajdonság hozzáadása a telemetriához. Attribútumokkal is beállíthat választható mezőket az Application Insights-sémában, például az ügyfél IP-címében.

Egyéni tulajdonság hozzáadása spanhoz

A spanokhoz hozzáadott attribútumok egyéni tulajdonságokként lesznek exportálva. Feltöltik a customDimensions mezőt a kérések, függőségek, nyomkövetések vagy kivételek táblában.

Span attribútumok hozzáadásához használja az alábbi két módszer egyikét:

Tipp.

A rendszerállapot-kódtárak által biztosított lehetőségek használatának előnye, hogy ha elérhetők, a teljes környezet elérhető. Ennek eredményeképpen a felhasználók további attribútumokat adhatnak hozzá vagy szűrhetnek. A HttpClient-eszköztár bővítési lehetősége például hozzáférést biztosít a felhasználóknak a HttpRequestMessage-hez és magához a HttpResponseMessage-hez . Bármit kiválaszthatnak belőle, és attribútumként tárolhatják.

  1. Számos rendszerállapot-kódtár kínál bővítési lehetőséget. Útmutatásért tekintse meg az egyes eszközkódtárak olvasási fájljait:

  2. Egyéni processzor használata:

Tipp.

Az Azure Monitor hozzáadása előtt adja hozzá az itt látható processzort.

// Create an ASP.NET Core application builder.
var builder = WebApplication.CreateBuilder(args);

// Configure the OpenTelemetry tracer provider to add a new processor named ActivityEnrichingProcessor.
builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityEnrichingProcessor()));

// Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
builder.Services.AddOpenTelemetry().UseAzureMonitor();

// Build the ASP.NET Core application.
var app = builder.Build();

// Start the ASP.NET Core application.
app.Run();

Adja hozzá ActivityEnrichingProcessor.cs a projekthez a következő kóddal:

public class ActivityEnrichingProcessor : BaseProcessor<Activity>
{
    public override void OnEnd(Activity activity)
    {
        // The updated activity will be available to all processors which are called after this processor.
        activity.DisplayName = "Updated-" + activity.DisplayName;
        activity.SetTag("CustomDimension1", "Value1");
        activity.SetTag("CustomDimension2", "Value2");
    }
}

A felhasználói IP-cím beállítása

A kérések client_IP mezőjét feltöltheti egy attribútum beállításával. Az Application Insights az IP-cím használatával hoz létre felhasználói helyattribútumokat, majd alapértelmezés szerint elveti.

Használja az egyéni tulajdonság hozzáadása példát, de cserélje le a következő kódsorokat a következőben ActivityEnrichingProcessor.cs:

// Add the client IP address to the activity as a tag.
// only applicable in case of activity.Kind == Server
activity.SetTag("client.address", "<IP Address>");

A felhasználói azonosító vagy a hitelesített felhasználói azonosító beállítása

A kérések user_Id vagy user_AuthenticatedId mezőjét az alábbi útmutató segítségével töltheti fel. A felhasználói azonosító névtelen felhasználói azonosító. A hitelesített felhasználói azonosító egy ismert felhasználói azonosító.

Fontos

A hitelesített felhasználói azonosító beállítása előtt tekintse meg a vonatkozó adatvédelmi jogszabályokat.

Használja az egyéni tulajdonság hozzáadása példát.

// Add the user ID to the activity as a tag, but only if the activity is not null.
activity?.SetTag("enduser.id", "<User Id>");

Naplóattribútumok hozzáadása

Az OpenTelemetry a . NET's ILogger. Az egyéni dimenziók naplókhoz való csatolása üzenetsablon használatával végezhető el.

Szűrőtelemetria

Az alkalmazás elhagyása előtt az alábbi módszerekkel szűrheti ki a telemetriát.

  1. Számos rendszerállapot-kódtár biztosít szűrőbeállítást. Útmutatásért tekintse meg az egyes eszközkódtárak olvasási fájljait:

  2. Egyéni processzor használata:

    Tipp.

    Az Azure Monitor hozzáadása előtt adja hozzá az itt látható processzort.

    // Create an ASP.NET Core application builder.
    var builder = WebApplication.CreateBuilder(args);
    
    // Configure the OpenTelemetry tracer provider to add a new processor named ActivityFilteringProcessor.
    builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddProcessor(new ActivityFilteringProcessor()));
    // Configure the OpenTelemetry tracer provider to add a new source named "ActivitySourceName".
    builder.Services.ConfigureOpenTelemetryTracerProvider((sp, builder) => builder.AddSource("ActivitySourceName"));
    // Add the Azure Monitor telemetry service to the application. This service will collect and send telemetry data to Azure Monitor.
    builder.Services.AddOpenTelemetry().UseAzureMonitor();
    
    // Build the ASP.NET Core application.
    var app = builder.Build();
    
    // Start the ASP.NET Core application.
    app.Run();
    

    Adja hozzá ActivityFilteringProcessor.cs a projekthez a következő kóddal:

    public class ActivityFilteringProcessor : BaseProcessor<Activity>
    {
        // The OnStart method is called when an activity is started. This is the ideal place to filter activities.
        public override void OnStart(Activity activity)
        {
            // prevents all exporters from exporting internal activities
            if (activity.Kind == ActivityKind.Internal)
            {
                activity.IsAllDataRequested = false;
            }
        }
    }
    
  3. Ha egy adott forrás nincs explicit módon hozzáadva a használatával AddSource("ActivitySourceName"), akkor az adott forrás használatával létrehozott tevékenységek egyike sem lesz exportálva.

A nyomkövetési azonosító vagy a span azonosítójának lekérése

Érdemes lehet lekérni a nyomkövetési azonosítót vagy a span azonosítót. Ha az Application Insightstól eltérő célhelyre küldött naplókat, fontolja meg a nyomkövetési azonosító vagy a span azonosító hozzáadását. Ezzel jobb korrelációt tesz lehetővé a hibák hibakeresése és diagnosztizálása során.

Feljegyzés

A Activity névtérből származó System.Diagnostics osztályok és ActivitySource osztályok az OpenTelemetry fogalmaitSpan, illetve Tracerazokat jelölik. Ennek az az oka, hogy az OpenTelemetry tracing API egyes részei közvetlenül a .NET-futtatókörnyezetbe vannak beépítve. További információ: Bevezetés az OpenTelemetry .NET Tracing API használatába.

// Get the current activity.
Activity activity = Activity.Current;
// Get the trace ID of the activity.
string traceId = activity?.TraceId.ToHexString();
// Get the span ID of the activity.
string spanId = activity?.SpanId.ToHexString();

Következő lépések

Gyakori kérdések

Ez a szakasz választ ad a gyakori kérdésekre.

Mi az OpenTelemetria?

Ez egy új nyílt forráskódú szabvány a megfigyelhetőséghez. További információ az OpenTelemetryről.

Miért fektet be a Microsoft Azure Monitor az OpenTelemetrybe?

A Microsoft az OpenTelemetria legnagyobb közreműködői közé tartozik.

Az OpenTelemetria fő értékajánlata, hogy szállítósemleges, és egységes API-kat/SDK-kat biztosít a nyelvek között.

Úgy gondoljuk, hogy az OpenTelemetry idővel lehetővé teszi az Azure Monitor-ügyfelek számára, hogy a támogatott nyelveken kívül más nyelveken írt alkalmazásokat figyeljenek meg. Emellett a rendszerállapot-kódtárak széles halmazán keresztül összegyűjthető adattípusokat is kibővíti. Emellett az OpenTelemetry Software Development Kits (SDK-k) nagyobb teljesítményűek, mint elődjeik, az Application Insights SDK-k.

Végül az OpenTelemetry igazodik a Microsoft stratégiájához, amely nyílt forráskód.

Mi az OpenTelemetria állapota?

Lásd: OpenTelemetry Status.

Mi az "Azure Monitor OpenTelemetry Distro"?

Úgy tekinthet rá, mint egy vékony burkolóra, amely összecsomagol minden OpenTelemetry-összetevőt egy első osztályú Azure-élmény érdekében. Ezt a burkolót az OpenTelemetryben disztribúciónak is nevezik.

Miért érdemes az "Azure Monitor OpenTelemetry Distro"-t használni?

Az Azure Monitor OpenTelemetry Distro használatának számos előnye van a közösség natív OpenTelemetry-ével szemben:

Az OpenTelemetria szellemében úgy terveztük meg a disztribúciót, hogy nyitott és bővíthető legyen. Hozzáadhatja például a következőt:

  • OpenTelemetry Protocol (OTLP) exportőr, és küldd el egy második cél egyidejűleg
  • A disztribúcióban nem szereplő egyéb eszközkódtárak

Mivel a Disztribúció OpenTelemetria-disztribúciót biztosít, a Disztribúció az OpenTelemetria által támogatott bármit támogat. Hozzáadhat például több telemetriai processzort, exportőrt vagy rendszerállapot-kódtárat, ha az OpenTelemetria támogatja őket.

Feljegyzés

A disztribúció egyéni, rögzített díjas mintavevőre állítja a mintavevőt az Application Insightshoz. Ezt módosíthatja egy másik mintavevőre, de ezzel letilthatja a Disztribúció egyes funkcióit. A támogatott mintavevőről az Azure Monitor OpenTelemetria konfigurálásának mintavételezés engedélyezése című szakaszában talál további információt.

A támogatott önálló OpenTelemetry-exportőr nélküli nyelvek esetében az Azure Monitor OpenTelemetry Distro az egyetlen jelenleg támogatott módszer az OpenTelemetry és az Azure Monitor használatára. A támogatott önálló OpenTelemetry-exportőrrel rendelkező nyelvek esetében lehetősége van az Azure Monitor OpenTelemetry Distro vagy a megfelelő önálló OpenTelemetry-exportőr használatára a telemetriai forgatókönyvtől függően. További információ: Mikor érdemes használni az Azure Monitor OpenTelemetry-exportőrt?.

Hogyan tesztelhetem az Azure Monitor OpenTelemetry disztribúciót?

Tekintse meg a .NET, a Java, a JavaScript (Node.js) és a Python engedélyezési dokumentációját.

Használjam az OpenTelemetryt vagy az Application Insights SDK-t?

Az OpenTelemetria-disztribúció használatát javasoljuk, kivéve, ha olyan szolgáltatásra van szüksége , amely csak formális támogatással érhető el az Application Insights SDK-ban.

Az OpenTelemetria bevezetése megakadályozza, hogy később migráljon.

Mikor érdemes használni az Azure Monitor OpenTelemetry-exportőrt?

ASP.NET Core, Java, Node.js és Python esetén az Azure Monitor OpenTelemetry Distro használatát javasoljuk. Ez egy kódsor az első lépésekhez.

Minden más .NET-forgatókönyv esetében, beleértve a klasszikus ASP.NET, a konzolalkalmazásokat, a Windows Formst (WinForms) stb., javasoljuk, hogy használja a .NET Azure Monitor OpenTelemetry exportőrt: Azure.Monitor.OpenTelemetry.Exporter.

Összetettebb, speciális konfigurációt igénylő Python-telemetriai forgatókönyvek esetén javasoljuk a Python Azure Monitor OpenTelemetry-exportőr használatát.

Mi az Azure Monitor OpenTelemetry Distro funkcióinak aktuális kiadási állapota?

Az alábbi diagram az Egyes nyelvek OpenTelemetry funkciójának támogatását mutatja be.

Szolgáltatás .NET Node.js Python Java
Elosztott nyomkövetés
Egyéni metrikák
Standard metrikák (a mintavételezés által jelenleg érintett pontosság)
Rögzített gyakoriságú mintavételezés
Offline tárolás és automatikus újrapróbálkozás
Kivételjelentés
Naplók gyűjteménye ⚠️
Egyéni események ⚠️ ⚠️ ⚠️
Microsoft Entra hitelesítés
Élő metrikák
Élő metrikák szűrése
Erőforrás-környezet észlelése virtuális géphez/VMSS-hez és App Service-hez
Az Azure Kubernetes Service (AKS) és a Functions erőforrás-környezetének észlelése
A Rendelkezésre állás nyomon követése API használatával létrehozott rendelkezésre állási tesztelési események
Kérelmek, függőségek, naplók és kivételek szűrése névtelen felhasználói azonosító és szintetikus forrás alapján
Függőségek, naplók és kivételek szűrése műveletnév alapján
Adaptív mintavételezés
Profilkészítő ⚠️
Pillanatkép-hibakereső

Kulcs

  • ✅ Ez a funkció minden hivatalos támogatással rendelkező ügyfél számára elérhető.
  • ⚠️ Ez a funkció nyilvános előzetes verzióként érhető el. Lásd a Microsoft Azure előzetes verziójának használati feltételeit.
  • ❌ Ez a funkció nem érhető el, vagy nem alkalmazható.

Használható az OpenTelemetria webböngészőkhöz?

Igen, de nem javasoljuk, és az Azure nem támogatja. Az OpenTelemetry JavaScript nagymértékben optimalizálva van Node.js. Ehelyett az Application Insights JavaScript SDK használatát javasoljuk.

Mikor várható, hogy az OpenTelemetry SDK elérhető lesz a webböngészőkben?

Az OpenTelemetry webes SDK nem rendelkezik meghatározott rendelkezésre állási ütemtervvel. Valószínűleg több évnyire vagyunk a böngésző SDK-tól, amely az Application Insights JavaScript SDK életképes alternatívája.

Tesztelhetem az OpenTelemetryt egy webböngészőben?

Az OpenTelemetry webes tesztkörnyezete egy elágazás, amely arra szolgál, hogy az OpenTelemetria működjön egy böngészőben. Még nem lehet telemetriát küldeni az Application Insightsnak. Az SDK nem definiál általános ügyféleseményeket.

Támogatott az Application Insights futtatása olyan versenytársakkal, mint az AppDynamics, a DataDog és a NewRelic?

Ezt a gyakorlatot nem tervezzük tesztelni vagy támogatni, bár distribúcióink lehetővé teszik, hogy egyszerre exportáljon egy OTLP-végpontra az Azure Monitor mellett.

Használhatok előzetes verziójú funkciókat éles környezetekben?

Nem javasoljuk. Lásd a Microsoft Azure előzetes verziójának használati feltételeit.

Mi a különbség a manuális és az automatikus rendszerállapot között?

Tekintse meg az OpenTelemetry áttekintését.

Használhatom az OpenTelemetry Collectort?

Egyes ügyfelek az OpenTelemetry Collectort használják ügynök alternatívaként, annak ellenére, hogy a Microsoft hivatalosan még nem támogatja az alkalmazásfigyelés ügynökalapú megközelítését. Addig is a nyílt forráskódú közösség hozzájárult egy OpenTelemetry Collector Azure Monitor-exportőrhöz , amellyel egyes ügyfelek adatokat küldenek az Azure Monitor Application Insightsnak. Ezt a Microsoft nem támogatja.

Mi a különbség az OpenCensus és az OpenTelemetria között?

Az OpenCensus az OpenTelemetria előfutára. A Microsoft segített összehozni az OpenTracinget és az OpenCensust az OpenTelemetria létrehozásához, amely a világ egyetlen megfigyelhetőségi szabványa. Az Azure Monitorhoz készült, jelenleg éles környezetben ajánlott Python SDK az OpenCensuson alapul. A Microsoft elkötelezett az Azure Monitor OpenTelemetria-alapúvá tétele mellett.

Hibaelhárítás

Nem működik? Tekintse meg a ASP.NET Core hibaelhárítási oldalát.

Támogatás

Válasszon egy lapot a választott nyelvhez a támogatási lehetőségek felderítéséhez.

OpenTelemetry-visszajelzés

Visszajelzés küldése: