Snabbstart: Anpassa din lösning med hjälp av klientbibliotek eller REST-API:er

Referensdokumentation | Bibliotekskällkod | Paket (NuGet) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en utan kostnad
• Den aktuella versionen av .NET Core.
• När du har din Azure-prenumeration skapar du Metrics Advisor en Metrics Advisor resurs i Azure Portal för att distribuera din Metrics Advisor instans.
• Din egen SQL med tidsseriedata.

Inrätta

Installera klientbiblioteket

När du har skapat ett nytt projekt installerar du klientbiblioteket genom att högerklicka på projektlösningen i Solution Explorer och välja Hantera NuGet-paket. I pakethanteraren som öppnas väljer du Bläddra, markerar Inkludera förhandsversion och söker efter Azure.AI.MetricsAdvisor . Välj version 1.0.0 och sedan Installera.

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du kommandot för att skapa en ny dotnet new konsolapp med namnet metrics-advisor-quickstart . Det här kommandot skapar ett enkelt "Hello World" C#-projekt med en enda källfil: program.cs.

dotnet new console -n metrics-advisor-quickstart

Ändra din katalog till den nyligen skapade appmappen. Du kan skapa programmet med:

dotnet build

Byggutdata får inte innehålla några varningar eller fel.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installera klientbiblioteket

Om du använder en annan IDE än Visual Studio kan du installera Metrics Advisor för .NET med följande kommando:

dotnet add package Azure.AI.MetricsAdvisor --version 1.0.0

Från projektkatalogen öppnar du filen program.cs och lägger till följande using -direktiv:

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.AI.MetricsAdvisor.Administration;
using Azure.AI.MetricsAdvisor;
using Azure.AI.MetricsAdvisor.Models;

I programmets -metod Main() lägger du till anrop för de metoder som används i den här snabbstarten. Du kommer att skapa dessa senare.

static void Main(string[] args){
    // You will create the below methods later in the quickstart
    exampleTask1();
}

Objektmodell

Följande klasser hanterar några av de viktigaste funktionerna i Metrics Advisor C# SDK.

Name	Beskrivning
MetricsAdvisorClient	Används för: – Lista incidenter – Lista rotorsaken till incidenter – Hämta ursprungliga tidsseriedata och tidsseriedata berikade med tjänsten. – Lista aviseringar – Lägga till feedback för att finjustera din modell
MetricsAdvisorAdministrationClient	Gör att du kan: – Hantera datafeeds – Konfigurera konfigurationer för avvikelseidentifiering – Konfigurera konfigurationer för avvikelseaviseringar – Hantera hookar
DataFeed	Vad Metrics Advisor matar in från din datakälla. En DataFeed innehåller rader med: – Tidsstämplar – Noll eller fler dimensioner – Ett eller flera mått
DataFeedMetric	Ett DataFeedMetric är ett kvantifierbart mått som används för att övervaka och utvärdera statusen för en specifik affärsprocess. Det kan vara en kombination av flera tidsserievärden indelade i dimensioner. Ett webbhälsomått kan till exempel innehålla dimensioner för användarantal och en-us-marknaden.

Kodexempel

Dessa kodfragment visar hur du utför följande uppgifter med Metrics Advisor klientbibliotek för .NET:

• Autentisera klienten
• Lägga till en datafeed
• Kontrollera datainmatningsstatusen
• Konfigurera avvikelseidentifiering
• Skapa en hook
• Skapa en aviseringskonfiguration
• Köra frågor mot aviseringen

Autentisera klienten

I programmets Program -klass skapar du variabler för resursens nycklar och slutpunkt.

När du har prenumerationen och API-nycklarna skapar du en MetricsAdvisorKeyCredential. Med slutpunkten och nyckelidentifieringsnyckeln kan du skapa en MetricsAdvisorClient :

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

Du kan också skapa en MetricsAdvisorAdministrationClient för att utföra administrativa åtgärder:

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

Lägga till en datafeed

Metrics Advisor stöder flera typer av datakällor. I det här exemplet visar vi hur du skapar en DataFeed som extraherar data från en SQL server.

Ersätt med din SQL serveranslutningssträng och ersätt med en fråga connection_String query som returnerar dina data vid en enda tidsstämpel. Du måste också justera värdena DataFeedMetric och baserat på dina anpassade DataFeedDimension data.

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

var dataFeedName = "Sample data feed";
var dataFeedSource = new SqlServerDataFeedSource(sqlServerConnectionString, sqlServerQuery);
var dataFeedGranularity = new DataFeedGranularity(DataFeedGranularityType.Daily);

var dataFeedMetrics = new List<DataFeedMetric>()
{
    new DataFeedMetric("cost"),
    new DataFeedMetric("revenue")
};
var dataFeedDimensions = new List<DataFeedDimension>()
{
    new DataFeedDimension("category"),
    new DataFeedDimension("city")
};
var dataFeedSchema = new DataFeedSchema(dataFeedMetrics)
{
    DimensionColumns = dataFeedDimensions
};

var ingestionStartTime = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var dataFeedIngestionSettings = new DataFeedIngestionSettings(ingestionStartTime);

var dataFeed = new DataFeed()
{
    Name = dataFeedName,
    DataSource = dataFeedSource,
    Granularity = dataFeedGranularity,
    Schema = dataFeedSchema,
    IngestionSettings = dataFeedIngestionSettings,
};

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

string dataFeedId = response.Value;

Console.WriteLine($"Data feed ID: {dataFeedId}");

// Note that only the ID of the data feed is known at this point. You can perform another
// service call to GetDataFeedAsync or GetDataFeed to get more information, such as status,
// created time, the list of administrators, or the metric IDs.

Response<DataFeed> response = await adminClient.GetDataFeedAsync(dataFeedId);

DataFeed dataFeed = response.Value;

Console.WriteLine($"Data feed status: {dataFeed.Status.Value}");
Console.WriteLine($"Data feed created time: {dataFeed.CreatedTime.Value}");

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

Console.WriteLine($"Metric IDs:");
foreach (DataFeedMetric metric in dataFeed.Schema.MetricColumns)
{
    Console.WriteLine($" - {metric.MetricName}: {metric.MetricId}");
}

Kontrollera datainmatningsstatusen

Kontrollera datainmatningsstatusen för en tidigare skapad DataFeed

string dataFeedId = "<dataFeedId>";

var startTime = DateTimeOffset.Parse("2020-01-01T00:00:00Z");
var endTime = DateTimeOffset.Parse("2020-09-09T00:00:00Z");
var options = new GetDataFeedIngestionStatusesOptions(startTime, endTime)
{
    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;
    }
}

Konfigurera avvikelseidentifiering

Skapa en konfiguration för avvikelseidentifiering för att meddela tjänsten vilka datapunkter som ska betraktas som avvikelser.

string metricId = "<metricId>";
string configurationName = "Sample anomaly detection configuration";

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

var smartDetectionSuppressCondition = new SuppressCondition(4, 50);
var smartDetectionCondition = new SmartDetectionCondition(10.0, AnomalyDetectorDirection.Up, smartDetectionSuppressCondition);

var detectionCondition = new MetricWholeSeriesDetectionCondition()
{
    HardThresholdCondition = hardThresholdCondition,
    SmartDetectionCondition = smartDetectionCondition,
    CrossConditionsOperator = DetectionConditionsOperator.Or
};

var detectionConfiguration = new AnomalyDetectionConfiguration(metricId, configurationName, detectionCondition);

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

string detectionConfigurationId = response.Value;

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

Skapa en hook

Metrics Advisor stöder EmailNotificationHook klasserna WebNotificationHook och som ett sätt att prenumerera på aviseringar. I det här exemplet visar vi hur du skapar en EmailNotificationHook . Du måste skicka hooken till en avvikelseaviseringskonfiguration för att börja få meddelanden. Mer information finns i exemplet skapa en aviseringskonfiguration för avvikelser.

string hookName = "Sample hook";
var emailsToAlert = new List<string>()
{
    "email1@sample.com",
    "email2@sample.com"
};

var emailHook = new EmailNotificationHook(hookName, emailsToAlert);

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

string hookId = response.Value;

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

Skapa en aviseringskonfiguration

Skapa en AnomalyAlertConfiguration för att meddela tjänsten vilka avvikelser som ska utlösa aviseringar.

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

string configurationName = "Sample anomaly alert configuration";
var idsOfHooksToAlert = new List<string>() { hookId };

var scope = MetricAnomalyAlertScope.GetScopeForWholeSeries();
var metricAlertConfigurations = new List<MetricAnomalyAlertConfiguration>()
{
    new MetricAnomalyAlertConfiguration(anomalyDetectionConfigurationId, scope)
};

AnomalyAlertConfiguration alertConfiguration = new AnomalyAlertConfiguration(configurationName, idsOfHooksToAlert, metricAlertConfigurations);

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

string alertConfigurationId = response.Value;

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

Köra frågor mot aviseringen

Titta igenom aviseringarna som skapats av en viss aviseringskonfiguration för avvikelser.

string anomalyAlertConfigurationId = "<anomalyAlertConfigurationId>";

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

int alertCount = 0;

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

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

När du känner till en aviserings ID visar du en lista över de avvikelser som utlöste aviseringen.

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

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

int anomalyCount = 0;

await foreach (DataPointAnomaly anomaly in client.GetAnomaliesAsync(alertConfigurationId, alertId, options))
{
    Console.WriteLine($"Anomaly detection configuration ID: {anomaly.AnomalyDetectionConfigurationId}");
    Console.WriteLine($"Metric ID: {anomaly.MetricId}");
    Console.WriteLine($"Anomaly at timestamp: {anomaly.Timestamp}");
    Console.WriteLine($"Anomaly detected at: {anomaly.CreatedTime}");
    Console.WriteLine($"Status: {anomaly.Status}");
    Console.WriteLine($"Severity: {anomaly.Severity}");
    Console.WriteLine("Series key:");

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

    Console.WriteLine();

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

Kör programmet

Kör programmet från programkatalogen med dotnet run kommandot .

dotnet run

Referensdokumentation | Bibliotekskällkod | Artefakt (Maven) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Den aktuella versionen av Java Development Kit (JDK)
• Gradle-byggverktyget, eller någon annan beroendehanterare.
• När du har din Azure-prenumeration skapar du en Metrics Advisor-resurs för att skapa en Metrics Advisor-resurs i Azure Portal för att distribuera din Metrics Advisor instans.
• Din egen SQL med tidsseriedata.

Inrätta

Skapa ett nytt Gradle-projekt

I den här snabbstarten används Gradle-beroendehanteraren. Du hittar mer information om klientbibliotek på Maven Central Repository.

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot gradle init från arbetskatalogen. Det här kommandot skapar viktiga byggfiler för Gradle, inklusive build.gradle.kts som används vid körning för att skapa och konfigurera ditt program.

gradle init --type basic

Välj en DSL när du uppmanas till det och välj Kotlin.

Installera klientbiblioteket

Leta upp build.gradle.kts och öppna det med önskad IDE eller textredigerare. Kopiera sedan den här byggkonfigurationen. Se till att inkludera projektberoendena.

dependencies {
    compile("com.azure:azure-ai-metricsadvisor:1.0.0")
}

Skapa en Java-fil

Skapa en mapp för exempelappen. Kör följande kommando från arbetskatalogen:

mkdir -p src/main/java

Navigera till den nya mappen och skapa en fil med namnet MetricsAdvisorQuickstarts.java. Öppna den i önskad redigerare eller IDE och lägg till följande import -instruktioner:

I programmets MetricsAdvisorQuickstarts -klass skapar du variabler för resursens nyckel och slutpunkt.

private static String SUBSCRIPTION_KEY = "<replace-with-your-metrics-advisor-subscription-key-here>";
private static String API_KEY = "<replace-with-your-metrics-advisor-api-key-here>"
private static String ENDPOINT = "<replace-with-your-metrics-advisor-endpoint-here>";

I programmets -metod Main() lägger du till anrop för de metoder som används i den här snabbstarten. Du skapar dessa senare.

static void Main(string[] args){

    // You will create the below methods later in the quickstart
    exampleTask1();
}

Objektmodell

Följande klasser hanterar några av de viktigaste funktionerna i Metrics Advisor Java SDK.

Name	Beskrivning
MetricsAdvisorClient	Används för: – Lista avvikelseincidenter – Lista rotorsaken till incidenter – Hämta ursprungliga tidsseriedata och tidsseriedata som berikats av tjänsten. – Lista aviseringar – Lägga till feedback för att finjustera din modell
MetricsAdvisorAdministrationClient	Gör att du kan: – Hantera datafeeds – Konfigurera konfigurationer för avvikelseidentifiering – Konfigurera konfigurationer för avvikelseaviseringar – Hantera hookar
DataFeed	Vad Metrics Advisor matar in från din datakälla. En DataFeed innehåller rader med: – Tidsstämplar – Noll eller fler dimensioner – Ett eller flera mått
DataFeedMetric	Ett DataFeedMetric är ett kvantifierbart mått som används för att övervaka och utvärdera statusen för en specifik affärsprocess. Det kan vara en kombination av flera tidsserievärden indelade i dimensioner. Ett webbhälsomått kan till exempel innehålla dimensioner för antal användare och en-us-marknaden.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med Metrics Advisor klientbibliotek för Java:

• Autentisera klienten
• Lägga till ett dataflöde
• Kontrollera datainmatningsstatusen
• Konfigurera avvikelseidentifiering
• Skapa en hook
• Skapa en aviseringskonfiguration
• Köra frågor mot aviseringen

Autentisera klienten

Skapa en Metrics Advisor klient med MetricsAdvisorKeyCredential

MetricsAdvisorKeyCredential credential = new MetricsAdvisorKeyCredential(SUBSCRIPTION_KEY, API_KEY);
MetricsAdvisorClient metricsAdvisorClient = new MetricsAdvisorClientBuilder()
    .endpoint(ENDPOINT)
    .credential(credential)
    .buildClient();

Skapa en klient för måttadministration med MetricsAdvisorKeyCredential

MetricsAdvisorKeyCredential credential = new MetricsAdvisorKeyCredential(SUBSCRIPTION_KEY, API_KEY);
MetricsAdvisorAdministrationClient metricsAdvisorAdministrationClient =
    new MetricsAdvisorAdministrationClientBuilder()
        .endpoint(ENDPOINT)
        .credential(credential)
        .buildClient();

Lägga till ett dataflöde

Ersätt med din SQL serveranslutningssträng och ersätt med en fråga som sql_server_connection_string query returnerar dina data med en enda tidsstämpel. Du måste också justera värdena DataFeedMetric och baserat på dina anpassade DataFeedDimension data.

DataFeed dataFeed = new DataFeed()
    .setName("dataFeedName")
    .setSource(new MySqlDataFeedSource("conn-string", "query"))
    .setGranularity(new DataFeedGranularity().setGranularityType(DataFeedGranularityType.DAILY))
    .setSchema(new DataFeedSchema(
        Arrays.asList(
            new DataFeedMetric("cost"),
            new DataFeedMetric("revenue")
        )).setDimensions(
        Arrays.asList(
            new DataFeedDimension("city"),
            new DataFeedDimension("category")
        ))
    )
    .setIngestionSettings(new DataFeedIngestionSettings(OffsetDateTime.parse("2020-01-01T00:00:00Z")))
    .setOptions(new DataFeedOptions()
        .setDescription("data feed description")
        .setRollupSettings(new DataFeedRollupSettings()
            .setRollupType(DataFeedRollupType.AUTO_ROLLUP)));
final DataFeed createdSqlDataFeed = metricsAdvisorAdminClient.createDataFeed(dataFeed);

System.out.printf("Data feed Id : %s%n", createdSqlDataFeed.getId());
System.out.printf("Data feed name : %s%n", createdSqlDataFeed.getName());
System.out.printf("Is the query user is one of data feed administrator : %s%n", createdSqlDataFeed.isAdmin());
System.out.printf("Data feed created time : %s%n", createdSqlDataFeed.getCreatedTime());
System.out.printf("Data feed granularity type : %s%n",
    createdSqlDataFeed.getGranularity().getGranularityType());
System.out.printf("Data feed granularity value : %d%n",
    createdSqlDataFeed.getGranularity().getCustomGranularityValue());
System.out.println("Data feed related metric Ids:");
createdSqlDataFeed.getMetricIds().forEach(System.out::println);
System.out.printf("Data feed source type: %s%n", createdSqlDataFeed.getSourceType());

if (SQL_SERVER_DB == createdSqlDataFeed.getSourceType()) {
    System.out.printf("Data feed sql server query: %s%n",
        ((SqlServerDataFeedSource) createdSqlDataFeed.getSource()).getQuery());
}

Kontrollera datainmatningsstatusen

I det här exemplet kontrolleras datainmatningsstatusen för en tidigare tillhandahållen dataflödeskälla.

String dataFeedId = "<use-the-data-feed-id-from-createdSqlDataFeed.getId()"; 

metricsAdvisorAdminClient.listDataFeedIngestionStatus(
    dataFeedId,
    new ListDataFeedIngestionOptions(
        OffsetDateTime.parse("2020-01-01T00:00:00Z"),
        OffsetDateTime.parse("2020-09-09T00:00:00Z"))
).forEach(dataFeedIngestionStatus -> {
    System.out.printf("Message : %s%n", dataFeedIngestionStatus.getMessage());
    System.out.printf("Timestamp value : %s%n", dataFeedIngestionStatus.getTimestamp());
    System.out.printf("Status : %s%n", dataFeedIngestionStatus.getStatus());
});

Konfigurera avvikelseidentifiering

Det här exemplet visar hur en användare kan konfigurera en konfiguration för avvikelseidentifiering för sina data.

String metricId = "<metric-id-from-adding-data-feed>";

ChangeThresholdCondition changeThresholdCondition = new ChangeThresholdCondition(
        20, 
        10, 
        true, 
        AnomalyDetectorDirection.BOTH, 
        new SuppressCondition(1, 2));

HardThresholdCondition hardThresholdCondition = new HardThresholdCondition(
        AnomalyDetectorDirection.DOWN, 
        new SuppressCondition(1, 1))
    .setLowerBound(5.0);

SmartDetectionCondition smartDetectionCondition = new SmartDetectionCondition(
        10.0, 
        AnomalyDetectorDirection.UP,
        new SuppressCondition(1, 2));

final AnomalyDetectionConfiguration anomalyDetectionConfiguration =
    metricsAdvisorAdminClient.createMetricAnomalyDetectionConfig(
        metricId,
        new AnomalyDetectionConfiguration("My dataPoint anomaly detection configuration")
            .setDescription("anomaly detection config description")
            .setWholeSeriesDetectionCondition(
                new MetricWholeSeriesDetectionCondition()
                    .setChangeThresholdCondition(changeThresholdCondition)
                    .setHardThresholdCondition(hardThresholdCondition)
                    .setSmartDetectionCondition(smartDetectionCondition)
                    .setConditionOperator(DetectionConditionOperator.OR))
    );

Skapa en hook

I det här exemplet skapas en e-post hook som tar emot aviseringar om avvikelseincidenter.

NotificationHook emailNotificationHook = new EmailNotificationHook("email Hook")
    .setDescription("my email Hook")
    .addEmailToAlert("alertme@alertme.com")
    .setExternalLink("https://example.com/handleAlerts"); // you must enter a valid webhook url to post the alert payload

final NotificationHook notificationHook = metricsAdvisorAdminClient.createHook(emailNotificationHook);
EmailNotificationHook createdEmailHook = (EmailNotificationHook) notificationHook;
System.out.printf("Email Hook Id: %s%n", createdEmailHook.getId());
System.out.printf("Email Hook name: %s%n", createdEmailHook.getName());
System.out.printf("Email Hook description: %s%n", createdEmailHook.getDescription());
System.out.printf("Email Hook external Link: %s%n", createdEmailHook.getExternalLink());
System.out.printf("Email Hook emails to alert: %s%n",
    String.join(",", createdEmailHook.getEmailsToAlert()));

Skapa en aviseringskonfiguration

Det här exemplet visar hur en användare kan konfigurera en aviseringskonfiguration för identifierade avvikelser i sina data.

String detectionConfigurationId1 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
String detectionConfigurationId2 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
String hookId1 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
String hookId2 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";

final AnomalyAlertConfiguration anomalyAlertConfiguration
    = metricsAdvisorAdminClient.createAnomalyAlertConfig(
        new AnomalyAlertConfiguration("My anomaly alert config name")
            .setDescription("alert config description")
            .setMetricAlertConfigurations(
                Arrays.asList(
                    new MetricAnomalyAlertConfiguration(detectionConfigurationId1,
                        MetricAnomalyAlertScope.forWholeSeries()),
                    new MetricAnomalyAlertConfiguration(detectionConfigurationId2,
                        MetricAnomalyAlertScope.forWholeSeries())
                        .setAlertConditions(new MetricAnomalyAlertConditions()
                            .setSeverityRangeCondition(new SeverityCondition(AnomalySeverity.HIGH,
                                AnomalySeverity.HIGH)))
                ))
            .setCrossMetricsOperator(MetricAnomalyAlertConfigurationsOperator.AND)
            .setIdOfHooksToAlert(Arrays.asList(hookId1, hookId2)));

Köra frågor mot aviseringen

Det här exemplet visar hur en användare kan köra frågor mot aviseringar som utlöses för en aviseringsidentifieringskonfiguration och få avvikelser för aviseringen.

String alertConfigurationId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
final OffsetDateTime startTime = OffsetDateTime.parse("2020-01-01T00:00:00Z");
final OffsetDateTime endTime = OffsetDateTime.parse("2020-09-09T00:00:00Z");
metricsAdvisorClient.listAlerts(
    alertConfigurationId,
        startTime, endTime)
    .forEach(alert -> {
        System.out.printf("AnomalyAlert Id: %s%n", alert.getId());
        System.out.printf("AnomalyAlert created on: %s%n", alert.getCreatedTime());

        // List anomalies for returned alerts
        metricsAdvisorClient.listAnomaliesForAlert(
            alertConfigurationId,
            alert.getId())
            .forEach(anomaly -> {
                System.out.printf("DataPoint Anomaly was created on: %s%n", anomaly.getCreatedTime());
                System.out.printf("DataPoint Anomaly severity: %s%n", anomaly.getSeverity().toString());
                System.out.printf("DataPoint Anomaly status: %s%n", anomaly.getStatus());
                System.out.printf("DataPoint Anomaly related series key: %s%n", anomaly.getSeriesKey().asMap());
            });
    });

Du kan skapa appen med:

gradle build

Kör programmet

Kör programmet med run målet:

gradle run

Referensdokumentation | Bibliotekskällkod | Paket (npm) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Den aktuella versionen av Node.js
• När du har din Azure-prenumeration skapar du en Metrics Advisor-resurs för att skapa en Metrics Advisor-resurs i Azure Portal för att distribuera din Metrics Advisor instans.
• Din egen SQL med tidsseriedata.

Inrätta

Skapa ett nytt Node.js-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

Kör kommandot npm init för att skapa ett nodprogram med en package.json fil.

npm init

Installera klientbiblioteket

Installera @azure/ai-metrics-advisor NPM-paketet:

npm install @azure/ai-metrics-advisor

Appens package.json fil uppdateras med beroendena.

Skapa en fil med index.js namnet och importera följande bibliotek:

Skapa variabler för resursens Azure-slutpunkt och nyckel.

subscriptionKey = "<paste-your-metrics-advisor-key-here>";
apiKey ="<paste-your-metrics-advisor-api-key-here>";
endpoint = "<paste-your-metrics-advisor-endpoint-here>";

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Metrics Advisor JavaScript SDK.

Name	Beskrivning
MetricsAdvisorClient	Används för: – Lista incidenter – Lista rotorsaken till incidenter – Hämta ursprungliga tidsseriedata och tidsseriedata som berikats av tjänsten. – Lista aviseringar – Lägga till feedback för att finjustera din modell
MetricsAdvisorAdministrationClient	Gör att du kan: – Hantera datafeeds – Skapa, konfigurera, hämta, lista och ta bort konfigurationer för avvikelseaviseringar – Hantera hookar
DataFeed	Vad Metrics Advisor matar in från din datakälla. En DataFeed innehåller rader med: – Tidsstämplar – Noll eller fler dimensioner – Ett eller flera mått
DataFeedMetric	Ett DataFeedMetric är ett kvantifierbart mått som används för att övervaka och utvärdera statusen för en specifik affärsprocess. Det kan vara en kombination av flera tidsserievärden indelade i dimensioner. Ett webbhälsomått kan till exempel innehålla dimensioner för antal användare och en-us-marknaden.

Kodexempel

De här kodfragmenten visar hur du gör följande med Metrics Advisor klientbibliotek för JavaScript:

• Autentisera klienten
• Lägga till ett dataflöde
• Kontrollera datainmatningsstatus
• Konfigurera avvikelseidentifiering
• Skapa en hook
• Skapa en aviseringskonfiguration
• Köra frågor mot aviseringen

Autentisera klienten

När du har de två nycklarna och slutpunktsadressen kan du använda klassen MetricsAdvisorKeyCredential för att autentisera klienterna på följande sätt:

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorClient,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);
const client = new MetricsAdvisorClient(endpoint, credential);
const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);

Lägga till ett dataflöde

Metrics Advisor stöder anslutning av olika typer av datakällor. Här är ett exempel för att mata in data från SQL Server.

Ersätt med din SQL serveranslutningssträng och ersätt med en fråga som sql_server_connection_string query returnerar dina data vid en enda tidsstämpel. Du måste också justera värdena metric och baserat på dina anpassade dimension data.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  const subscriptionKey = "<paste-your-metrics-advisor-key-here>";
  const apiKey ="<paste-your-metrics-advisor-api-key-here>";
  const endpoint = "<paste-your-metrics-advisor-endpoint-here>";
  const sqlServerConnectionString ="<sql_server_connection_string>";
  const sqlServerQuery ="<query>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);

  const created = await createDataFeed(adminClient, sqlServerConnectionString, sqlServerQuery);
  console.log(`Data feed created: ${created.id}`);
}

async function createDataFeed(adminClient, sqlServerConnectionString, sqlServerQuery) {
  console.log("Creating Datafeed...");
  const dataFeed = {
    name: "test_datafeed_" + new Date().getTime().toString(),
    source: {
      dataSourceType: "SqlServer",
      dataSourceParameter: {
        connectionString: sqlServerConnectionString,
        query: sqlServerQuery
      }
    },
    granularity: {
      granularityType: "Daily"
    },
    schema: {
      metrics: [
        {
          name: "revenue",
          displayName: "revenue",
          description: "Metric1 description"
        },
        {
          name: "cost",
          displayName: "cost",
          description: "Metric2 description"
        }
      ],
      dimensions: [
        { name: "city", displayName: "city display" },
        { name: "category", displayName: "category display" }
      ],
      timestampColumn: null
    },
    ingestionSettings: {
      ingestionStartTime: new Date(Date.UTC(2020, 5, 1)),
      ingestionStartOffsetInSeconds: 0,
      dataSourceRequestConcurrency: -1,
      ingestionRetryDelayInSeconds: -1,
      stopRetryAfterInSeconds: -1
    },
    rollupSettings: {
      rollupType: "AutoRollup",
      rollupMethod: "Sum",
      rollupIdentificationValue: "__CUSTOM_SUM__"
    },
    missingDataPointFillSettings: {
      fillType: "SmartFilling"
    },
    accessMode: "Private",
    admins: ["xyz@example.com"]
  };
  const result = await adminClient.createDataFeed(dataFeed);

  return result;
}

Kontrollera datainmatningsstatus

När vi har börjat datainmatningen kan vi kontrollera inmatningsstatusen.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = "<service endpoint>";
  const subscriptionKey = "<subscription key>";
  const apiKey = "<api key>";
  const dataFeedId = "<data feed id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);
  await checkIngestionStatus(
    adminClient,
    dataFeedId,
    new Date(Date.UTC(2020, 8, 1)),
    new Date(Date.UTC(2020, 8, 12))
  );
}

async function checkIngestionStatus(adminClient, datafeedId, startTime, endTime) {
  // This shows how to use for-await-of syntax to list status
  console.log("Checking ingestion status...");
  const iterator = adminClient.listDataFeedIngestionStatus(datafeedId, startTime, endTime);
  for await (const status of iterator) {
    console.log(`  [${status.timestamp}] ${status.status} - ${status.message}`);
  }
}

Konfigurera avvikelseidentifiering

Vi behöver en konfiguration för avvikelseidentifiering för att avgöra om en punkt i tidsserien är en avvikelse. En standardkonfiguration för identifiering tillämpas automatiskt på varje mått, men du kan finjustera identifieringslägen som används för dina data genom att skapa en anpassad konfiguration för avvikelseidentifiering.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  const endpoint = "<service endpoint>";
  const subscriptionKey = "<subscription key>";
  const apiKey = "<api key>";
  const metricId =  "<metric id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);

  const detectionConfig = await configureAnomalyDetectionConfiguration(adminClient, metricId);
  console.log(`Detection configuration created: ${detectionConfig.id}`);
}

async function configureAnomalyDetectionConfiguration(adminClient, metricId) {
  console.log(`Creating an anomaly detection configuration on metric '${metricId}'...`);
  const detectionConfig = {
    name: "test_detection_configuration" + new Date().getTime().toString(),
    metricId,
    wholeSeriesDetectionCondition: {
      smartDetectionCondition: {
        sensitivity: 100,
        anomalyDetectorDirection: "Both",
        suppressCondition: {
          minNumber: 1,
          minRatio: 1
        }
      }
    },
    description: "Detection configuration description"
  };
  return await adminClient.createDetectionConfig(detectionConfig);
}

Skapa en hook

Vi använder hookar för att prenumerera på aviseringar i realtid. I det här exemplet skapar vi en webhook för Metrics Advisor som aviseringen ska publiceras till.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = "<service endpoint>";
  const subscriptionKey = "<subscription key>";
  const apiKey = "<api key>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);
  const hook = await createWebhookHook(adminClient);
  console.log(`Webhook hook created: ${hook.id}`);
}

async function createWebhookHook(adminClient) {
  console.log("Creating a webhook hook");
  const hook = {
    hookType: "Webhook",
    name: "web hook " + new Date().getTime().toFixed(),
    description: "description",
    hookParameter: {
      endpoint: "https://example.com/handleAlerts", // you must enter a valid webhook url to post the alert payload
      username: "username",
      password: "password"
      // certificateKey: "certificate key",
      // certificatePassword: "certificate password"
    }
  };

  return await adminClient.createHook(hook);
}

Skapa en aviseringskonfiguration

Det här exemplet visar hur du konfigurerar villkor som en avisering måste utlösas och vilka hookar som ska användas som mål för en avisering.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = "<service endpoint>";
  const subscriptionKey = "<subscription key>";
  const apiKey = "<api key>";
  const detectionConfigId = "<detection id>";
  const hookId = "<hook id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);
  const alertConfig = await configureAlertConfiguration(adminClient, detectionConfigId, [hookId]);
  console.log(`Alert configuration created: ${alertConfig.id}`);
}

async function configureAlertConfiguration(adminClient, detectionConfigId, hookIds) {
  console.log("Creating a new alerting configuration...");
  const anomalyAlertConfig = {
    name: "test_alert_config_" + new Date().getTime().toString(),
    crossMetricsOperator: "AND",
    metricAlertConfigurations: [
      {
        detectionConfigurationId: detectionConfigId,
        alertScope: {
          scopeType: "All"
        },
        alertConditions: {
          severityCondition: { minAlertSeverity: "Medium", maxAlertSeverity: "High" }
        },
        snoozeCondition: {
          autoSnooze: 0,
          snoozeScope: "Metric",
          onlyForSuccessive: true
        }
      }
    ],
    hookIds,
    description: "Alerting config description"
  };
  return await adminClient.createAlertConfig(anomalyAlertConfig);
}

Köra frågor mot aviseringen

const { MetricsAdvisorKeyCredential, MetricsAdvisorClient } = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = "<service endpoint>";
  const subscriptionKey = "<subscription key>";
  const apiKey = "<api key>";
  const alertConfigId = "<alert config id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const client = new MetricsAdvisorClient(endpoint, credential);

  const alertIds = await queryAlerts(
    client,
    alertConfigId,
    new Date(Date.UTC(2020, 8, 1)),
    new Date(Date.UTC(2020, 8, 12))
  );

  if (alertIds.length > 1) {
    // query anomalies using an alert id.
    await queryAnomaliesByAlert(client, alertConfigId, alertIds[0]);
  } else {
    console.log("No alerts during the time period");
  }
}

async function queryAlerts(client, alertConfigId, startTime, endTime) {
  let alerts = [];
  const iterator = client.listAlerts(alertConfigId, startTime, endTime, "AnomalyTime");
  for await (const alert of iterator) {
    alerts.push(alert);
  }

  return alerts;
}

async function queryAnomaliesByAlert(client, alert) {
  console.log(
    `Listing anomalies for alert configuration '${alert.alertConfigId}' and alert '${alert.id}'`
  );
  const iterator = client.listAnomaliesForAlert(alert);
  for await (const anomaly of iterator) {
    console.log(
      `  Anomaly ${anomaly.severity} ${anomaly.status} ${anomaly.seriesKey} ${anomaly.timestamp}`
    );
  }
}

Kör programmet

Kör programmet med kommandot node i snabbstartsfilen.

node index.js

Referensdokumentation | Bibliotekskällkod | Paket (PiPy) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Python 3.x
• När du har din Azure-prenumeration skapar du Metrics Advisor en Metrics Advisor-resurs i Azure Portal för att distribuera din Metrics Advisor instans.
• Din egen SQL med tidsseriedata.

Inrätta

Installera klientbiblioteket

När du har installerat Python kan du installera klientbiblioteket med:

pip install azure-ai-metricsadvisor --pre

Skapa ett nytt Python-program

Skapa en ny Python-fil och importera följande bibliotek.

import os
import datetime

Skapa variabler för resursens Azure-slutpunkt och nyckel.

subscription_key = "<paste-your-metrics-advisor-subscription-key-here>"
api_key = "<paste-your-metrics-advisor-api-key-here>"
service_endpoint = "<paste-your-metrics-advisor-endpoint-here>"

Objektmodell

Följande klasser hanterar några av de viktigaste funktionerna i Metrics Advisor Python SDK.

Name	Beskrivning
MetricsAdvisorClient	Används för: – Lista incidenter – Lista rotorsaken till incidenter – Hämta ursprungliga tidsseriedata och tidsseriedata som berikats av tjänsten. – Lista aviseringar – Lägga till feedback för att finjustera din modell
MetricsAdvisorAdministrationClient	Gör att du kan: – Hantera datafeeds – Skapa, konfigurera, hämta, lista och ta bort konfigurationer för avvikelseidentifiering – Skapa, konfigurera, hämta, lista och ta bort konfigurationer för avvikelseaviseringar – Hantera hookar
DataFeed	Vad Metrics Advisor matar in från din datakälla. En DataFeed innehåller rader med: – Tidsstämplar – Noll eller fler dimensioner – Ett eller flera mått
DataFeedMetric	Ett DataFeedMetric är ett kvantifierbart mått som används för att övervaka och utvärdera statusen för en specifik affärsprocess. Det kan vara en kombination av flera tidsserievärden indelade i dimensioner. Ett webbhälsomått kan till exempel innehålla dimensioner för antal användare och en-us-marknaden.

Kodexempel

De här kodfragmenten visar hur du gör följande med Metrics Advisor klientbibliotek för Python:

• Autentisera klienten
• Lägga till ett dataflöde
• Kontrollera datainmatningsstatus
• Konfigurera konfiguration av identifiering och aviseringskonfiguration
• Skapa en aviseringskonfiguration
• Frågeresultat för avvikelseidentifiering

Autentisera klienten

Klienten i det här exemplet är ett MetricsAdvisorAdministrationClient objekt som använder slutpunkten och ett objekt MetricsAdvisorKeyCredential som innehåller dina nycklar. Du behöver inte kopiera det här kodexe exemplet. De metoder som du skapar senare instansierar klienten. Den alternativa klienten kallas MetricsAdvisorClient mer information om den här klienten finns i referensdokumentationen.

client = MetricsAdvisorAdministrationClient(service_endpoint,
                                MetricsAdvisorKeyCredential(subscription_key, api_key))

Lägga till ett dataflöde

I en ny metod skapar du importutsatser som i exemplet nedan. Ersätt med din SQL serveranslutningssträng och ersätt med en fråga som sql_server_connection_string query returnerar dina data vid en enda tidsstämpel. Du måste också justera värdena DataFeedmetric och baserat på dina anpassade DataFeedDimension data.

Skapa en klient med dina nycklar och slutpunkter och client.create_data_feed() använd för att konfigurera namn, källa, kornighet och schema. Du kan också ange inmatningstid, sammanslagningsinställningar med mera.

def sample_create_data_feed():
    from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
    from azure.ai.metricsadvisor.models import (
        SqlServerDataFeedSource,
        DataFeedSchema,
        DataFeedMetric,
        DataFeedDimension,
        DataFeedRollupSettings,
        DataFeedMissingDataPointFillSettings
    )
    sql_server_connection_string = "<replace-with-your-sql-server-connection-string>"
    query = "<replace-with-metrics-advisor-sql-server-query>"

    client = MetricsAdvisorAdministrationClient(service_endpoint,
                                  MetricsAdvisorKeyCredential(subscription_key, api_key))

    data_feed = client.create_data_feed(
    name="My data feed",
    source=SqlServerDataFeedSource(
        connection_string=sql_server_connection_string,
        query=query,
    ),
    granularity="Daily",
    schema=DataFeedSchema(
        metrics=[
            DataFeedMetric(name="cost", display_name="Cost"),
            DataFeedMetric(name="revenue", display_name="Revenue")
        ],
        dimensions=[
            DataFeedDimension(name="category", display_name="Category"),
            DataFeedDimension(name="city", display_name="City")
        ],
        timestamp_column="Timestamp"
    ),
    ingestion_settings=datetime.datetime(2019, 10, 1),
    data_feed_description="cost/revenue data feed",
    rollup_settings=DataFeedRollupSettings(
        rollup_type="AutoRollup",
        rollup_method="Sum",
        rollup_identification_value="__CUSTOM_SUM__"
    ),
    missing_data_point_fill_settings=DataFeedMissingDataPointFillSettings(
        fill_type="SmartFilling"
    ),
    access_mode="Private"
    )
)

return data_feed
sample_create_data_feed()

Kontrollera datainmatningsstatusen

I en ny metod skapar du en import-instruktion som i exemplet nedan. Ersätt data_feed_id med ID:t för den datafeed som du skapade. Skapa en klient med dina nycklar och slutpunkter och använd client.list_data_feed_ingestion_status() för att hämta inmatningsförloppet. Skriv ut informationen, till exempel de senaste aktiva och lyckade tidsstämplar.

    from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient

    data_feed_id = "<replace-with-your-metrics-advisor-data-feed-id>"

   client = MetricsAdvisorAdministrationClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

ingestion_status = client.list_data_feed_ingestion_status(
    data_feed_id,
    datetime.datetime(2020, 9, 20),
    datetime.datetime(2020, 9, 25)
)
for status in ingestion_status:
    print("Timestamp: {}".format(status.timestamp))
    print("Status: {}".format(status.status))
    print("Message: {}\n".format(status.message))

Konfigurera avvikelseidentifiering

I en ny metod skapar du importutsatser som i exemplet nedan. Ersätt metric_id med ID:t för det mått som du vill konfigurera. Skapa en klient med dina nycklar och slutpunkter och använd för client.create_detection_configuration att skapa en ny identifieringskonfiguration. Tröskelvärdena anger parametrarna för avvikelseidentifiering.

    from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
    from azure.ai.metricsadvisor.models import (
        ChangeThresholdCondition,
        HardThresholdCondition,
        SmartDetectionCondition,
        SuppressCondition,
        MetricDetectionCondition,
    )
    metric_id = "replace-with-your-metric-id"

    
client = MetricsAdvisorAdministrationClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

change_threshold_condition = ChangeThresholdCondition(
    anomaly_detector_direction="Both",
    change_percentage=20,
    shift_point=10,
    within_range=True,
    suppress_condition=SuppressCondition(
        min_number=5,
        min_ratio=2
    )
)
hard_threshold_condition = HardThresholdCondition(
    anomaly_detector_direction="Up",
    upper_bound=100,
    suppress_condition=SuppressCondition(
        min_number=2,
        min_ratio=2
    )
)
smart_detection_condition = SmartDetectionCondition(
    anomaly_detector_direction="Up",
    sensitivity=10,
    suppress_condition=SuppressCondition(
        min_number=2,
        min_ratio=2
    )
)

detection_config = client.create_detection_configuration(
    name="my_detection_config",
    metric_id=metric_id,
    description="anomaly detection config for metric",
    whole_series_detection_condition=MetricDetectionCondition(
        condition_operator="OR",
        change_threshold_condition=change_threshold_condition,
        hard_threshold_condition=hard_threshold_condition,
        smart_detection_condition=smart_detection_condition
    )
)
return detection_config

Skapa en hook

I en ny metod skapar du importutsatser som i exemplet nedan. Skapa en klient med dina nycklar och slutpunkter och använd för client.create_hook() att skapa en hook. Ange en beskrivning, en lista över e-postmeddelanden att skicka aviseringen till och en extern länk som visas i aviseringen.

def sample_create_hook():

    from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
    from azure.ai.metricsadvisor.models import EmailNotificationHook

    client = MetricsAdvisorAdministrationClient(service_endpoint,
                                  MetricsAdvisorKeyCredential(subscription_key, api_key))

client = MetricsAdvisorAdministrationClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key))

hook = client.create_hook(
    hook=EmailNotificationHook(
        name="email hook",
        description="my email hook",
        emails_to_alert=["alertme@alertme.com"],
        external_link="https://example.com/handleAlerts"   #A customized field configured by users, which will be displayed in the anomaly alert. It's usually been used to link to a troubleshooting guide to help further diagnose the issue.
    )
)

Skapa en aviseringskonfiguration

I en ny metod skapar du importutsatser som i exemplet nedan. Ersätt detection_configuration_id med ID:t för konfigurationen av avvikelseidentifiering och ersätt hook_id med den hook som du skapade tidigare. Skapa en klient med dina nycklar och slutpunkter och använd för client.create_alert_configuration() att skapa en aviseringskonfiguration.

def sample_create_alert_config():
    from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
    from azure.ai.metricsadvisor.models import (
        MetricAlertConfiguration,
        MetricAnomalyAlertScope,
        TopNGroupScope,
        MetricAnomalyAlertConditions,
        SeverityCondition,
        MetricBoundaryCondition,
        MetricAnomalyAlertSnoozeCondition
    )
    anomaly_detection_configuration_id = "<replace-with-your-detection-configuration-id"
    hook_id = "<replace-with-your-hook-id>"

    client = MetricsAdvisorAdministrationClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

alert_config = client.create_alert_configuration(
        name="my alert config",
        description="alert config description",
        cross_metrics_operator="AND",
        metric_alert_configurations=[
            MetricAlertConfiguration(
                detection_configuration_id=detection_configuration_id,
                alert_scope=MetricAnomalyAlertScope(
                    scope_type="WholeSeries"
                ),
                alert_conditions=MetricAnomalyAlertConditions(
                    severity_condition=SeverityCondition(
                        min_alert_severity="Low",
                        max_alert_severity="High"
                    )
                )
            ),
            MetricAlertConfiguration(
                detection_configuration_id=detection_configuration_id,
                alert_scope=MetricAnomalyAlertScope(
                    scope_type="TopN",
                    top_n_group_in_scope=TopNGroupScope(
                        top=10,
                        period=5,
                        min_top_count=5
                    )
                ),
                alert_conditions=MetricAnomalyAlertConditions(
                    metric_boundary_condition=MetricBoundaryCondition(
                        direction="Up",
                        upper=50
                    )
                ),
                alert_snooze_condition=MetricAnomalyAlertSnoozeCondition(
                    auto_snooze=2,
                    snooze_scope="Metric",
                    only_for_successive=True
                )
            ),
        ],
        hook_ids=[hook_id]
    )

    return alert_config

Köra frågor mot aviseringen

I en ny metod skapar du en import-instruktion som i exemplet nedan. Ersätt alert_id med ID:t för aviseringen och ersätt med alert_config_id aviseringskonfigurations-ID:t. Skapa en klient med dina nycklar och slutpunkter och använd client.list_anomalies för att lista avvikelserna för en avisering.

from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient
    
alert_id = "<replace-with-your-alert-id>"
alert_config_id = "<replace-with-your-alert-configuration-id"

client = MetricsAdvisorClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

results = client.list_alerts(
    alert_configuration_id=alert_config_id,
    start_time=datetime.datetime(2020, 1, 1),
    end_time=datetime.datetime(2020, 9, 9),
    time_mode="AnomalyTime",
)
for result in results:
    print("Alert id: {}".format(result.id))
    print("Create on: {}".format(result.created_on))

results = client.list_anomalies(
    alert_configuration_id=alert_config_id,
    alert_id=alert_id,
)
for result in results:
    print("Create on: {}".format(result.created_on))
    print("Severity: {}".format(result.severity))
    print("Status: {}".format(result.status))

Kör programmet

Kör programmet med kommandot python i snabbstartsfilen.

python quickstart-file.py

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• När du har din Azure-prenumeration skapar du Metrics Advisor en Metrics Advisor-resurs i Azure Portal för att distribuera din Metrics Advisor instans.
• Den aktuella versionen av cURL. Flera kommandoradsväxlar används i den här artikeln, vilket anges i cURL-dokumentationen.
  • I följande BASH-exempel används rad \ fortsättningstecknet. Om konsolen eller terminalen använder ett annat rad fortsättningstecken använder du det här tecknet.

Du behöver två nycklar för att börja använda REST API:

• Nyckeln till din Metrics Advisor resurs. Du hittar detta i avsnittet Nycklar och slutpunkt för resursen i Azure Portal.
  • Senare ska du ersätta Ocp-Apim-Subscription-Key i exemplen med den här nyckeln.
• API-nyckeln för din Metrics Advisor instans. Du hittar detta i webbportalen för Metrics Advisor API-nycklar på den vänstra navigeringsmenyn.
  • Senare ska du ersätta x-api-key i exemplen med den här nyckeln.

Lägga till en datafeed från ett exempel eller en datakälla

Om du vill börja övervaka dina tidsseriedata måste du lägga till ett dataflöde. Om du vill lägga till ett dataflöde måste du ange ett dataschema enligt datakällstypen och parametrarna. Spara nedanstående JSON-begärandetext i en filbody.jspå och kör cURL-kommandot.

{
        "dataSourceType": "SqlServer",
        "dataFeedName": "test_data_feed_00000001",
        "dataFeedDescription": "",
        "dataSourceParameter": {
            "connectionString": "Server=ad-sample.database.windows.net,1433;Initial Catalog=ad-sample;Persist Security Info=False;User ID=adreadonly;Password=Readonly@2020;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;",
            "query": "select * from adsample3 where Timestamp = @StartTime"
        },
        "granularityName": "Daily",
        "granularityAmount": 0,
        "metrics": [
            {
                "metricName": "revenue",
                "metricDisplayName": "revenue",
                "metricDescription": ""
            },
            {
                "metricName": "cost",
                "metricDisplayName": "cost",
                "metricDescription": ""
            }
        ],
        "dimension": [
            {
                "dimensionName": "city",
                "dimensionDisplayName": "city"
            },
            {
                "dimensionName": "category",
                "dimensionDisplayName": "category"
            }
        ],
        "timestampColumn": "timestamp",
        "dataStartFrom": "2020-06-01T00:00:00.000Z",
        "startOffsetInSeconds": 0,
        "maxConcurrency": -1,
        "minRetryIntervalInSeconds": -1,
        "stopRetryAfterInSeconds": -1,
        "needRollup": "NoRollup",
        "fillMissingPointType": "SmartFilling",
        "fillMissingPointValue": 0,
        "viewMode": "Private",
        "admins": [
            "xxx@microsoft.com"
        ],
        "viewers": [
        ],
        "actionLinkTemplate": ""
}

Kommandot cURL körs från ett BASH-gränssnitt. Redigera det här kommandot med ditt eget resursnamn, resursnyckel och JSON-värden.

curl -i https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/datafeeds \
-X POST \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY" \
-H "Content-Type:application/json" \
-d @body.json

Exempelsvar

HTTP/1.1 201 Created
Content-Length: 0
Location: https://gualala-beta-0617.cognitiveservices.azure.com/metricsadvisor/v1.0/datafeeds/b5921405-8001-42b2-8746-004ddeeb780d
x-envoy-upstream-service-time: 564
apim-request-id: 4e4fe70b-d663-4fb7-a804-b9dc14ba02a3
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
x-content-type-options: nosniff
Date: Thu, 03 Sep 2020 18:29:27 GMT

I svaret ovan är Location-huvudet URL:en för dataflödet som du skapade och den innehåller dataFeedID.

Med hjälp av ovanstående URL kan du köra frågor mot detaljerad information om dataflödet som du skapade i föregående steg. (Vi använder metricID i dataflödesinformationen i följande steg)

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/datafeeds/REPLACE-WITH-YOUR-DATA-FEED-ID \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY"

Exempelsvar

{
   "dataFeedId":"90919c03-be13-4efa-86e5-aa9dc72764ce",
   "dataFeedName":"test_data_feed_00000007",
   "metrics":[
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "metricName":"cost",
         "metricDisplayName":"cost",
         "metricDescription":""
      },
      {
         "metricId":"82bbc63d-3739-4d57-b190-accb69721b6a",
         "metricName":"revenue",
         "metricDisplayName":"revenue",
         "metricDescription":""
      }
   ],
   "dimension":[
      {
         "dimensionName":"category",
         "dimensionDisplayName":"category"
      },
      {
         "dimensionName":"city",
         "dimensionDisplayName":"city"
      }
   ],
   "dataStartFrom":"2020-06-01T00:00:00Z",
   "dataSourceType":"SqlServer",
   "timestampColumn":"timestamp",
   "startOffsetInSeconds":0,
   "maxQueryPerMinute":30.0,
   "granularityName":"Daily",
   "granularityAmount":null,
   "allUpIdentification":null,
   "needRollup":"NoRollup",
   "fillMissingPointType":"SmartFilling",
   "fillMissingPointValue":0.0,
   "rollUpMethod":"None",
   "rollUpColumns":[
      
   ],
   "dataFeedDescription":"",
   "stopRetryAfterInSeconds":-1,
   "minRetryIntervalInSeconds":-1,
   "maxConcurrency":-1,
   "viewMode":"Private",
   "admins":[
      "xyz@microsoft.com"
   ],
   "viewers":[
      
   ],
   "creator":"xyz@microsoft.com",
   "status":"Active",
   "createdTime":"2020-09-08T08:39:28Z",
   "isAdmin":true,
   "actionLinkTemplate":"",
   "dataSourceParameter":{
      "connectionString":"Server=ad-sample.database.windows.net,1433;Initial Catalog=ad-sample;Persist Security Info=False;User ID=adreadonly;Password=Readonly@2020;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;",
      "query":"select * from adsample3 where Timestamp = @StartTime"
   }
}

Kontrollera datainmatningsstatus

Om du vill kontrollera förloppet för ett datainmatningsjobb när du har lagt till dataflödet kan du kontrollera statusen för det. Spara nedanstående JSON-begärandetext i en filbody.jspå och kör cURL-kommandot.

{
  "startTime": "2020-01-01T00:00:00.0000000+00:00",
  "endTime": "2020-01-04T00:00:00.0000000+00:00"
}

Kommandot cURL körs från ett BASH-gränssnitt. Redigera det här kommandot med ditt eget resursnamn, resursnyckel och JSON-värden och storleken på JSON.

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/datafeeds/REPLACE-WITH-YOUR-DATA-FEED-ID/ingestionStatus/query \
-X POST \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY" \
-H "Content-Type:application/json" \
-d @body.json

Exempelsvar

{
  "@nextLink": "https://demo.example.com/datafeeds/01234567-8901-2345-6789-012345678901/ingestionStatus/query?$skip=3&$top=1",
  "value": [
    {
      "timestamp": "2020-09-03T00:00:00.0000000+00:00",
      "status": "Running",
      "message": ""
    },
    {
      "timestamp": "2020-09-02T00:00:00.0000000+00:00",
      "status": "Succeeded",
      "message": ""
    },
    {
      "timestamp": "2020-09-01T00:00:00.0000000+00:00",
      "status": "Failed",
      "message": "No valid record pulled from source for current timestamp 2020-01-01T00:00:00Z"
    }
  ]
}

Konfigurera konfiguration av avvikelseidentifiering

Medan en standardkonfiguration tillämpas automatiskt på varje mått kan du finjustera identifieringslägen som används för dina data. Spara nedanstående JSON-begärandetext i en filbody.jspå och kör cURL-kommandot.

{
        "name": "test_detection_config0000000001",
        "description": "string",
        "metricId": "8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
        "wholeMetricConfiguration": {
            "smartDetectionCondition": {
                "sensitivity": 100,
                "anomalyDetectorDirection": "Both",
                "suppressCondition": {
                    "minNumber": 1,
                    "minRatio": 1
                }
            }
        },
        "dimensionGroupOverrideConfigurations": [
        ],
        "seriesOverrideConfigurations": [
        ]
}

Kommandot cURL körs från ett BASH-gränssnitt. Redigera det här kommandot med ditt eget resursnamn, resursnyckel och JSON-värden och storleken på JSON.

curl -i https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/enrichment/anomalyDetection/configurations \
-X POST \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY" \
-H "Content-Type:application/json" \
-d @body.json

Exempelsvar

HTTP/1.1 201 Created
Content-Length: 0
Location: https://gualala-beta-0617.cognitiveservices.azure.com/metricsadvisor/v1.0/enrichment/anomalyDetection/configurations/6a977d61-f0f5-488a-a162-2feb4643ae09
x-request-id: 17752fcc-9085-46d5-ad37-c4e9e9ba6a5a
x-envoy-upstream-service-time: 253
apim-request-id: 17752fcc-9085-46d5-ad37-c4e9e9ba6a5a
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
x-content-type-options: nosniff
Date: Tue, 08 Sep 2020 09:50:38 GMT

I platsrubriken ovan innehåller den URL:en för den nya skapade resursen (identifieringskonfiguration).

Med hjälp av ovanstående URL i Platshuvud kan du konfigurera frågeidentifiering som du har skapat (vi kommer att använda anomalyDetectionConfigurationId i svarsinnehåll i följande steg)

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/enrichment/anomalyDetection/configurations/REPLACE-WITH-YOUR-DETECTION-CONFIGURATION-ID \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY"

Exempelsvar

{
   "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
   "name":"test_detection_config0000000001",
   "description":"string",
   "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
   "wholeMetricConfiguration":{
      "smartDetectionCondition":{
         "sensitivity":100.0,
         "anomalyDetectorDirection":"Both",
         "suppressCondition":{
            "minNumber":1,
            "minRatio":1.0
         }
      }
   },
   "dimensionGroupOverrideConfigurations":[
      
   ],
   "seriesOverrideConfigurations":[
      
   ]
}

Konfigurera aviseringskonfiguration

Innan du konfigurerar aviseringen måste du skapa en hook som ska användas för att meddela aviseringen. Det finns två sätt att få aviseringar om en avisering utlöses, det vill säga webhook och e-post. Du kan ange någon av dem i hook-konfigurationen som hooktyp när du skapar en hook.

Spara nedanstående JSON-begärandetext i en filbody.jspå och kör cURL-kommandot.

{
        "hookType": "Webhook",
        "hookName": "test_web_hook000001",
        "description": "",
        "externalLink": "",
        "hookParameter": {
            "endpoint": "https://www.xxx.com/aaa",
            "username": "",
            "password": ""
        }
}

Kommandot cURL körs från ett BASH-gränssnitt. Redigera det här kommandot med ditt eget resursnamn, resursnyckel och JSON-värden och storleken på JSON.

curl -i https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/hooks \
-X POST \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY" \
-H "Content-Type:application/json" \
-d @body.json

Exempelsvar

HTTP/1.1 201 Created
Content-Length: 0
Location: https://gualala-beta-0617.cognitiveservices.azure.com/metricsadvisor/v1.0/hooks/34d677bd-0875-4760-8bf6-24d48abde7c3
x-request-id: 7b6cc1a6-02cb-405b-bee3-174fdae0a7d2
x-envoy-upstream-service-time: 1640
apim-request-id: 7b6cc1a6-02cb-405b-bee3-174fdae0a7d2
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
x-content-type-options: nosniff
Date: Tue, 08 Sep 2020 10:37:59 GMT

Med hjälp av ovanstående URL i Platshuvud kan du köra frågor mot den webhook som du har skapat.

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/hooks/REPLACE-WITH-YOUR-HOOK-ID \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY"

Exempelsvar

{
   "hookId":"34d677bd-0875-4760-8bf6-24d48abde7c3",
   "hookName":"test_web_hook000001",
   "hookType":"Webhook",
   "externalLink":"",
   "description":"",
   "admins":[
      "bowgong@microsoft.com"
   ],
   "hookParameter":{
      "endpoint":"https://www.xxx.com/aaa",
      "username":"",
      "password":"",
      "headers":{
         

      },
      "certificateKey":"",
      "certificatePassword":""

   }
}

Genom att konfigurera aviseringskonfiguration kan du ange identifieringsvillkor som kan användas för att utlösa avisering. Spara nedanstående JSON-begärandetext i en filbody.jspå och kör cURL-kommandot.

{
        "name": "test_alert_config00000001",
        "description": "",
        "crossMetricsOperator": "AND",
        "hookIds": [
           "34d677bd-0875-4760-8bf6-24d48abde7c3" 
        ],
        "metricAlertingConfigurations": [
            {
                "anomalyDetectionConfigurationId": "6a977d61-f0f5-488a-a162-2feb4643ae09",
                "anomalyScopeType": "All",
                "severityFilter": {
                    "minAlertSeverity": "Low",
                    "maxAlertSeverity": "High"
                },
                "snoozeFilter": {
                    "autoSnooze": 0,
                    "snoozeScope": "Metric",
                    "onlyForSuccessive": true
                },
            }
        ]
}

Kommandot cURL körs från ett BASH-gränssnitt. Redigera det här kommandot med ditt eget resursnamn, resursnyckel och JSON-värden och storleken på JSON.

curl -i https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/alert/anomaly/configurations \
-X POST \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY" \
-H "Content-Type:application/json" \
-d @body.json

Exempelsvar

HTTP/1.1 201 Created
Content-Length: 0
Location: https://gualala-beta-0617.cognitiveservices.azure.com/metricsadvisor/v1.0/alert/anomaly/configurations/40004c91-6996-47c0-b8c8-fd20a8f4f0ab
x-request-id: 17752fcc-9085-46d5-ad37-c4e9e9ba6a5a
x-envoy-upstream-service-time: 253
apim-request-id: 17752fcc-9085-46d5-ad37-c4e9e9ba6a5a
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
x-content-type-options: nosniff
Date: Tue, 08 Sep 2020 09:50:38 GMT

I platsrubriken ovan innehåller den URL:en för den nya skapade resursen (identifieringskonfiguration).

Med hjälp av ovanstående URL i Platshuvud kan du köra frågor mot den aviseringskonfiguration som du har skapat. (Vi använder anomalyAlertingConfigurationId i aviseringskonfigurationen i följande steg)

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/alert/anomaly/configurations/REPLACE-WITH-YOUR-ANOMALY-ALERTING-CONFIGURATION-ID \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY"

Exempelsvar

{
   "anomalyAlertingConfigurationId":"40004c91-6996-47c0-b8c8-fd20a8f4f0ab",
   "name":"test_alert_config00000001",
   "description":"",
   "hookIds":[
      "34d677bd-0875-4760-8bf6-24d48abde7c3"
   ],
   "metricAlertingConfigurations":[
      {
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "anomalyScopeType":"All",
         "negationOperation":false,
         "severityFilter":{
            "minAlertSeverity":"Low",
            "maxAlertSeverity":"High"
         },
         "snoozeFilter":{
            "autoSnooze":0,
            "snoozeScope":"Metric",
            "onlyForSuccessive":true
         }
      }
   ]
}

Frågeresultat för avvikelseidentifiering

Det finns olika sätt att få identifieringsresultat. Du kan till exempel aktivt köra frågor mot identifieringsresultat med jämna mellanrum med hjälp av identifieringskonfigurationen som du har skapat, eller så kan du meddelas via en avisering och sedan kan du använda den här aviseringen för att köra frågor mot motsvarande avvikelser.

I följande exempel visas hur du frågar efter aviseringar och använder den här aviseringen för att fråga efter avvikelser som är relaterade till den här aviseringen.

Frågeavisering

Du kan använda aviseringskonfigurationen som skapades i steget ovan för att köra frågor mot aviseringen.

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/alert/anomaly/configurations/REPLACE-WITH-YOUR-ANOMALY-ALERTING-CONFIGURATION-ID/alerts/query \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY"

Exempelsvar

{
   "value":[
      {
         "alertId":"17465dcc000",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.532Z",
         "modifiedTime":"2020-09-08T19:12:46.588Z"
      }
   ],
   "@nextLink":null
}

I svaret ovan fick vi en avisering. Med hjälp av det här alertID:t kan vi köra frågor mot alla relaterade avvikelser som orsakade aviseringen.

(Ett annat sätt att få en avisering är att konfigurera webhook och få en passiv avisering när den hittas)

Köra frågor mot avvikelser med alertID

curl https://REPLACE-WITH-YOUR-ENDPOINT/metricsadvisor/v1.0/alert/anomaly/configurations/REPLACE-WITH-YOUR-ANOMALY-ALERTING-CONFIGURATION-ID/alerts/REPLACE-WITH-YOUR-ALERTID/anomalies \
-H "Ocp-Apim-Subscription-Key: REPLACE-WITH-YOUR-RESOURCE-KEY" \
-H "x-api-key: REPLACE-WITH-YOUR-API-KEY"

Exempelsvar

{
   "value":[
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Amphibian",
            "category":"Caucasian Fir"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      },
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Animals by number of neurons",
            "category":"Crack willow"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      },
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Amphibian",
            "category":"Crack willow"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      },
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Animals by number of neurons",
            "category":"Common Lime"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      },
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Chickadee",
            "category":"Common Lime"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      },
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Amphibian",
            "category":"Common Lime"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      },
      {
         "metricId":"8d03e541-a56d-4c28-8d9c-09ce91c6d95f",
         "anomalyDetectionConfigurationId":"6a977d61-f0f5-488a-a162-2feb4643ae09",
         "timestamp":"2020-09-07T00:00:00Z",
         "createdTime":"2020-09-08T19:12:46.566Z",
         "modifiedTime":"2020-09-08T19:12:46.566Z",
         "dimension":{
            "city":"Chickadee",
            "category":"Crack willow"
         },
         "property":{
            "anomalySeverity":"High",
            "anomalyStatus":"Active"
         }
      }
   ],
   "@nextLink":null
}