Delen via

Afgeschaft ⚠️: Dit pakket is afgeschaft en is niet langer in actieve ontwikkeling. Gelieve te migreren naar de volgende pakketten:

Nieuwe functies en niet-beveiligingsbugfixes worden toegevoegd aan de hierboven genoemde vervangende bibliotheken.

De Azure Monitor Query-clientbibliotheek wordt gebruikt om alleen-lezen query's uit te voeren op de twee gegevensplatforms van Azure Monitor:

  • Logboeken - Verzamelt en organiseert logboek- en prestatiegegevens van bewaakte bronnen. Gegevens uit verschillende bronnen, zoals platformlogboeken van Azure-services, logboek- en prestatiegegevens van agents voor virtuele machines en gebruiks- en prestatiegegevens van apps, kunnen worden geconsolideerd in één Azure Log Analytics-werkruimte. De verschillende gegevenstypen kunnen samen worden geanalyseerd met behulp van de Kusto-querytaal.
  • Metrische gegevens : verzamelt numerieke gegevens van bewaakte bronnen in een tijdreeksdatabase. Metrische gegevens zijn numerieke waarden die regelmatig worden verzameld en een bepaald aspect van een systeem op een bepaald tijdstip beschrijven. Metrische gegevens zijn lichtgewicht en kunnen bijna realtime scenario's ondersteunen, waardoor ze handig zijn voor waarschuwingen en snelle detectie van problemen.

Bronnen:

Slag

Ondersteunde omgevingen

Zie ons ondersteuningsbeleidvoor meer informatie.

Voorwaarden

  • Een Azure-abonnement
  • Een implementatie van TokenCredential, zoals een referentietype van de Azure Identity-bibliotheek.
  • Als u logboeken wilt opvragen, hebt u een van de volgende zaken nodig:
  • Als u query's wilt uitvoeren op metrische gegevens, hebt u een Azure-resource van elk type nodig (Opslagaccount, Key Vault, Cosmos DB, enzovoort).

Het pakket installeren

Installeer de Azure Monitor Query-clientbibliotheek voor JavaScript met npm:

npm install --save @azure/monitor-query

De client maken

Een geverifieerde client is vereist voor het opvragen van logboeken of metrische gegevens. Voor verificatie wordt in het volgende voorbeeld DefaultAzureCredential uit het pakket @azure/identity gebruikt.

import { DefaultAzureCredential } from "@azure/identity";
import { LogsQueryClient, MetricsQueryClient, MetricsClient } from "@azure/monitor-query";

const credential = new DefaultAzureCredential();

// Create a LogsQueryClient
const logsQueryClient = new LogsQueryClient(credential);

// Create a MetricsQueryClient
const metricsQueryClient = new MetricsQueryClient(credential);

// Create a MetricsClient
const endpoint = " https://<endpoint>.monitor.azure.com/";
const metricsClient = new MetricsClient(endpoint, credential);

Client configureren voor onafhankelijke Azure-cloud

De clients van de bibliotheek zijn standaard geconfigureerd voor het gebruik van de openbare Azure-cloud. Als u in plaats daarvan een onafhankelijke cloud wilt gebruiken, geeft u het juiste eindpunt en de doelgroepwaarde op bij het instantiëren van een client. Bijvoorbeeld:

import { DefaultAzureCredential } from "@azure/identity";
import { LogsQueryClient, MetricsQueryClient, MetricsClient } from "@azure/monitor-query";

const credential = new DefaultAzureCredential();

// Create a LogsQueryClient
const logsQueryClient: LogsQueryClient = new LogsQueryClient(credential, {
  endpoint: "https://api.loganalytics.azure.cn/v1",
  audience: "https://api.loganalytics.azure.cn/.default",
});

// Create a MetricsQueryClient
const metricsQueryClient: MetricsQueryClient = new MetricsQueryClient(credential, {
  endpoint: "https://management.chinacloudapi.cn",
  audience: "https://monitor.azure.cn/.default",
});

// Create a MetricsClient
const endpoint = " https://<endpoint>.monitor.azure.cn/";
const metricsClient = new MetricsClient(endpoint, credential, {
  audience: "https://monitor.azure.cn/.default",
});

Opmerking: Gebruikt MetricsQueryClient momenteel het Azure Resource Manager (ARM)-eindpunt voor het uitvoeren van query's op metrische gegevens. U hebt het bijbehorende beheereindpunt voor uw cloud nodig bij het gebruik van deze client. Deze details kunnen in de toekomst worden gewijzigd.

De query uitvoeren

Zie de sectie Voorbeelden voor voorbeelden van logboeken en metrische query's.

Sleutelbegrippen

Logboeken queryfrequentielimieten en bandbreedtebeperking

De Log Analytics-service past beperking toe wanneer de aanvraagsnelheid te hoog is. Limieten, zoals het maximum aantal geretourneerde rijen, worden ook toegepast op de Kusto-query's. Zie Query-API voor meer informatie.

Gegevensstructuur voor metrische gegevens

Elke set met metrische waarden is een tijdreeks met de volgende kenmerken:

  • Het tijdstip waarop de waarde is verzameld
  • De resource die is gekoppeld aan de waarde
  • Een naamruimte die fungeert als een categorie voor de metrische waarde
  • Een metrische naam
  • De waarde zelf
  • Sommige metrische gegevens hebben meerdere dimensies, zoals beschreven in multidimensionale metrische gegevens. Aangepaste metrische gegevens kunnen maximaal 10 dimensies hebben.

Voorbeelden

Logboekquery

Het LogsQueryClient kan worden gebruikt om een query uit te voeren op een Log Analytics-werkruimte met behulp van de Kusto-querytaal. Het timespan.duration kan worden gespecificeerd als een tekenreeks in een ISO 8601-duurformaat. U kunt de Durations constanten gebruiken die worden gegeven voor een aantal veelgebruikte ISO 8601-duurperioden.

U kunt query's uitvoeren op logboeken op log analytics-werkruimte-id of Azure-resource-id. Het resultaat wordt geretourneerd als een tabel met een verzameling rijen.

Query voor werkruimtegerichte logboeken

Gebruik de LogsQueryClient.queryWorkspace volgende methode om een query uit te voeren op basis van werkruimte-id:

import { LogsQueryClient, Durations, LogsQueryResultStatus } from "@azure/monitor-query";
import { DefaultAzureCredential } from "@azure/identity";

const azureLogAnalyticsWorkspaceId = "<workspace_id>";
const logsQueryClient = new LogsQueryClient(new DefaultAzureCredential());

const kustoQuery = "AppEvents | limit 1";
const result = await logsQueryClient.queryWorkspace(azureLogAnalyticsWorkspaceId, kustoQuery, {
  duration: Durations.twentyFourHours,
});

if (result.status === LogsQueryResultStatus.Success) {
  const tablesFromResult = result.tables;

  if (tablesFromResult.length === 0) {
    console.log(`No results for query '${kustoQuery}'`);
    return;
  }
  console.log(`This query has returned table(s) - `);
  processTables(tablesFromResult);
} else {
  console.log(`Error processing the query '${kustoQuery}' - ${result.partialError}`);
  if (result.partialTables.length > 0) {
    console.log(`This query has also returned partial data in the following table(s) - `);
    processTables(result.partialTables);
  }
}

function processTables(tablesFromResult) {
  for (const table of tablesFromResult) {
    const columnHeaderString = table.columnDescriptors
      .map((column) => `${column.name}(${column.type}) `)
      .join("| ");
    console.log("| " + columnHeaderString);
    for (const row of table.rows) {
      const columnValuesString = row.map((columnValue) => `'${columnValue}' `).join("| ");
      console.log("| " + columnValuesString);
    }
  }
}

Query voor resourcegerichte logboeken

In het volgende voorbeeld ziet u hoe u logboeken rechtstreeks vanuit een Azure-resource opvraagt. Hier wordt de queryResource methode gebruikt en wordt een Azure-resource-id doorgegeven. Bijvoorbeeld: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

De resource-id zoeken:

  1. Navigeer naar de pagina van uw resource in Azure Portal.
  2. Selecteer op de blade Overzicht de koppeling JSON-weergave .
  3. Kopieer in de resulterende JSON de waarde van de id eigenschap.
import { DefaultAzureCredential } from "@azure/identity";
import { LogsQueryClient, Durations, LogsQueryResultStatus } from "@azure/monitor-query";

const logsResourceId = "<the Resource Id for your logs resource>";

const tokenCredential = new DefaultAzureCredential();
const logsQueryClient = new LogsQueryClient(tokenCredential);

const kustoQuery = `MyTable_CL | summarize count()`;

console.log(`Running '${kustoQuery}' over the last One Hour`);
const queryLogsOptions = {
  // explicitly control the amount of time the server can spend processing the query.
  serverTimeoutInSeconds: 600, // sets the timeout to 10 minutes
  // optionally enable returning additional statistics about the query's execution.
  // (by default, this is off)
  includeQueryStatistics: true,
};

const result = await logsQueryClient.queryResource(
  logsResourceId,
  kustoQuery,
  { duration: Durations.sevenDays },
  queryLogsOptions,
);

const executionTime = (result as any)?.statistics?.query?.executionTime;

console.log(
  `Results for query '${kustoQuery}', execution time: ${executionTime == null ? "unknown" : executionTime}`,
);

if (result.status === LogsQueryResultStatus.Success) {
  const tablesFromResult = result.tables;

  if (tablesFromResult.length === 0) {
    console.log(`No results for query '${kustoQuery}'`);
    return;
  }
  console.log(`This query has returned table(s) - `);
  processTables(tablesFromResult);
} else {
  console.log(`Error processing the query '${kustoQuery}' - ${result.partialError}`);
  if (result.partialTables.length > 0) {
    console.log(`This query has also returned partial data in the following table(s) - `);
    processTables(result.partialTables);
  }
}

function processTables(tablesFromResult) {
  for (const table of tablesFromResult) {
    const columnHeaderString = table.columnDescriptors
      .map((column) => `${column.name}(${column.type}) `)
      .join("| ");
    console.log("| " + columnHeaderString);

    for (const row of table.rows) {
      const columnValuesString = row.map((columnValue) => `'${columnValue}' `).join("| ");
      console.log("| " + columnValuesString);
    }
  }
}

Logboekenqueryantwoord verwerken

De queryWorkspace functie van LogsQueryClient geeft een LogsQueryResult object terug. Het objecttype kan of zijn LogsQuerySuccessfulResultLogsQueryPartialResult. Hier volgt een hiërarchie van het antwoord:

LogsQuerySuccessfulResult
|---statistics
|---visualization
|---status ("Success")
|---tables (list of `LogsTable` objects)
    |---name
    |---rows
    |---columnDescriptors (list of `LogsColumn` objects)
        |---name
        |---type

LogsQueryPartialResult
|---statistics
|---visualization
|---status ("PartialFailure")
|---partialError
    |--name
    |--code
    |--message
    |--stack
|---partialTables (list of `LogsTable` objects)
    |---name
    |---rows
    |---columnDescriptors (list of `LogsColumn` objects)
        |---name
        |---type

Als u bijvoorbeeld een antwoord wilt verwerken met tabellen:

function processTables(tablesFromResult) {
  for (const table of tablesFromResult) {
    const columnHeaderString = table.columnDescriptors
      .map((column) => `${column.name}(${column.type}) `)
      .join("| ");
    console.log("| " + columnHeaderString);

    for (const row of table.rows) {
      const columnValuesString = row.map((columnValue) => `'${columnValue}' `).join("| ");
      console.log("| " + columnValuesString);
    }
  }
}

Een volledig voorbeeld is hier te vinden.

Query voor Batch-logboeken

In het volgende voorbeeld ziet u hoe u meerdere query's tegelijk verzendt met behulp van de batchquery-API. De query's kunnen worden weergegeven als een lijst met BatchQuery objecten.

import { DefaultAzureCredential } from "@azure/identity";
import { LogsQueryClient, LogsQueryResultStatus } from "@azure/monitor-query";

const monitorWorkspaceId = "<workspace_id>";

const tokenCredential = new DefaultAzureCredential();
const logsQueryClient = new LogsQueryClient(tokenCredential);

const kqlQuery = "AppEvents | project TimeGenerated, Name, AppRoleInstance | limit 1";
const queriesBatch = [
  {
    workspaceId: monitorWorkspaceId,
    query: kqlQuery,
    timespan: { duration: "P1D" },
  },
  {
    workspaceId: monitorWorkspaceId,
    query: "AzureActivity | summarize count()",
    timespan: { duration: "PT1H" },
  },
  {
    workspaceId: monitorWorkspaceId,
    query:
      "AppRequests | take 10 | summarize avgRequestDuration=avg(DurationMs) by bin(TimeGenerated, 10m), _ResourceId",
    timespan: { duration: "PT1H" },
  },
  {
    workspaceId: monitorWorkspaceId,
    query: "AppRequests | take 2",
    timespan: { duration: "PT1H" },
    includeQueryStatistics: true,
  },
];

const result = await logsQueryClient.queryBatch(queriesBatch);

if (result == null) {
  throw new Error("No response for query");
}

let i = 0;
for (const response of result) {
  console.log(`Results for query with query: ${queriesBatch[i]}`);
  if (response.status === LogsQueryResultStatus.Success) {
    console.log(
      `Printing results from query '${queriesBatch[i].query}' for '${queriesBatch[i].timespan}'`,
    );
    processTables(response.tables);
  } else if (response.status === LogsQueryResultStatus.PartialFailure) {
    console.log(
      `Printing partial results from query '${queriesBatch[i].query}' for '${queriesBatch[i].timespan}'`,
    );
    processTables(response.partialTables);
    console.log(
      ` Query had errors:${response.partialError.message} with code ${response.partialError.code}`,
    );
  } else {
    console.log(`Printing errors from query '${queriesBatch[i].query}'`);
    console.log(` Query had errors:${response.message} with code ${response.code}`);
  }
  // next query
  i++;
}

function processTables(tablesFromResult) {
  for (const table of tablesFromResult) {
    const columnHeaderString = table.columnDescriptors
      .map((column) => `${column.name}(${column.type}) `)
      .join("| ");
    console.log("| " + columnHeaderString);

    for (const row of table.rows) {
      const columnValuesString = row.map((columnValue) => `'${columnValue}' `).join("| ");
      console.log("| " + columnValuesString);
    }
  }
}

Batchqueryantwoorden verwerken in logboeken

De queryBatch functie van LogsQueryClient geeft een LogsQueryBatchResult object terug. LogsQueryBatchResult Bevat een lijst van objecten met de volgende mogelijke typen:

  • LogsQueryPartialResult
  • LogsQuerySuccessfulResult
  • LogsQueryError

Hier volgt een hiërarchie van het antwoord:

LogsQuerySuccessfulResult
|---statistics
|---visualization
|---status ("Success")
|---tables (list of `LogsTable` objects)
    |---name
    |---rows
    |---columnDescriptors (list of `LogsColumn` objects)
        |---name
        |---type

LogsQueryPartialResult
|---statistics
|---visualization
|---status ("PartialFailure")
|---partialError
    |--name
    |--code
    |--message
    |--stack
|---partialTables (list of `LogsTable` objects)
    |---name
    |---rows
    |---columnDescriptors (list of `LogsColumn` objects)
        |---name
        |---type

LogsQueryError
|--name
|--code
|--message
|--stack
|--status ("Failure")

Met de volgende code wordt bijvoorbeeld een queryantwoord voor batchlogboeken verwerkt:

import { LogsQueryResultStatus } from "@azure/monitor-query";

async function processBatchResult(result, queriesBatch) {
  let i = 0;
  for (const response of result) {
    console.log(`Results for query with query: ${queriesBatch[i]}`);
    if (response.status === LogsQueryResultStatus.Success) {
      console.log(
        `Printing results from query '${queriesBatch[i].query}' for '${queriesBatch[i].timespan}'`,
      );
      processTables(response.tables);
    } else if (response.status === LogsQueryResultStatus.PartialFailure) {
      console.log(
        `Printing partial results from query '${queriesBatch[i].query}' for '${queriesBatch[i].timespan}'`,
      );
      processTables(response.partialTables);
      console.log(
        ` Query had errors:${response.partialError.message} with code ${response.partialError.code}`,
      );
    } else {
      console.log(`Printing errors from query '${queriesBatch[i].query}'`);
      console.log(` Query had errors:${response.message} with code ${response.code}`);
    }
    // next query
    i++;
  }
}

function processTables(tablesFromResult) {
  for (const table of tablesFromResult) {
    const columnHeaderString = table.columnDescriptors
      .map((column) => `${column.name}(${column.type}) `)
      .join("| ");
    console.log("| " + columnHeaderString);

    for (const row of table.rows) {
      const columnValuesString = row.map((columnValue) => `'${columnValue}' `).join("| ");
      console.log("| " + columnValuesString);
    }
  }
}

Een volledig voorbeeld is hier te vinden.

Geavanceerde queryscenario's voor logboeken

Time-out voor logboekquery's instellen

Het uitvoeren van sommige logboekquery's duurt langer dan 3 minuten. De standaardtime-out voor de server is 3 minuten. U kunt de time-out van de server verhogen tot maximaal 10 minuten. In het volgende voorbeeld wordt de eigenschap van LogsQueryOptions het serverTimeoutInSeconds object gebruikt om de time-out van de server te verlengen tot 10 minuten:

import { DefaultAzureCredential } from "@azure/identity";
import { LogsQueryClient, Durations } from "@azure/monitor-query";

const azureLogAnalyticsWorkspaceId = "<workspace_id>";

const tokenCredential = new DefaultAzureCredential();
const logsQueryClient = new LogsQueryClient(tokenCredential);

const kqlQuery = "AppEvents | project TimeGenerated, Name, AppRoleInstance | limit 1";

// setting optional parameters
const queryLogsOptions = {
  // explicitly control the amount of time the server can spend processing the query.
  serverTimeoutInSeconds: 600, // 600 seconds = 10 minutes
};

const result = await logsQueryClient.queryWorkspace(
  azureLogAnalyticsWorkspaceId,
  kqlQuery,
  { duration: Durations.twentyFourHours },
  queryLogsOptions,
);

const status = result.status;

Query's uitvoeren op meerdere werkruimten

Dezelfde logboekquery kan worden uitgevoerd in meerdere Log Analytics-werkruimten. Naast de Kusto-query zijn de volgende parameters vereist:

  • workspaceId - De eerste (primaire) werkruimte-ID.
  • additionalWorkspaces - Een lijst met werkruimten, met uitzondering van de werkruimte die in de workspaceId parameter is opgegeven. De lijstitems van de parameter kunnen bestaan uit de volgende id-indelingen:
    • Gekwalificeerde werkruimtenamen
    • Werkruimte-id's
    • Azure-resource-id's

De volgende query wordt bijvoorbeeld uitgevoerd in drie werkruimten:

import { DefaultAzureCredential } from "@azure/identity";
import { LogsQueryClient, Durations } from "@azure/monitor-query";

const azureLogAnalyticsWorkspaceId = "<workspace_id>";

const tokenCredential = new DefaultAzureCredential();
const logsQueryClient = new LogsQueryClient(tokenCredential);

const kqlQuery = "AppEvents | project TimeGenerated, Name, AppRoleInstance | limit 1";

// setting optional parameters
const queryLogsOptions = {
  additionalWorkspaces: ["<workspace2>", "<workspace3>"],
};

const result = await logsQueryClient.queryWorkspace(
  azureLogAnalyticsWorkspaceId,
  kqlQuery,
  { duration: Durations.twentyFourHours },
  queryLogsOptions,
);

const status = result.status;

Als u de resultaten voor elke werkruimte wilt weergeven, gebruikt u de TenantId kolom om de resultaten te ordenen of te filteren in de Kusto-query.

Bestel resultaten op TenantId

AppEvents | order by TenantId

Resultaten filteren op TenantId

AppEvents | filter TenantId == "<workspace2>"

Een volledig voorbeeld is hier te vinden.

Statistieken opnemen

Ga als volgende te werk om statistieken over de uitvoering van logboeken op te halen, zoals CPU en geheugenverbruik:

  1. Stel de eigenschap LogsQueryOptions.includeQueryStatistics in op true.
  2. Open het statistics veld in het LogsQueryResult object.

In het volgende voorbeeld wordt de uitvoeringstijd van de query afgedrukt:

import { LogsQueryClient, Durations } from "@azure/monitor-query";
import { DefaultAzureCredential } from "@azure/identity";

const monitorWorkspaceId = "<workspace_id>";
const logsQueryClient = new LogsQueryClient(new DefaultAzureCredential());
const kustoQuery = "AzureActivity | top 10 by TimeGenerated";

const result = await logsQueryClient.queryWorkspace(
  monitorWorkspaceId,
  kustoQuery,
  { duration: Durations.oneDay },
  {
    includeQueryStatistics: true,
  },
);

const executionTime = (result as any)?.statistics?.query?.executionTime;

console.log(
  `Results for query '${kustoQuery}', execution time: ${executionTime == null ? "unknown" : executionTime}`,
);

Omdat de structuur van de statistics payload per query verschilt, wordt een Record<string, unknown> retourtype gebruikt. Het bevat het onbewerkte JSON-antwoord. De statistieken zijn te vinden binnen het query eigendom van de JSON. Bijvoorbeeld:

{
  "query": {
    "executionTime": 0.0156478,
    "resourceUsage": {...},
    "inputDatasetStatistics": {...},
    "datasetStatistics": [{...}]
  }
}

Visualisatie opnemen

Visualisatiegegevens ophalen voor logboekquery's met behulp van de renderoperator:

  1. Stel de eigenschap LogsQueryOptions.includeVisualization in op true.
  2. Open het visualization veld in het LogsQueryResult object.

Bijvoorbeeld:

import { LogsQueryClient, Durations } from "@azure/monitor-query";
import { DefaultAzureCredential } from "@azure/identity";

const monitorWorkspaceId = "<workspace_id>";
const logsQueryClient = new LogsQueryClient(new DefaultAzureCredential());

const result = await logsQueryClient.queryWorkspace(
  monitorWorkspaceId,
  `StormEvents
        | summarize event_count = count() by State
        | where event_count > 10
        | project State, event_count
        | render columnchart`,
  { duration: Durations.oneDay },
  {
    includeVisualization: true,
  },
);

console.log("visualization result:", result.visualization);

Omdat de structuur van de visualization payload per query verschilt, wordt een Record<string, unknown> retourtype gebruikt. Het bevat het onbewerkte JSON-antwoord. Bijvoorbeeld:

{
  "visualization": "columnchart",
  "title": "the chart title",
  "accumulate": false,
  "isQuerySorted": false,
  "kind": null,
  "legend": null,
  "series": null,
  "yMin": "NaN",
  "yMax": "NaN",
  "xAxis": null,
  "xColumn": null,
  "xTitle": "x axis title",
  "yAxis": null,
  "yColumns": null,
  "ySplit": null,
  "yTitle": null,
  "anomalyColumns": null
}

Query voor metrische gegevens

In het volgende voorbeeld worden metrische gegevens voor een Azure Metrics Advisor-abonnement opgehaald. De resource-URI moet dat zijn van de resource waarvoor metrische gegevens worden opgevraagd. Het is normaal gesproken van het formaat /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

De resource-URI zoeken:

  1. Navigeer naar de pagina van uw resource in Azure Portal.
  2. Selecteer op de blade Overzicht de koppeling JSON-weergave .
  3. Kopieer in de resulterende JSON de waarde van de id eigenschap.
import { DefaultAzureCredential } from "@azure/identity";
import { MetricsQueryClient, Durations } from "@azure/monitor-query";

const metricsResourceId = "<the Resource Id for your metrics resource>";

const tokenCredential = new DefaultAzureCredential();
const metricsQueryClient = new MetricsQueryClient(tokenCredential);

const metricNames = [];
const metricDefinitions = metricsQueryClient.listMetricDefinitions(metricsResourceId);
for await (const { id, name } of metricDefinitions) {
  console.log(` metricDefinitions - ${id}, ${name}`);
  if (name) {
    metricNames.push(name);
  }
}

const [firstMetricName, secondMetricName] = metricNames;
if (firstMetricName && secondMetricName) {
  console.log(`Picking an example metric to query: ${firstMetricName} and ${secondMetricName}`);
  const metricsResponse = await metricsQueryClient.queryResource(
    metricsResourceId,
    [firstMetricName, secondMetricName],
    {
      granularity: "PT1M",
      timespan: { duration: Durations.fiveMinutes },
    },
  );

  console.log(
    `Query cost: ${metricsResponse.cost}, interval: ${metricsResponse.granularity}, time span: ${metricsResponse.timespan}`,
  );

  const metrics = metricsResponse.metrics;
  console.log(`Metrics:`, JSON.stringify(metrics, undefined, 2));
  const metric = metricsResponse.getMetricByName(firstMetricName);
  console.log(`Selected Metric: ${firstMetricName}`, JSON.stringify(metric, undefined, 2));
} else {
  console.error(`Metric names are not defined - ${firstMetricName} and ${secondMetricName}`);
}

In het voorgaande voorbeeld zijn de metrische resultaten gerangschikt metricsResponse op basis van de volgorde waarin de gebruiker de namen van de metrische gegevens opgeeft in het metricNames matrixargument voor de queryResource functie. Als de gebruiker opgeeft [firstMetricName, secondMetricName], verschijnt het resultaat voor firstMetricName vóór het resultaat voor secondMetricName in de metricResponse.

Queryantwoord voor metrische gegevens verwerken

De functie Metrische gegevens queryResource retourneert een QueryMetricsResult object. Het QueryMetricsResult object bevat eigenschappen zoals een lijst met Metric-getypte objecten, interval, namespace, en timespan. De Metric objectenlijst kan worden geopend met behulp van de metrics eigenschap. Elk Metric object in deze lijst bevat een lijst met TimeSeriesElement objecten. Elk TimeSeriesElement bevat data en metadataValues eigenschappen. In visuele vorm lijkt de objecthiërarchie van het antwoord op de volgende structuur:

QueryMetricsResult
|---cost
|---timespan (of type `QueryTimeInterval`)
|---granularity
|---namespace
|---resourceRegion
|---metrics (list of `Metric` objects)
    |---id
    |---type
    |---name
    |---unit
    |---displayDescription
    |---errorCode
    |---timeseries (list of `TimeSeriesElement` objects)
        |---metadataValues
        |---data (list of data points represented by `MetricValue` objects)
            |---timeStamp
            |---average
            |---minimum
            |---maximum
            |---total
            |---count
|---getMetricByName(metricName): Metric | undefined (convenience method)

Voorbeeld van het verwerken van een antwoord

import { DefaultAzureCredential } from "@azure/identity";
import { MetricsQueryClient, Durations } from "@azure/monitor-query";

const metricsResourceId = "<the Resource Id for your metrics resource>";

const tokenCredential = new DefaultAzureCredential();
const metricsQueryClient = new MetricsQueryClient(tokenCredential);

console.log(`Picking an example metric to query: MatchedEventCount`);

const metricsResponse = await metricsQueryClient.queryResource(
  metricsResourceId,
  ["MatchedEventCount"],
  {
    timespan: {
      duration: Durations.fiveMinutes,
    },
    granularity: "PT1M",
    aggregations: ["Count"],
  },
);

console.log(
  `Query cost: ${metricsResponse.cost}, granularity: ${metricsResponse.granularity}, time span: ${metricsResponse.timespan}`,
);

const metrics = metricsResponse.metrics;
for (const metric of metrics) {
  console.log(metric.name);
  for (const timeseriesElement of metric.timeseries) {
    for (const metricValue of timeseriesElement.data!) {
      if (metricValue.count !== 0) {
        console.log(`There are ${metricValue.count} matched events at ${metricValue.timeStamp}`);
      }
    }
  }
}

Een volledig voorbeeld is hier te vinden.

Query's uitvoeren op metrische gegevens voor meerdere resources

Gebruik de MetricsClient.queryResources methode om metrische gegevens voor meerdere Azure-resources in één aanvraag op te vragen. Deze methode:

  • Roept een andere API aan dan de MetricsClient methoden.
  • Vereist een regionaal eindpunt bij het maken van de client. Bijvoorbeeld'https://westus3.metrics.monitor.azure.com".

Elke Azure-resource moet zich bevinden in:

  • Dezelfde regio als het eindpunt dat is opgegeven bij het maken van de client.
  • Hetzelfde Azure-abonnement.

Bovendien:

import { DefaultAzureCredential } from "@azure/identity";
import { MetricsClient } from "@azure/monitor-query";

const resourceIds = [
  "/subscriptions/0000000-0000-000-0000-000000/resourceGroups/test/providers/Microsoft.OperationalInsights/workspaces/test-logs",
  "/subscriptions/0000000-0000-000-0000-000000/resourceGroups/test/providers/Microsoft.OperationalInsights/workspaces/test-logs2",
];
const metricsNamespace = "<YOUR_METRICS_NAMESPACE>";
const metricNames = ["requests", "count"];
const endpoint = " https://<endpoint>.monitor.azure.com/";

const credential = new DefaultAzureCredential();
const metricsClient = new MetricsClient(endpoint, credential);

const result = await metricsClient.queryResources(resourceIds, metricNames, metricsNamespace);

Zie Ondersteunde metrische gegevens met Azure Monitor voor een inventaris van metrische gegevens en dimensies die beschikbaar zijn voor elk Azure-resourcetype.

Probleemoplossing

Zie de handleiding voor het oplossen van problemen om verschillende foutscenario's te diagnosticeren.

Volgende stappen

Zie de documentatie van de Azure Monitor-service voor meer informatie over Azure Monitor.

Bijdragen

Als u een bijdrage wilt leveren aan deze bibliotheek, leest u de gids voor bijdragen voor meer informatie over het bouwen en testen van de code.

De tests van deze module zijn een combinatie van live- en eenheidstests, waarvoor u een Azure Monitor-exemplaar moet hebben. Als u de tests wilt uitvoeren, moet u het volgende uitvoeren:

  1. pnpm install
  2. pnpm build --filter @azure/monitor-query...
  3. cd into sdk/monitor/monitor-query
  4. Kopieer het sample.env bestand naar .env
  5. Open het .env bestand in een editor en vul de waarden in.
  6. npm run test.

Bekijk voor meer informatie onze testmap.