Az Azure Monitor OpenTelemetry engedélyezése .NET-, Node.js- és Python-alkalmazásokhoz (előzetes verzió)

Az Azure Monitor OpenTelemetry-exportőr egy olyan összetevő, amely nyomkövetéseket és metrikákat (és végül az összes alkalmazás-telemetriát) küld az Azure Monitor Application Insightsnak. Az OpenTelemetry alapfogalmaival kapcsolatos további információkért tekintse meg az OpenTelemetry áttekintését vagy az OpenTelemetry gyiket.

Ez a cikk az OpenTelemetry-alapú Azure Monitor Előzetes verziós ajánlatok engedélyezését és konfigurálását ismerteti. A cikk utasításainak befejezése után OpenTelemetry-nyomkövetéseket és -metrikákat küldhet az Azure Monitor Application Insightsnak.

Fontos

Az Azure Monitor OpenTelemetry-alapú ajánlatai .NET-, Node.js- és Python-alkalmazásokhoz jelenleg előzetes verzióban érhetők el. A bétaverziójú, előzetes verziójú vagy másként még általánosan nem elérhető Azure-szolgáltatások jogi feltételeit lásd: Kiegészítő használati feltételek a Microsoft Azure előzetes verziójú termékeihez.

Az előzetes kiadás korlátozásai

Gondolja át, hogy ez az előzetes verzió megfelel-e Önnek. Lehetővé teszi az elosztott nyomkövetést, a metrikákat és a kizárásokat:

  • Élő metrikák
  • Naplózási API (például konzolnaplók és naplózási kódtárak)
  • Profilkészítő
  • Pillanatkép-hibakereső
  • Hitelesítés Azure Active Directory-fiókkal
  • Felhőbeli szerepkör nevének és felhőbeli szerepkörpéldányának automatikus feltöltése Azure-környezetekben
  • A felhasználói azonosító és a hitelesített felhasználói azonosító automatikus feltöltése az Application Insights JavaScript SDK használatakor
  • A felhasználói IP-cím automatikus feltöltése (a helyattribútumok meghatározásához)
  • Műveletnév felülbírálása
  • Felhasználói azonosító vagy hitelesített felhasználói azonosító manuális beállítása
  • Műveletnév propagálása függőségi telemetriára
  • Eszközkódtárak támogatása Azure Functions
  • Az állapot támogatja a statuscode(unset,ok,error) és az állapotleírást. Az Azure Monitor-exportőrök figyelmen kívül hagyják az "Állapot leírása" kifejezést.

Ha teljes körű felhasználói élményre van szüksége, használja a meglévő Application Insights-ASP.NET vagy ASP.NET Core SDK-t, amíg az OpenTelemetry-alapú ajánlat ki nem ér.

Bevezetés

Az alkalmazás OpenTelemetryvel való kialakításához kövesse az ebben a szakaszban található lépéseket.

Előfeltételek

  • A .NET Core hivatalosan támogatott verzióját vagy .NET-keretrendszer legalább .NET-keretrendszer 4.6.2-es verzióját használó alkalmazás

Az ügyfélkódtárak telepítése

Telepítse a legújabb Azure.Monitor.OpenTelemetry.Exporter NuGet-csomagot:

dotnet add package --prerelease Azure.Monitor.OpenTelemetry.Exporter 

Ha a "Nincs elérhető verzió az Azure.Monitor.OpenTelemetry.Exporter csomaghoz" hibaüzenet jelenik meg, akkor valószínűleg a NuGet-csomagforrások beállítása hiányzik. Próbálja meg megadni a forrást a -s következő beállítással:

# Install the latest package with the NuGet package source specified.
dotnet add package --prerelease Azure.Monitor.OpenTelemetry.Exporter -s https://api.nuget.org/v3/index.json

Az Azure Monitor Application Insights engedélyezése

Ez a szakasz útmutatást nyújt az OpenTelemetry engedélyezéséhez.

OpenTelemetry-eszközkód hozzáadása

Az alábbi kód bemutatja, hogyan engedélyezheti az OpenTelemetryt egy C#-konzolalkalmazásban az OpenTelemetry TracerProvider beállításával. Ennek a kódnak az alkalmazás indításakor kell lennie. A ASP.NET Core általában az ConfigureServices alkalmazásosztály Startup metódusában történik. Az ASP.NET alkalmazások esetében ez általában a következőben Global.asax.cstörténik: .

using System.Diagnostics;
using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Trace;

public class Program
{
    private static readonly ActivitySource MyActivitySource = new ActivitySource(
        "OTel.AzureMonitor.Demo");

    public static void Main()
    {
        using var tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource("OTel.AzureMonitor.Demo")
            .AddAzureMonitorTraceExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        using (var activity = MyActivitySource.StartActivity("TestActivity"))
        {
            activity?.SetTag("CustomTag1", "Value1");
            activity?.SetTag("CustomTag2", "Value2");
        }

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

Megjegyzés

A Activity névtér és ActivitySource osztályai a System.Diagnostics és Traceraz OpenTelemetry fogalmait Span képviselik. A létrehozása ActivitySource közvetlenül a konstruktor használatával történik ahelyett, hogy a használatával hoz TracerProviderlétre. 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.

Tipp

Eszközkódtárakat adhat hozzá a telemetria automatikus gyűjtéséhez a népszerű keretrendszerekben és kódtárakban.

Az Application Insights kapcsolati sztring beállítása

Cserélje le az előző kódban szereplő helyőrzőt <Your Connection String>az Application Insights-erőforrásból származó kapcsolati sztring.

Képernyőkép az Application Insights kapcsolati sztring.

Ellenőrizze, hogy az adatok áramlanak-e

Futtassa az alkalmazást, és nyissa meg az Application Insights-erőforrás lapot a Azure Portal. Eltarthat néhány percig, amíg az adatok megjelennek a portálon.

Megjegyzés

Ha nem tudja futtatni az alkalmazást, vagy nem a várt módon kapja meg az adatokat, tekintse meg a hibaelhárítást ismertető cikket.

Képernyőkép az Application Insights Áttekintés lapról, amelyen a kiszolgálókérések és a kiszolgáló válaszideje ki van emelve.

Fontos

Ha két vagy több olyan szolgáltatással rendelkezik, amelyek telemetriát bocsátanak ki ugyanarra az Application Insights-erőforrásra, be kell állítania a felhőbeli szerepkörneveket , hogy megfelelően ábrázolják őket az alkalmazástérképen.

Az Application Insights rendszerállapotának részeként diagnosztikai adatokat gyűjtünk és küldünk a Microsoftnak. Ezek az adatok segítenek az Application Insights futtatásában és fejlesztésében. Letilthatja a nem lényeges adatgyűjtést. További információ: Statsbeat in Azure-alkalmazás Insights.

A felhőbeli szerepkör nevének és a felhőbeli szerepkörpéldánynak a beállítása

A felhőbeli szerepkör nevét és a felhőbeli szerepkörpéldányt erőforrásattribútumokon keresztül állíthatja be. Ez a lépés frissíti a felhőbeli szerepkör nevét és a felhőbeli szerepkörpéldányt az alapértelmezett értékükről a csapat számára értelmezhető értékre. Az alkalmazástérképen a csomópont alatti névként jelennek meg. A felhőbeli szerepkör neve és service.namespaceservice.name attribútumai, bár visszaesik service.name , ha service.namespace nincs beállítva. A felhőbeli szerepkörpéldány az attribútumértéket service.instance.id használja.

// Setting role name and role instance
var resourceAttributes = new Dictionary<string, object> {
    { "service.name", "my-service" },
    { "service.namespace", "my-namespace" },
    { "service.instance.id", "my-instance" }};
var resourceBuilder = ResourceBuilder.CreateDefault().AddAttributes(resourceAttributes);
// Done setting role name and role instance

// Set ResourceBuilder on the provider.
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddSource("OTel.AzureMonitor.Demo")
    .AddAzureMonitorTraceExporter(o =>
    {
        o.ConnectionString = "<Your Connection String>";
    })
    .Build();

További információ az erőforrások standard attribútumáról: Erőforrás szemantikai konvenciók.

Mintavételezés engedélyezése

Érdemes lehet engedélyezni a mintavételezést az adatbetöltési mennyiség csökkentése érdekében, ami csökkenti a költségeket. Az Azure Monitor egy egyéni rögzített gyakoriságú mintavevőt biztosít, amely "mintavételezési aránysal" tölti fel az eseményeket, amelyet az Application Insights "ItemCount"-ra konvertál. A rögzített gyakoriságú mintavevő pontos élményeket és eseményszámokat biztosít. A mintavevő úgy lett kialakítva, hogy megőrizze a nyomkövetéseket a szolgáltatások között, és együttműködik a régebbi Application Insights SDK-kkal. A mintavevő 0 és 1 közötti mintaarányt vár. A 0,1 arány azt jelenti, hogy a rendszer a nyomkövetések körülbelül 10%-át küldi el. További információ: További információ a mintavételezésről.

Megjegyzés

A metrikákat a mintavételezés nem befolyásolja.

Ebben a példában a -t ApplicationInsightsSamplerhasználjuk, amely kompatibilitást biztosít az Application Insights SDK-kkal.

dotnet add package --prerelease OpenTelemetry.Extensions.AzureMonitor
var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource("OTel.AzureMonitor.Demo")
    .SetSampler(new ApplicationInsightsSampler(0.1F))
    .AddAzureMonitorTraceExporter(o =>
    {
     o.ConnectionString = "<Your Connection String>";
    })
    .Build();

Tipp

Ha nem biztos abban, hogy hol kell beállítani a mintavételezési arányt, kezdje 5%-kal (azaz 0,05 mintavételezési aránysal), és módosítsa a sebességet 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 BÁRMILYEN mintavételezés azonban hatással lesz a pontosságra, ezért javasoljuk, hogy riasztást küldjön az OpenTelemetry-metrikákról, amelyek nem befolyásolják a mintavételezést.

Rendszerállapot-kódtárak

A rendszer ellenőrzi, hogy az alábbi kódtárak működnek-e az előzetes kiadással.

Figyelmeztetés

A rendszerállapot-kódtárak kísérleti OpenTelemetry-specifikációkon alapulnak. A Microsoft előzetes verzióbeli támogatási kötelezettségvállalása annak biztosítása, hogy a következő kódtárak adatokat bocsátanak ki az Azure Monitor Application Insightsnak, de előfordulhat, hogy a kompatibilitástörő változások vagy a kísérleti leképezések blokkolni fognak bizonyos adatelemeket.

Elosztott nyomkövetés

Kérelmek

Függőségek

(1) Támogatja a nem kezelt kivételek automatikus jelentéskészítését (SpanEvent néven).

Mérőszámok

Tipp

Az OpenTelemetry-alapú ajánlatok jelenleg az összes metrikát egyéni metrikákként bocsátják ki a Metrics Explorerben. Bármit is állít be a mérőszám neveként, az lesz a metrikák névtere.

Telemetria módosítása

Ez a szakasz a telemetria módosítását ismerteti.

Span attribútumok hozzáadása

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

Ezek az attribútumok közé tartozhat egy egyéni tulajdonság hozzáadása a telemetriához. Attribútumok használatával is beállíthat választható mezőket az Application Insights-sémában, például az Ügyfél IP-címé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 szolgáltatáshoz. Bármit kiválaszthatnak belőle, és attribútumként tárolhatják.

Egyéni tulajdonság hozzáadása nyomkövetéshez

A spanokhoz hozzáadott attribútumok egyéni tulajdonságokként lesznek exportálva. Feltöltik a customDimensions mezőt a kérelmekben vagy a függőségi táblákban az Application Insightsban.

  1. Számos eszközkódtár nyújt 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

Adja hozzá az itt látható processzort az Azure Monitor-exportőr előtt .

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
        .AddSource("OTel.AzureMonitor.Demo")
        .AddProcessor(new ActivityEnrichingProcessor())
        .AddAzureMonitorTraceExporter(o =>
        {
                o.ConnectionString = "<Your Connection String>"
        })
        .Build();

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

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

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ő kitöltéséhez állítsa be az http.client_ip attribútumot a span értékre. 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:

// only applicable in case of activity.Kind == Server
activity.SetTag("http.client_ip", "<IP Address>");

Szűrőtelemetria

Az alábbi módszerekkel szűrheti ki a telemetriát, mielőtt az elhagyja az alkalmazást.

  1. Számos eszközkó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:

    using var tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource("OTel.AzureMonitor.Demo")
            .AddProcessor(new ActivityFilteringProcessor())
            .AddAzureMonitorTraceExporter(o =>
            {
                    o.ConnectionString = "<Your Connection String>"
            })
            .Build();
    

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

    using System.Diagnostics;
    using OpenTelemetry;
    using OpenTelemetry.Trace;
    
    public class ActivityFilteringProcessor : BaseProcessor<Activity>
    {
        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.

Egyéni telemetria

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

Egyéni metrikák hozzáadása

Megjegyzés

Az egyéni metrikák előzetes verzióban érhetők el az Azure Monitor Application Insightsban. A dimenziók nélküli egyéni metrikák alapértelmezés szerint elérhetők. A dimenziók megtekintéséhez és riasztásához be kell jelentkeznie.

Érdemes lehet metrikákat gyűjteni a rendszerállapot-kódtárak által gyűjtött adatokon túl.

Az OpenTelemetry API hat metrika "műszert" kínál a különböző metrikaforgatókönyvek lefedéséhez, és a metrikák a Metrics Explorerben való vizualizációjakor a megfelelő "Aggregációs típust" kell választania. Ez a követelmény akkor érvényes, ha az OpenTelemetry Metric API-t metrikák küldéséhez és eszközkódtár használata esetén használja.

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

OpenTelemetry Instrument Az Azure Monitor összesítési 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 nagyobb aggregációtípusok általában nem értelmezhetők.

Az OpenTelemetry Specification ismerteti az eszközöket, és példákat ad arra, hogy mikor érdemes ezeket használni.

Tipp

A hisztogram a legsokoldalúbb és legszorosabban egyenértékű a korábbi Application Insights Track Metric 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

using System.Diagnostics.Metrics;
using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Metrics;

public class Program
{
    private static readonly Meter meter = new("OTel.AzureMonitor.Demo");

    public static void Main()
    {
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        Histogram<long> myFruitSalePrice = meter.CreateHistogram<long>("FruitSalePrice");

        var rand = new Random();
        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"));

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

Példa számlálóra

using System.Diagnostics.Metrics;
using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Metrics;

public class Program
{
    private static readonly Meter meter = new("OTel.AzureMonitor.Demo");

    public static void Main()
    {
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        Counter<long> myFruitCounter = meter.CreateCounter<long>("MyFruitCounter");

        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"));

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
}

Példa mérőműszerre

using System.Diagnostics.Metrics;
using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Metrics;

public class Program
{
    private static readonly Meter meter = new("OTel.AzureMonitor.Demo");

    public static void Main()
    {
        using var meterProvider = Sdk.CreateMeterProviderBuilder()
            .AddMeter("OTel.AzureMonitor.Demo")
            .AddAzureMonitorMetricExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>";
            })
            .Build();

        var process = Process.GetCurrentProcess();
        
        ObservableGauge<int> myObservableGauge = meter.CreateObservableGauge("Thread.State", () => GetThreadState(process));

        System.Console.WriteLine("Press Enter key to exit.");
        System.Console.ReadLine();
    }
    
    private static IEnumerable<Measurement<int>> GetThreadState(Process process)
    {
        foreach (ProcessThread thread in process.Threads)
        {
            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 támogatja az Application Insights kivételeit. Előfordulhat azonban, hogy a rendszerállapot-kódtárak jelentésen túli kivételeket is manuálisan szeretne jelenteni. A kód által észlelt kivételek például általában nem* jelennek meg. Jelentheti őket, 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.

using (var activity = activitySource.StartActivity("ExceptionExample"))
{
    try
    {
        throw new Exception("Test exception");
    }
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error);
        activity?.RecordException(ex);
    }
}

Az OTLP-exportőr engedélyezése

Érdemes engedélyeznie az OpenTelemetry Protocol (OTLP) exportőrt az Azure Monitor-exportőr mellett, hogy két helyre küldje a telemetriát.

Megjegyzés

Az OTLP-exportőr csak kényelmi okokból jelenik meg. Hivatalosan nem támogatjuk az OTLP-exportőrt, illetve az azt követő összetevőket vagy harmadik féltől származó tapasztalatokat. Javasoljuk, hogy nyisson meg egy problémát az OpenTelemetry-Collector for OpenTelemetry problémáival kapcsolatban a Azure-támogatás határán kívül.

  1. Telepítse az OpenTelemetry.Exporter.OpenTelemetryProtocol csomagot az Azure.Monitor.OpenTelemetry.Exporter csomaggal együtt a projektben.

  2. Adja hozzá a következő kódrészletet. Ez a példa feltételezi, hogy van egy OpenTelemetry Collector, amelyen egy OTLP-vevő fut. Részletekért tekintse meg a GitHubon található példát.

    // Sends data to Application Insights as well as OTLP
    using var tracerProvider = Sdk.CreateTracerProviderBuilder()
            .AddSource("OTel.AzureMonitor.Demo")
            .AddAzureMonitorTraceExporter(o =>
            {
                o.ConnectionString = "<Your Connection String>"
            })
            .AddOtlpExporter()
            .Build();
    

Konfiguráció

Offline tárolás és automatikus újrapróbálkozások

A megbízhatóság és a rugalmasság javítása érdekében az Azure Monitor OpenTelemetry-alapú ajánlatai alapértelmezés szerint offline/helyi tárolóba írnak, ha egy alkalmazás elveszíti a kapcsolatot az Application Insightsszal. 48 órára menti az alkalmazás telemetriáját, és rendszeres időközönként megpróbálja újra elküldeni. A megengedett idő túllépése mellett a telemetriai adatok időnként el lesznek dobva a nagy terhelésű alkalmazásokban, ha túllépik a maximális fájlméretet, vagy az SDK-nak nincs lehetősége törölni a fájlt. Ha választani kell, a termék menti a legutóbbi eseményeket a régiek fölé. Bizonyos esetekben érdemes lehet letiltani ezt a funkciót az alkalmazás teljesítményének optimalizálása érdekében. További információ

Alapértelmezés szerint az AzureMonitorExporter az alábbi helyek egyikét használja az 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 állítsa be a következőt AzureMonitorExporterOptions.StorageDirectory: .

Például:

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddAzureMonitorTraceExporter(o => {
        o.ConnectionString = "<Your Connection String>";
        o.StorageDirectory = "C:\\SomeDirectory";
    })
    .Build();

A funkció letiltásához be kell állítania a következőt AzureMonitorExporterOptions.DisableOfflineStorage = true: .

Hibaelhárítás

Ez a szakasz segítséget nyújt a hibaelhárításhoz.

Diagnosztikai naplózás engedélyezése

Az Azure Monitor-exportőr az EventSource-t használja a saját belső naplózásához. Az exportőr naplói bármely EventListener számára elérhetők az OpenTelemetry-AzureMonitor-Exporter nevű forrás kiválasztásával. A hibaelhárítási lépésekért tekintse meg az OpenTelemetry hibaelhárítását ismertető cikket.

Ismert problémák

Az Azure Monitor OpenTelemetry-exportőrök ismert problémái a következők:

  • A művelet neve hiányzik a függőségi telemetriai adatokból, ami hátrányosan befolyásolja a hibákat és a teljesítmény lapot.
  • Az eszközmodell hiányzik a kérések és függőségi telemetria alapján, ami hátrányosan befolyásolja az eszköz kohorszelemzését.
  • Az adatbázis-kiszolgáló neve kimarad a függőségi névből, amely helytelenül összesíti az azonos nevű táblákat a különböző kiszolgálókon.

Az alkalmazásgazda és a betöltési szolgáltatás közötti kapcsolat tesztelése

Az Application Insights SDK-k és -ügynökök telemetriát küldenek, hogy REST-hívásokként betöltse a betöltési végpontokat. A webkiszolgálóról vagy az alkalmazásgazdagépről a betöltési szolgáltatás végpontjaihoz való kapcsolódást a PowerShell nyers REST-ügyfélprogramjaival vagy curl-parancsokkal tesztelheti. Lásd: Hiányzó alkalmazástelemetria hibaelhárítása az Azure Monitor Application Insightsban.

Támogatás

Támogatás kérése:

  • Tekintse át a cikkben található hibaelhárítási lépéseket.
  • Azure-támogatás problémák esetén nyisson meg egy Azure-támogatás jegyet.

OpenTelemetry-problémák esetén lépjen kapcsolatba közvetlenül az OpenTelemetry .NET-közösséggel .

OpenTelemetry-visszajelzés

Visszajelzés küldése:

Következő lépések