Share via

Azure Metrics Advisor-Clientbibliothek für .NET– Version 1.1.0

  • Artikel

Azure Cognitive Services Metrics Advisor ist ein Clouddienst, der maschinelles Lernen verwendet, um Anomalien in Zeitreihendaten zu überwachen und zu erkennen. Es umfasst die folgenden Funktionen:

  • Analysieren sie mehrdimensionale Daten aus mehreren Datenquellen.
  • Identifizieren und Korrelieren von Anomalien.
  • Konfigurieren und optimieren Sie das für Ihre Daten verwendete Anomalieerkennungsmodell.
  • Diagnostizieren von Anomalien und Bereitstellen von Unterstützung bei der Ursachenanalyse

Quellcode | Paket (NuGet) | API-Referenzdokumentation | Produktdokumentation | Proben

Erste Schritte

Installieren des Pakets

Installieren Sie die Azure Metrics Advisor-Clientbibliothek für .NET mit NuGet:

dotnet add package Azure.AI.MetricsAdvisor

Voraussetzungen

Erstellen einer Metrics Advisor-Ressource

Sie können eine Metrics Advisor-Ressource mit folgenden Aktionen erstellen:

Option 1: Azure-Portal.

Option 2: Azure CLI.

Im Folgenden finden Sie ein Beispiel dafür, wie Sie eine Metrics Advisor-Ressource mithilfe der CLI erstellen können:

# Create a new resource group to hold the Metrics Advisor resource.
# If using an existing resource group, skip this step.
az group create --name <your-resource-name> --location <location>

# Create the Metrics Advisor resource.
az cognitiveservices account create \
    --name <your-resource-name> \
    --resource-group <your-resource-group-name> \
    --kind MetricsAdvisor \
    --sku <sku> \
    --location <location>
    --yes

Weitere Informationen zum Erstellen der Ressource oder zum Abrufen des Standorts und der SKU finden Sie hier.

Authentifizieren des Clients

Um mit dem Metrics Advisor-Dienst zu interagieren, müssen Sie eine instance der MetricsAdvisorClient - oder -MetricsAdvisorAdministrationClientKlassen erstellen. Sie benötigen einen Endpunkt, einen Abonnementschlüssel und einen API-Schlüssel , um ein Clientobjekt zu instanziieren.

Abrufen des Endpunkts und des Abonnementschlüssels

Sie können den Endpunkt und den Abonnementschlüssel aus den Ressourceninformationen im Azure-Portal abrufen.

Alternativ können Sie den folgenden Azure CLI-Codeausschnitt verwenden, um den Abonnementschlüssel aus der Metrics Advisor-Ressource abzurufen.

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

Abrufen des API-Schlüssels

Sie können den API-Schlüssel im Metrics Advisor-Webportal abrufen. Sie werden aufgefordert, sich für die Authentifizierung anzumelden.

Nachdem Sie angemeldet sind, geben Sie den Namen Ihrer Azure Active Directory-, Abonnement- und Metrics Advisor-Ressource ein.

Erstellen eines MetricsAdvisorClient oder eines MetricsAdvisorAdministrationClient

Nachdem Sie über das Abonnement und die API-Schlüssel verfügen, erstellen Sie eine MetricsAdvisorKeyCredential. Mit dem Endpunkt und den Schlüsselanmeldeinformationen können Sie das Element MetricsAdvisorClient erstellen:

string endpoint = "<endpoint>";
string subscriptionKey = "<subscriptionKey>";
string apiKey = "<apiKey>";
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var client = new MetricsAdvisorClient(new Uri(endpoint), credential);

Darüber hinaus können Sie das Element MetricsAdvisorAdministrationClient erstellen, um Verwaltungsvorgänge durchzuführen:

string endpoint = "<endpoint>";
string subscriptionKey = "<subscriptionKey>";
string apiKey = "<apiKey>";
var credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
var adminClient = new MetricsAdvisorAdministrationClient(new Uri(endpoint), credential);

Erstellen eines MetricsAdvisorClient oder eines MetricsAdvisorAdministrationClient mit Azure Active Directory

MetricsAdvisorKeyCredential Die Authentifizierung wird in den Beispielen in diesem Leitfaden zu den ersten Schritten verwendet, Sie können sich aber auch mithilfe der Azure Identity-Bibliothek bei Azure Active Directory authentifizieren.

Um den unten gezeigten DefaultAzureCredential-Anbieter oder andere Anmeldeinformationsanbieter zu verwenden, die mit dem Azure SDK bereitgestellt werden, installieren Sie das Azure.Identity Paket:

Install-Package Azure.Identity

Außerdem müssen Sie eine neue AAD-Anwendung registrieren und Zugriff auf Metrics Advisor gewähren, indem Sie die "Cognitive Services Metrics Advisor User" Rolle Ihrem Dienstprinzipal zuweisen. Sie können stattdessen die "Cognitive Services Metrics Advisor Administrator" Rolle zuweisen, wenn Administratorrechte erforderlich sind.

Legen Sie die Werte der Client-ID, mandanten-ID und des geheimen Clientschlüssels der AAD-Anwendung als Umgebungsvariablen fest: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

Nachdem Sie die Umgebungsvariablen festgelegt haben, können Sie eine MetricsAdvisorClienterstellen:

string endpoint = "<endpoint>";
var client = new MetricsAdvisorClient(new Uri(endpoint), new DefaultAzureCredential());

Alternativ können Sie auch ein MetricsAdvisorAdministrationClient erstellen, um Verwaltungsvorgänge auszuführen:

string endpoint = "<endpoint>";
var adminClient = new MetricsAdvisorAdministrationClient(new Uri(endpoint), new DefaultAzureCredential());

Wichtige Begriffe

MetricsAdvisorClient

MetricsAdvisorClient ist die primäre Abfrageschnittstelle für Entwickler, die die Metrics Advisor-Clientbibliothek verwenden. Es bietet synchrone und asynchrone Methoden für den Zugriff auf eine bestimmte Verwendung von Metrics Advisor, z. B. das Auflisten von Incidents, das Abrufen von Grundursachen von Incidents und das Abrufen von Zeitreihendaten.

MetricsAdvisorAdministrationClient

MetricsAdvisorAdministrationClient ist die Schnittstelle, die für die Verwaltung von Entitäten in der Metrics Advisor-Ressource verantwortlich ist. Es bietet synchrone und asynchrone Methoden für Aufgaben wie das Erstellen und Aktualisieren von Datenfeeds, Anomalieerkennungskonfigurationen und Anomaliewarnungskonfigurationen.

Datenfeed

Ein DataFeed erfasst regelmäßig Tabellen mit aggregierten Daten aus Ihrer Datenquelle, z. B. CosmosDB oder einem SQL-Server, und stellt sie für den Metrics Advisor-Dienst zur Verfügung. Es ist der Einstiegspunkt für Daten und daher der erste erforderliche Agent, der festgelegt werden muss, bevor die Anomalieerkennung erfolgen kann. Weitere Informationen finden Sie weiter unten im Beispiel Erstellen eines Datenfeeds aus einer Datenquelle .

Datenfeedmetrik

Eine DataFeedMetric- oder einfach "Metrik" ist ein quantifizierbares Measure, mit dem die status eines bestimmten Geschäftsprozesses überwacht wird. Es kann sich um die Kosten eines Produkts im Laufe der Monate oder sogar um ein tägliches Maß für die Temperatur handeln. Der Dienst überwacht, wie sich dieser Wert im Laufe der Zeit bei der Suche nach einem anomalen Verhalten ändert. Ein Datenfeed kann mehrere Metriken aus derselben Datenquelle erfassen.

Datenfeeddimension

Eine DataFeedDimension- oder einfach "Dimension" ist ein kategorischer Wert, der eine Metrik kennzeichnet. Wenn instance eine Metrik die Kosten eines Produkts darstellt, könnten die Art des Produkts (z. B. Schuhe, Hüte) und die Stadt, in der diese Werte gemessen wurden (z. B. New York, Tokio), als Dimension verwendet werden. Die Kombination mehrerer Dimensionen identifiziert eine bestimmte univariate Zeitreihe.

Zeitreihe

Eine Zeitreihe ist eine Sequenz von Datenpunkten, die chronologisch indiziert sind. Diese Datenpunkte beschreiben die Variation des Werts einer Metrik im Laufe der Zeit.

Bei einer Metrik erstellt der Metrics Advisor-Dienst eine Datenreihe für jede mögliche Kombination von Dimensionswerten . Dies bedeutet, dass mehrere Zeitreihen für dieselbe Metrik überwacht werden können.

Angenommen, die folgenden Datenspalten werden von Ihrer Datenquelle zurückgegeben:

City Category Kosten Umsatz
New York Schuhe 1045.00 1345.00
New York Hüte 670.00 502.00
Delhi Schuhe 991.00 1009.00
Delhi Hüte 623.00 711.00

Kosten und Umsatz sind die Metriken, die der Dienst überwachen soll, während Stadt und Kategorie die Dimensionen sind, die diese Metriken charakterisieren. In diesen Daten gibt es vier mögliche Dimensionskombinationen:

  • City = New York, Kategorie = Schuhe
  • City = New York, Kategorie = Hüte
  • City = Delhi, Kategorie = Schuhe
  • City = Delhi, Kategorie = Hüte

Für jede Metrik erstellt der Dienst vier Zeitreihen zum Überwachen von Daten, wobei jede eine mögliche Dimensionskombination darstellt. Bei jeder Datenquellenerfassung werden diese Datenreihen mit einem neuen Datenpunkt aktualisiert, sofern in den neu erfassten Daten verfügbar.

Datenpunktanomalie

Eine DataPointAnomaly- oder einfach "Anomalie" tritt auf, wenn sich ein Datenpunkt in einer Zeitreihe unerwartet verhält. Dies kann auftreten, wenn ein Datenpunktwert zu hoch oder zu niedrig ist oder wenn sich der Wert zwischen Denkpunkten plötzlich ändert. Sie können die Bedingungen angeben, die ein Datenpunkt erfüllen muss, um bei einem AnomalyDetectionConfigurationals Anomalie betrachtet zu werden. Nach der Datenerfassung wendet der Dienst bei der Suche nach Anomalien alle vorhandenen Konfigurationen auf den Satz neuer Punkte an. Weitere Informationen finden Sie weiter unten im Beispiel Erstellen einer Anomalieerkennungskonfiguration .

Anomalievorfall

Wenn Anomalien in mehreren Zeitreihen innerhalb einer Metrik zu einem bestimmten Zeitstempel erkannt werden, gruppiert der Metrics Advisor-Dienst Anomalien, die dieselbe Grundursache gemeinsam haben, automatisch in einem AnomalyIncidentoder einfach "Incident". Dadurch wird der Aufwand, jede einzelne Anomalie zu überprüfen, erheblich verringert und schnell den wichtigsten Faktor gefunden, der zu einem Problem beiträgt.

Anomaliewarnung

Eine AnomalyAlertoder einfach "Warnung" wird ausgelöst, wenn eine erkannte Anomalie ein angegebenes Kriterium erfüllt. Bei instance kann jedes Mal eine Warnung ausgelöst werden, wenn eine Anomalie mit hohem Schweregrad erkannt wird. Sie können die Bedingungen angeben, die eine Anomalie erfüllen muss, um eine Warnung mit auszulösen AnomalyAlertConfiguration. Nachdem die Anomalieerkennung über neu erfasste Datenpunkte durchgeführt wurde, wendet der Dienst alle vorhandenen Konfigurationen auf die neuen Anomalien an, und jede Konfiguration löst eine einzelne Warnung für den Satz von Punkten aus, die die angegebenen Kriterien erfüllen. Warnungskonfigurationen sind nicht standardmäßig festgelegt, daher müssen Sie eine erstellen, um Warnungen auszulösen. Weitere Informationen finden Sie weiter unten im Beispiel Erstellen einer Anomaliewarnungskonfiguration .

Notification Hook

Ein NotificationHookoder einfach "Hook" ist ein Mittel zum Abonnieren von Warnungsbenachrichtigungen . Sie können einen Hook an ein AnomalyAlertConfiguration übergeben und Benachrichtigungen für jede erstellte Warnung erhalten. Weitere Informationen finden Sie weiter unten im Beispiel Erstellen eines Hooks zum Empfangen von Anomaliewarnungen .

Threadsicherheit

Wir garantieren, dass alle Client-instance Methoden threadsicher und unabhängig voneinander sind (Richtlinie). Dadurch wird sichergestellt, dass die Empfehlung, Clientinstanzen wiederzuverwenden, immer sicher ist, auch threadsübergreifend.

Zusätzliche Konzepte

Clientoptionen | Zugreifen auf die Antwort | Behandeln von Fehlern | Diagnose | Spott | Clientlebensdauer

Beispiele

Der folgende Abschnitt enthält mehrere Codeausschnitte, die gängige Muster veranschaulichen, die in der Metrikratgeber-.NET-API verwendet werden. Die folgenden Codeausschnitte verwenden asynchrone Dienstaufrufe. Beachten Sie jedoch, dass das Azure.AI.MetricsAdvisor-Paket sowohl synchrone als auch asynchrone APIs unterstützt.

Erstellen eines Datenfeeds aus einer Datenquelle

Metrics Advisor unterstützt mehrere Arten von Datenquellen. In diesem Beispiel wird veranschaulicht, wie Sie ein DataFeed-Element erstellen, mit dem Daten aus einer SQL Server-Instanz extrahiert werden.

string sqlServerConnectionString = "<connectionString>";
string sqlServerQuery = "<query>";

var dataFeed = new DataFeed();

dataFeed.Name = "<dataFeedName>";
dataFeed.DataSource = new SqlServerDataFeedSource(sqlServerConnectionString, sqlServerQuery);
dataFeed.Granularity = new DataFeedGranularity(DataFeedGranularityType.Daily);

dataFeed.Schema = new DataFeedSchema();
dataFeed.Schema.MetricColumns.Add(new DataFeedMetric("cost"));
dataFeed.Schema.MetricColumns.Add(new DataFeedMetric("revenue"));
dataFeed.Schema.DimensionColumns.Add(new DataFeedDimension("category"));
dataFeed.Schema.DimensionColumns.Add(new DataFeedDimension("city"));

dataFeed.IngestionSettings = new DataFeedIngestionSettings(DateTimeOffset.Parse("2020-01-01T00:00:00Z"));

Response<DataFeed> response = await adminClient.CreateDataFeedAsync(dataFeed);

DataFeed createdDataFeed = response.Value;

Console.WriteLine($"Data feed ID: {createdDataFeed.Id}");
Console.WriteLine($"Data feed status: {createdDataFeed.Status.Value}");
Console.WriteLine($"Data feed created time: {createdDataFeed.CreatedOn.Value}");

Console.WriteLine($"Data feed administrators:");
foreach (string admin in createdDataFeed.Administrators)
{
    Console.WriteLine($" - {admin}");
}

Console.WriteLine($"Metric IDs:");
foreach (DataFeedMetric metric in createdDataFeed.Schema.MetricColumns)
{
    Console.WriteLine($" - {metric.Name}: {metric.Id}");
}

Console.WriteLine($"Dimensions:");
foreach (DataFeedDimension dimension in createdDataFeed.Schema.DimensionColumns)
{
    Console.WriteLine($" - {dimension.Name}");
}

Andere Datenquellenauthentifizierungsalternativen

Einige Datenquellen unterstützen mehrere Authentifizierungstypen. Ein SqlServerDataFeedSource unterstützt beispielsweise Verbindungszeichenfolge, Dienstprinzipal und verwaltete Identität. Sie können die vollständige Liste der Datenquellen und deren Authentifizierungstypen hier überprüfen.

Nachdem Sie sichergestellt haben, dass Ihre Datenquelle die zu verwendende Authentifizierung unterstützt, müssen Sie die Authentication Eigenschaft beim Erstellen oder Aktualisieren der Datenquelle festlegen:

var dataSoure = new SqlServerDataFeedSource("<connection-string>", "<query>")
{
    Authentication = SqlServerDataFeedSource.AuthenticationType.ManagedIdentity
};

Beachten Sie, dass Sie mit Ausnahme der Basic Authentifizierungstypen und ManagedIdentity auch über die ID eines entsprechenden DataSourceCredentialEntity im Dienst verfügen müssen. Um eine Entität für Anmeldeinformationen zu erstellen, müssen Sie Folgendes tun:

string credentialName = "<credentialName>";

var credentialEntity = new ServicePrincipalCredentialEntity(credentialName, "<clientId>", "<clientSecret>", "<tenantId>");

Response<DataSourceCredentialEntity> response = await adminClient.CreateDataSourceCredentialAsync(credentialEntity);

DataSourceCredentialEntity createdCredentialEntity = response.Value;

Console.WriteLine($"Credential entity ID: {createdCredentialEntity.Id}");

Sobald Sie die ID besitzen, fügen Sie sie der DataSourceCredentialId Eigenschaft hinzu, wenn Sie Ihre Datenquelle einrichten:

var dataSoure = new SqlServerDataFeedSource("<connection-string>", "<query>")
{
    Authentication = SqlServerDataFeedSource.AuthenticationType.ServicePrincipal,
    DataSourceCredentialId = "<credentialId>"
};

Überprüfen der Erfassung status eines Datenfeeds

Überprüfen Sie die Erfassung status eines zuvor erstellten DataFeed.

string dataFeedId = "<dataFeedId>";

var startsOn = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endsOn = DateTimeOffset.Parse("2020-09-09T00:00:00Z");
var options = new GetDataFeedIngestionStatusesOptions(startsOn, endsOn)
{
    MaxPageSize = 5
};

Console.WriteLine("Ingestion statuses:");
Console.WriteLine();

int statusCount = 0;

await foreach (DataFeedIngestionStatus ingestionStatus in adminClient.GetDataFeedIngestionStatusesAsync(dataFeedId, options))
{
    Console.WriteLine($"Timestamp: {ingestionStatus.Timestamp}");
    Console.WriteLine($"Status: {ingestionStatus.Status}");
    Console.WriteLine($"Service message: {ingestionStatus.Message}");
    Console.WriteLine();

    // Print at most 5 statuses.
    if (++statusCount >= 5)
    {
        break;
    }
}

Erstellen einer Anomalieerkennungskonfiguration

Erstellen Sie einen AnomalyDetectionConfiguration , um dem Dienst mitzuteilen, welche Datenpunkte als Anomalien betrachtet werden sollen.

string metricId = "<metricId>";
string configurationName = "<configurationName>";

var detectionConfiguration = new AnomalyDetectionConfiguration()
{
    MetricId = metricId,
    Name = configurationName,
    WholeSeriesDetectionConditions = new MetricWholeSeriesDetectionCondition()
};

var detectCondition = detectionConfiguration.WholeSeriesDetectionConditions;

var hardSuppress = new SuppressCondition(1, 100);
detectCondition.HardThresholdCondition = new HardThresholdCondition(AnomalyDetectorDirection.Down, hardSuppress)
{
    LowerBound = 5.0
};

var smartSuppress = new SuppressCondition(4, 50);
detectCondition.SmartDetectionCondition = new SmartDetectionCondition(10.0, AnomalyDetectorDirection.Up, smartSuppress);

detectCondition.ConditionOperator = DetectionConditionOperator.Or;

Response<AnomalyDetectionConfiguration> response = await adminClient.CreateDetectionConfigurationAsync(detectionConfiguration);

AnomalyDetectionConfiguration createdDetectionConfiguration = response.Value;

Console.WriteLine($"Anomaly detection configuration ID: {createdDetectionConfiguration.Id}");

Erstellen eines Hooks zum Empfangen von Anomaliewarnungen

Metrics Advisor unterstützt die EmailNotificationHook Klassen und WebNotificationHook als Mittel zum Abonnieren von Warnungsbenachrichtigungen . In diesem Beispiel wird veranschaulicht, wie Sie das Element EmailNotificationHook erstellen. Beachten Sie, dass Sie den Hook an eine Anomaliewarnungskonfiguration übergeben müssen, um Benachrichtigungen zu erhalten. Weitere Informationen finden Sie weiter unten im Beispiel Erstellen einer Anomaliewarnungskonfiguration .

string hookName = "<hookName>";

var emailHook = new EmailNotificationHook(hookName);

emailHook.EmailsToAlert.Add("email1@sample.com");
emailHook.EmailsToAlert.Add("email2@sample.com");

Response<NotificationHook> response = await adminClient.CreateHookAsync(emailHook);

NotificationHook createdHook = response.Value;

Console.WriteLine($"Hook ID: {createdHook.Id}");

Erstellen einer Anomaliewarnungskonfiguration

Erstellen Sie das Element AnomalyAlertConfiguration, um dem Dienst mitzuteilen, für welche Anomalien Warnungen ausgelöst werden sollen.

string hookId = "<hookId>";
string anomalyDetectionConfigurationId = "<anomalyDetectionConfigurationId>";
string configurationName = "<configurationName>";

AnomalyAlertConfiguration alertConfiguration = new AnomalyAlertConfiguration()
{
    Name = configurationName
};

alertConfiguration.IdsOfHooksToAlert.Add(hookId);

var scope = MetricAnomalyAlertScope.CreateScopeForWholeSeries();
var metricAlertConfiguration = new MetricAlertConfiguration(anomalyDetectionConfigurationId, scope);

alertConfiguration.MetricAlertConfigurations.Add(metricAlertConfiguration);

Response<AnomalyAlertConfiguration> response = await adminClient.CreateAlertConfigurationAsync(alertConfiguration);

AnomalyAlertConfiguration createdAlertConfiguration = response.Value;

Console.WriteLine($"Alert configuration ID: {createdAlertConfiguration.Id}");

Abfrage erkannte Anomalien und ausgelöste Warnungen

Sehen Sie sich die Warnungen an, die durch eine bestimmte Anomaliewarnungskonfiguration erstellt wurden.

string anomalyAlertConfigurationId = "<anomalyAlertConfigurationId>";

var startsOn = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endsOn = DateTimeOffset.UtcNow;
var options = new GetAlertsOptions(startsOn, endsOn, AlertQueryTimeMode.AnomalyDetectedOn)
{
    MaxPageSize = 5
};

int alertCount = 0;

await foreach (AnomalyAlert alert in client.GetAlertsAsync(anomalyAlertConfigurationId, options))
{
    Console.WriteLine($"Alert created at: {alert.CreatedOn}");
    Console.WriteLine($"Alert at timestamp: {alert.Timestamp}");
    Console.WriteLine($"Id: {alert.Id}");
    Console.WriteLine();

    // Print at most 5 alerts.
    if (++alertCount >= 5)
    {
        break;
    }
}

Wenn Sie die ID einer Warnung kennen, können Sie die Anomalien auflisten, die diese Warnung ausgelöst haben.

string alertConfigurationId = "<alertConfigurationId>";
string alertId = "<alertId>";

var options = new GetAnomaliesForAlertOptions() { MaxPageSize = 3 };

int anomalyCount = 0;

await foreach (DataPointAnomaly anomaly in client.GetAnomaliesForAlertAsync(alertConfigurationId, alertId, options))
{
    Console.WriteLine($"Anomaly detection configuration ID: {anomaly.DetectionConfigurationId}");
    Console.WriteLine($"Data feed ID: {anomaly.DataFeedId}");
    Console.WriteLine($"Metric ID: {anomaly.MetricId}");
    Console.WriteLine($"Anomaly value: {anomaly.Value}");

    if (anomaly.ExpectedValue.HasValue)
    {
        Console.WriteLine($"Anomaly expected value: {anomaly.ExpectedValue}");
    }

    Console.WriteLine($"Anomaly at timestamp: {anomaly.Timestamp}");
    Console.WriteLine($"Anomaly detected at: {anomaly.CreatedOn}");
    Console.WriteLine($"Status: {anomaly.Status}");
    Console.WriteLine($"Severity: {anomaly.Severity}");
    Console.WriteLine("Series key:");

    foreach (KeyValuePair<string, string> dimension in anomaly.SeriesKey)
    {
        Console.WriteLine($"  Dimension '{dimension.Key}': {dimension.Value}");
    }

    Console.WriteLine();

    // Print at most 3 anomalies.
    if (++anomalyCount >= 3)
    {
        break;
    }
}

Problembehandlung

Allgemein

Wenn Sie mit der Cognitive Services Metrics Advisor-Clientbibliothek mithilfe des .NET SDK interagieren, führen vom Dienst zurückgegebene Fehler zu einem RequestFailedException mit demselben HTTP-status Code, der von der REST-API-Anforderung zurückgegeben wird.

Wenn Sie beispielsweise versuchen, einen Datenfeed aus dem Dienst mit einer nicht vorhandenen ID abzurufen, wird ein 404 Fehler zurückgegeben, der "Nicht gefunden" angibt.

string dataFeedId = "00000000-0000-0000-0000-000000000000";

try
{
    Response<DataFeed> response = await adminClient.GetDataFeedAsync(dataFeedId);
}
catch (RequestFailedException ex)
{
    Console.WriteLine(ex.ToString());
}

Beachten Sie, dass zusätzliche Informationen protokolliert werden, z. B. die vom Dienst zurückgegebene Fehlermeldung.

Azure.RequestFailedException: Service request failed.
Status: 404 (Not Found)

Content:
{"code":"ERROR_INVALID_PARAMETER","message":"datafeedId is invalid."}

Headers:
X-Request-ID: REDACTED
x-envoy-upstream-service-time: REDACTED
apim-request-id: REDACTED
Strict-Transport-Security: REDACTED
X-Content-Type-Options: REDACTED
Date: Thu, 08 Oct 2020 09:04:31 GMT
Content-Length: 69
Content-Type: application/json; charset=utf-8

Einrichten der Konsolenprotokollierung

Die einfachste Möglichkeit, die Protokolle anzuzeigen, besteht darin, die Konsolenprotokollierung zu aktivieren.

Verwenden Sie die AzureEventSourceListener.CreateConsoleLogger -Methode, um einen Azure SDK-Protokolllistener zu erstellen, der Nachrichten an die Konsole ausgibt.

// Set up a listener to monitor logged events.
using AzureEventSourceListener listener = AzureEventSourceListener.CreateConsoleLogger();

Weitere Informationen zu anderen Protokollierungsmechanismen finden Sie unter Diagnosebeispiele.

Nächste Schritte

Beispiele für die Verwendung der Cognitive Services Metrics Advisor-Bibliothek sind in diesem GitHub-Repository verfügbar. Beispiele werden für jeden Standard Funktionsbereich bereitgestellt:

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Weitere Informationen finden Sie unter cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.