Bibliothèque cliente de requête Azure Monitor pour JavaScript - version 1.3.1

Article
08/02/2024

La bibliothèque cliente requête Azure Monitor est utilisée pour exécuter des requêtes en lecture seule sur les deux plateformes de données d’Azure Monitor:

journaux d’activité : collecte et organise les données de journal et de performances à partir de ressources surveillées. Les données provenant de différentes sources telles que les journaux de plateforme à partir des services Azure, les données de journal et de performances des agents de machines virtuelles, ainsi que les données d’utilisation et de performances des applications peuvent être consolidées dans un espace de travail Azure Log Analytique unique. Les différents types de données peuvent être analysés ensemble à l’aide du langage de requête Kusto.
Métriques : collecte des données numériques à partir de ressources surveillées dans une base de données de série chronologique. Les métriques sont des valeurs numériques collectées à intervalles réguliers et décrivent un aspect d’un système à un moment donné. Les métriques sont légères et capables de prendre en charge des scénarios en temps quasi réel, ce qui les rend utiles pour les alertes et la détection rapide des problèmes.

ressources :

code source
package (npm)
Documentation de référence de l’API
documentation Service
Exemples
du journal des modifications

Commencer

Environnements pris en charge

versions LTS de Node.js
Dernières versions de Safari, Chrome, Microsoft Edge et Firefox

Pour plus d’informations, consultez notre stratégie de support .

Conditions préalables

Un abonnement Azure
Implémentation TokenCredential, telle qu’un type d’informations d’identification de bibliothèque Azure Identity .
Pour interroger les journaux, vous avez besoin de l’une des opérations suivantes :
- Un espace de travail Analytique Azure Log
- Ressource Azure de tout type (compte de stockage, Coffre de clés, Cosmos DB, etc.)
Pour interroger des métriques, vous avez besoin d’une ressource Azure de tout type (compte de stockage, coffre de clés, Cosmos DB, etc.).

Installer le package

Installez la bibliothèque cliente requête Azure Monitor pour JavaScript avec npm :

npm install --save @azure/monitor-query

Créer le client

Un client authentifié est requis pour interroger les journaux ou les métriques. Pour vous authentifier, l’exemple suivant utilise DefaultAzureCredential à partir du package/@azure/identity.

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

const credential = new DefaultAzureCredential();

const logsQueryClient: LogsQueryClient = new LogsQueryClient(credential);
// or
const metricsQueryClient: MetricsQueryClient = new MetricsQueryClient(credential);
// or
const endPoint: string = "<YOUR_METRICS_ENDPOINT>"; //for example, https://eastus.metrics.monitor.azure.com/

const metricsQueryClient: MetricsQueryClient = new MetricsQueryClient(endPoint, credential);

Configurer le client pour le cloud souverain Azure

Par défaut, les clients de la bibliothèque sont configurés pour utiliser le cloud public Azure. Pour utiliser un cloud souverain à la place, fournissez le point de terminaison et la valeur d’audience appropriés lors de l’instanciation d’un client. Par exemple:

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

const credential = new DefaultAzureCredential();

const logsQueryClient: LogsQueryClient = new LogsQueryClient(credential, {
  endpoint: "https://api.loganalytics.azure.cn/v1",
  audience: "https://api.loganalytics.azure.cn/.default",
});
// or
const metricsQueryClient: MetricsQueryClient = new MetricsQueryClient(credential, {
  endpoint: "https://management.chinacloudapi.cn",
  audience: "https://monitor.azure.cn/.default",
});
// or
const endPoint: string = "<YOUR_METRICS_ENDPOINT>"; //for example, https://eastus.metrics.monitor.azure.com/

const metricsClient: MetricsClient = new MetricsClient(endPoint, credential, {
  audience: "https://monitor.azure.cn/.default",
});

Remarque: actuellement, MetricsQueryClient utilise le point de terminaison Azure Resource Manager (ARM) pour interroger les métriques. Vous avez besoin du point de terminaison de gestion correspondant pour votre cloud lors de l’utilisation de ce client. Ce détail est susceptible de changer à l’avenir.

Exécuter la requête

Pour obtenir des exemples de requêtes journaux et métriques, consultez la section Exemples.

Concepts clés

Journaux des limites et limitation du taux de requête

Le service log Analytique applique la limitation lorsque le taux de requêtes est trop élevé. Les limites, telles que le nombre maximal de lignes retournées, sont également appliquées aux requêtes Kusto. Pour plus d’informations, consultez 'API de requête.

Structure des données de métriques

Chaque ensemble de valeurs de métriques est une série chronologique avec les caractéristiques suivantes :

Heure à laquelle la valeur a été collectée
Ressource associée à la valeur
Espace de noms qui agit comme une catégorie pour la métrique
Nom d’une métrique
Valeur elle-même
Certaines métriques ont plusieurs dimensions, comme décrit dans les métriques multidimensionnelles. Les métriques personnalisées peuvent avoir jusqu’à 10 dimensions.

Exemples

de requête journaux d’activité
de requête des journaux Batch
- Gérer la réponse aux requêtes par lots des journaux d’activité
scénarios de requête de journaux avancés
requête Métriques

Requête journaux

Le LogsQueryClient peut être utilisé pour interroger un espace de travail log Analytique à l’aide du langage de requête Kusto . La timespan.duration peut être spécifiée sous forme de chaîne dans un format de durée ISO 8601. Vous pouvez utiliser les constantes Durations fournies pour certaines durées ISO 8601 couramment utilisées.

Vous pouvez interroger les journaux par ID d’espace de travail log Analytique ou ID de ressource Azure. Le résultat est retourné sous la forme d’une table avec une collection de lignes.

Requête des journaux centrés sur l’espace de travail

Pour interroger par ID d’espace de travail, utilisez la méthode LogsQueryClient.queryWorkspace :

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

const azureLogAnalyticsWorkspaceId = "<the Workspace Id for your Azure Log Analytics resource>";
const logsQueryClient = new LogsQueryClient(new DefaultAzureCredential());

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

  if (result.status === LogsQueryResultStatus.Success) {
    const tablesFromResult: LogsTable[] = 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);
    }
  }
}

async function processTables(tablesFromResult: LogsTable[]) {
  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);
    }
  }
}

run().catch((err) => console.log("ERROR:", err));

Requête des journaux centrés sur les ressources

L’exemple suivant montre comment interroger les journaux directement à partir d’une ressource Azure. Ici, la méthode queryResource est utilisée et un ID de ressource Azure est transmis. Par exemple, /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Pour trouver l’ID de ressource :

Accédez à la page de votre ressource dans le portail Azure.
Dans le panneau Vue d’ensemble vue d’ensemble, sélectionnez le lien de vue JSON .
Dans le json obtenu, copiez la valeur de la propriété id.

/**
 * @summary Demonstrates how to run a query against a Log Analytics workspace, using an Azure resource ID.
 */

import { DefaultAzureCredential } from "@azure/identity";
import {
  Durations,
  LogsQueryClient,
  LogsTable,
  LogsQueryOptions,
  LogsQueryResultStatus,
} from "@azure/monitor-query";
import * as dotenv from "dotenv";
dotenv.config();

const logsResourceId = process.env.LOGS_RESOURCE_ID;

export async function main() {
  const tokenCredential = new DefaultAzureCredential();
  const logsQueryClient = new LogsQueryClient(tokenCredential);

  if (!logsResourceId) {
    throw new Error("LOGS_RESOURCE_ID must be set in the environment for this sample");
  }

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

  console.log(`Running '${kustoQuery}' over the last One Hour`);
  const queryLogsOptions: LogsQueryOptions = {
    // 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.statistics && result.statistics.query && (result.statistics.query as any).executionTime;

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

  if (result.status === LogsQueryResultStatus.Success) {
    const tablesFromResult: LogsTable[] = 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);
    }
  }
}

async function processTables(tablesFromResult: LogsTable[]) {
  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);
    }
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
  process.exit(1);
});

Gérer la réponse de requête des journaux

La fonction queryWorkspace de LogsQueryClient retourne un objet LogsQueryResult. Le type d’objet peut être LogsQuerySuccessfulResult ou LogsQueryPartialResult. Voici une hiérarchie de la réponse :

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

Par exemple, pour gérer une réponse avec des tables :

async function processTables(tablesFromResult: LogsTable[]) {
  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);
    }
  }
}

Vous trouverez un exemple complet ici.

Requête des journaux batch

L’exemple suivant illustre l’envoi de plusieurs requêtes en même temps à l’aide de l’API de requête batch. Les requêtes peuvent être représentées sous la forme d’une liste d’objets BatchQuery.

export async function main() {
  if (!monitorWorkspaceId) {
    throw new Error("MONITOR_WORKSPACE_ID must be set in the environment for this sample");
  }

  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++;
  }
}

async function processTables(tablesFromResult: LogsTable[]) {
  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);
    }
  }
}

Gérer la réponse aux requêtes par lots des journaux

La fonction queryBatch de LogsQueryClient retourne un objet LogsQueryBatchResult. LogsQueryBatchResult contient une liste d’objets avec les types possibles suivants :

LogsQueryPartialResult
LogsQuerySuccessfulResult
LogsQueryError

Voici une hiérarchie de la réponse :

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

Par exemple, le code suivant gère une réponse de requête des journaux de traitement par lots :

async function processBatchResult(result: LogsQueryBatchResult) {
  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++;
  }
}

async function processTables(tablesFromResult: LogsTable[]) {
  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);
    }
  }
}

Vous trouverez un exemple complet ici.

Scénarios de requête de journaux avancés

Définir le délai d’expiration de la requête des journaux

Certaines requêtes de journaux prennent plus de 3 minutes pour s’exécuter. Le délai d’expiration du serveur par défaut est de 3 minutes. Vous pouvez augmenter le délai d’expiration du serveur à un maximum de 10 minutes. Dans l’exemple suivant, la propriété serverTimeoutInSeconds de l’objet LogsQueryOptions est utilisée pour augmenter le délai d’expiration du serveur à 10 minutes :

// setting optional parameters
const queryLogsOptions: LogsQueryOptions = {
  // 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,
  kustoQuery,
  { duration: Durations.twentyFourHours },
  queryLogsOptions,
);

const tablesFromResult = result.tables;

Interroger plusieurs espaces de travail

La même requête de journaux d’activité peut être exécutée sur plusieurs espaces de travail log Analytique. Outre la requête Kusto, les paramètres suivants sont requis :

workspaceId - PREMIER ID d’espace de travail (principal).
additionalWorkspaces : liste d’espaces de travail, à l’exclusion de l’espace de travail fourni dans le paramètre workspaceId. Les éléments de liste du paramètre peuvent se composer des formats d’identificateur suivants :
- Noms d’espaces de travail qualifiés
- ID d’espace de travail
- ID de ressources Azure

Par exemple, la requête suivante s’exécute dans trois espaces de travail :

const queryLogsOptions: LogsQueryOptions = {
  additionalWorkspaces: ["<workspace2>", "<workspace3>"],
};

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

Pour afficher les résultats de chaque espace de travail, utilisez la colonne TenantId pour classer les résultats ou les filtrer dans la requête Kusto.

résultats de l’ordre de par tenantId

AppEvents | order by TenantId

Filtrer les résultats par tenantId

AppEvents | filter TenantId == "<workspace2>"

Vous trouverez un exemple complet ici.

Inclure des statistiques

Pour obtenir les statistiques d’exécution des requêtes de journaux, telles que la consommation du processeur et de la mémoire :

Définissez la propriété LogsQueryOptions.includeQueryStatistics sur true.
Accédez au champ statistics à l’intérieur de l’objet LogsQueryResult.

L’exemple suivant imprime l’heure d’exécution de la requête :

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.statistics && result.statistics.query && result.statistics.query.executionTime;

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

Étant donné que la structure de la charge utile statistics varie selon la requête, un type de retour Record<string, unknown> est utilisé. Il contient la réponse JSON brute. Les statistiques se trouvent dans la propriété query du JSON. Par exemple:

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

Inclure la visualisation

Pour obtenir des données de visualisation pour les requêtes de journaux à l’aide de l’opérateur de rendu :

Définissez la propriété LogsQueryOptions.includeVisualization sur true.
Accédez au champ visualization à l’intérieur de l’objet LogsQueryResult.

Par exemple:

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

Étant donné que la structure de la charge utile visualization varie selon la requête, un type de retour Record<string, unknown> est utilisé. Il contient la réponse JSON brute. Par exemple:

{
  "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
}

Requête de métriques

L’exemple suivant obtient des métriques pour un abonnement Azure Metrics Advisor. L’URI de ressource doit être celui de la ressource pour laquelle les métriques sont interrogées. Il s’agit normalement du format /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Pour rechercher l’URI de ressource :

Accédez à la page de votre ressource dans le portail Azure.
Dans le panneau Vue d’ensemble vue d’ensemble, sélectionnez le lien de vue JSON .
Dans le json obtenu, copiez la valeur de la propriété id.

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

dotenv.config();

const metricsResourceId = process.env.METRICS_RESOURCE_ID;

export async function main() {
  const tokenCredential = new DefaultAzureCredential();
  const metricsQueryClient = new MetricsQueryClient(tokenCredential);

  if (!metricsResourceId) {
    throw new Error("METRICS_RESOURCE_ID must be set in the environment for this sample");
  }

  const iterator = metricsQueryClient.listMetricDefinitions(metricsResourceId);
  let result = await iterator.next();
  let metricNames: string[] = [];
  for await (const result of iterator) {
    console.log(` metricDefinitions - ${result.id}, ${result.name}`);
    if (result.name) {
      metricNames.push(result.name);
    }
  }
  const firstMetricName = metricNames[0];
  const secondMetricName = metricNames[1];
  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: Metric[] = 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}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
  process.exit(1);
});

Dans l’exemple précédent, les résultats de métrique dans metricsResponse sont classés selon l’ordre dans lequel l’utilisateur spécifie les noms de métriques dans l’argument de tableau metricNames pour la fonction queryResource. Si l’utilisateur spécifie [firstMetricName, secondMetricName], le résultat de firstMetricName s’affiche avant le résultat de secondMetricName dans le metricResponse.

Gérer la réponse aux requêtes de métriques

La fonction queryResource métriques retourne un objet QueryMetricsResult. L’objet QueryMetricsResult contient des propriétés telles qu’une liste d’objets Metric-typés, interval, namespaceet timespan. La liste des objets Metric est accessible à l’aide de la propriété metrics. Chaque objet Metric de cette liste contient une liste d’objets TimeSeriesElement. Chaque TimeSeriesElement contient des propriétés data et metadataValues. Sous forme visuelle, la hiérarchie d’objets de la réponse ressemble à la structure suivante :

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)

Exemple de gestion de la réponse

import { DefaultAzureCredential } from "@azure/identity";
import { Durations, Metric, MetricsQueryClient } from "@azure/monitor-query";
import * as dotenv from "dotenv";
dotenv.config();

const metricsResourceId = process.env.METRICS_RESOURCE_ID;
export async function main() {
  const tokenCredential = new DefaultAzureCredential();
  const metricsQueryClient = new MetricsQueryClient(tokenCredential);

  if (!metricsResourceId) {
    throw new Error(
      "METRICS_RESOURCE_ID for an Azure Metrics Advisor subscription must be set in the environment for this sample",
    );
  }

  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: Metric[] = 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}`);
        }
      }
    }
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
  process.exit(1);
});

Vous trouverez un exemple complet ici.

Interroger des métriques pour plusieurs ressources

Pour interroger des métriques pour plusieurs ressources Azure dans une seule requête, utilisez la méthode MetricsClient.queryResources. Cette méthode :

Appelle une API différente de celle des méthodes MetricsClient.
Nécessite un point de terminaison régional lors de la création du client. Par exemple, «https://westus3.metrics.monitor.azure.com".

Chaque ressource Azure doit résider dans :

La même région que le point de terminaison spécifié lors de la création du client.
Même abonnement Azure.

En outre:

L’utilisateur doit être autorisé à lire les données de surveillance au niveau de l’abonnement Azure. Par exemple, le rôle lecteur de surveillance sur l’abonnement à interroger.
L’espace de noms de métrique contenant les métriques à interroger doit être fourni. Pour obtenir la liste des espaces de noms de métriques, consultez catégories de journaux et de métriques prises en charge par type de ressource.

let resourceIds: string[] = [
  "/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",
];
let metricsNamespace: string = "<YOUR_METRICS_NAMESPACE>";
let metricNames: string[] = ["requests", "count"];
const endpoint: string = "<YOUR_METRICS_ENDPOINT>"; //for example, https://eastus.metrics.monitor.azure.com/

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

const result: : MetricsQueryResult[] = await metricsClient.queryResources(
  resourceIds,
  metricNames,
  metricsNamespace
);

Pour obtenir un inventaire des métriques et dimensions disponibles pour chaque type de ressource Azure, consultez Métriques prises en charge avec Azure Monitor.

Dépannage

Pour diagnostiquer différents scénarios d’échec, consultez le guide de résolution des problèmes .

Étapes suivantes

Pour en savoir plus sur Azure Monitor, consultez la documentation service Azure Monitor.

Contribuant

Si vous souhaitez contribuer à cette bibliothèque, lisez le guide de contribution pour en savoir plus sur la génération et le test du code.

Les tests de ce module sont un mélange de tests en direct et unitaires, ce qui vous oblige à disposer d’une instance Azure Monitor. Pour exécuter les tests, vous devez exécuter :

rush update
rush build -t @azure/monitor-query
cd into sdk/monitor/monitor-query
Copiez le fichier sample.env dans .env
Ouvrez le fichier .env dans un éditeur et renseignez les valeurs.
npm run test.

Pour plus d’informations, consultez notre dossier tests.

Kit de développement logiciel (SDK) Microsoft Azure pour javaScript
Azure Monitor

Impressions

Partager via

Bibliothèque cliente de requête Azure Monitor pour JavaScript - version 1.3.1

Commencer

Environnements pris en charge

Conditions préalables

Installer le package

Créer le client

Configurer le client pour le cloud souverain Azure

Exécuter la requête

Concepts clés

Journaux des limites et limitation du taux de requête

Structure des données de métriques

Exemples

Requête journaux

Requête des journaux centrés sur l’espace de travail

Requête des journaux centrés sur les ressources

Gérer la réponse de requête des journaux

Requête des journaux batch

Gérer la réponse aux requêtes par lots des journaux

Scénarios de requête de journaux avancés

Définir le délai d’expiration de la requête des journaux

Interroger plusieurs espaces de travail

Inclure des statistiques

Inclure la visualisation

Requête de métriques

Gérer la réponse aux requêtes de métriques

Exemple de gestion de la réponse

Interroger des métriques pour plusieurs ressources

Dépannage

Étapes suivantes

Contribuant

Ressources supplémentaires

Partager via

Bibliothèque cliente de requête Azure Monitor pour JavaScript - version 1.3.1

Commencer

Environnements pris en charge

Conditions préalables

Installer le package

Créer le client

Configurer le client pour le cloud souverain Azure

Exécuter la requête

Concepts clés

Journaux des limites et limitation du taux de requête

Structure des données de métriques

Exemples

Requête journaux

Requête des journaux centrés sur l’espace de travail

Requête des journaux centrés sur les ressources

Gérer la réponse de requête des journaux

Requête des journaux batch

Gérer la réponse aux requêtes par lots des journaux

Scénarios de requête de journaux avancés

Définir le délai d’expiration de la requête des journaux

Interroger plusieurs espaces de travail

Inclure des statistiques

Inclure la visualisation

Requête de métriques

Gérer la réponse aux requêtes de métriques

Exemple de gestion de la réponse

Interroger des métriques pour plusieurs ressources

Dépannage

Étapes suivantes

Contribuant

Projets connexes

Ressources supplémentaires