Bibliothèque cliente de requête Azure Monitor pour JavaScript - version 1.3.0
La bibliothèque cliente de 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 : collecte et organise les données de journal et de performances à partir des ressources supervisées. Les données provenant de différentes sources, telles que les journaux d’activité de plateforme 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 regroupées dans un seul espace de travail Azure Log Analytics. Les différents types de données peuvent être analysés ensemble à l’aide du langage de requête Kusto.
- Métriques : collecte les données numériques des 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 qui décrivent un certain 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 quasi-temps réel, ce qui les rend utiles pour l’alerte et la détection rapide des problèmes.
Ressources :
- Code source
- Package (npm)
- Documentation de référence de l’API
- Documentation du service
- Exemples
- Journal des modifications
Prise en main
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.
Prérequis
- Un abonnement Azure
- Une implémentation TokenCredential, par exemple un type d’informations d'identification de la bibliothèque d’identités Azure.
- Pour interroger les journaux, vous avez besoin de l’une des opérations suivantes :
- Un espace de travail Azure Log Analytics
- Une ressource Azure de tout type (compte de stockage, Key Vault, 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 de requête Azure Monitor pour JavaScript avec npm :
npm install --save @azure/monitor-query
Création du client
Un client authentifié est nécessaire pour interroger les journaux ou les métriques. Pour l’authentification, 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 lorsque vous utilisez ce client. Ce détail est susceptible de changer à l’avenir.
exécuter la requête.
Pour obtenir des exemples de requêtes de journaux et de métriques, consultez la section Exemples .
Concepts clés
Limites et limitation du débit des requêtes des journaux
Le service Log Analytics applique une limitation lorsque le taux de requête est trop élevé. Des 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 des métriques
Chaque ensemble de valeurs de métrique est une série chronologique avec les caractéristiques suivantes :
- L’heure à laquelle la valeur a été collectée
- Ressource associée à la valeur
- Un espace de noms qui agit comme une catégorie pour la métrique
- Un nom de métrique
- La 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
- Requête Logs
- Requête journaux de traitement des lots
- Scénarios de requête de journaux avancés
- Requête de métriques
Requête Logs
LogsQueryClient
Peut être utilisé pour interroger un espace de travail Log Analytics à l’aide du langage de requête Kusto. Peut timespan.duration
être spécifié sous forme de chaîne dans un format de durée ISO 8601. Vous pouvez utiliser les Durations
constantes fournies pour certaines durées ISO 8601 couramment utilisées.
Vous pouvez interroger les journaux par ID d’espace de travail Log Analytics ou ID de ressource Azure. Le résultat est retourné sous forme de table avec une collection de lignes.
Requête de journaux centrés sur l’espace de travail
Pour interroger par ID d’espace de travail, utilisez la LogsQueryClient.queryWorkspace
méthode :
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 de journaux centrés sur les ressources
L’exemple suivant montre comment interroger les journaux directement à partir d’une ressource Azure. Ici, la queryResource
méthode 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 rechercher l’ID de ressource :
- Accédez à la page de votre ressource dans le portail Azure.
- Dans le panneau Vue d’ensemble , sélectionnez le lien Affichage JSON .
- Dans le json résultant, copiez la valeur de la
id
propriété .
/**
* @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 aux requêtes des journaux
La queryWorkspace
fonction de LogsQueryClient
retourne un LogsQueryResult
objet. 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 journaux de traitement des lots
L’exemple suivant illustre l’envoi de plusieurs requêtes en même temps à l’aide de l’API de requête par lots. 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 queryBatch
fonction de LogsQueryClient
retourne un LogsQueryBatchResult
objet. 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
L’exécution de certaines requêtes de journaux prend plus de 3 minutes. Le délai d’attente du serveur par défaut est de 3 minutes. Vous pouvez augmenter le délai d’attente du serveur jusqu’à un maximum de 10 minutes. Dans l’exemple suivant, la propriété de serverTimeoutInSeconds
l’objet LogsQueryOptions
est utilisée pour augmenter le délai d’attente 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 peut être exécutée dans plusieurs espaces de travail Log Analytics. En plus de la requête Kusto, les paramètres suivants sont requis :
workspaceId
- ID du premier espace de travail (principal).additionalWorkspaces
- Liste des espaces de travail, à l’exclusion de l’espace de travail fourni dans leworkspaceId
paramètre. 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 ressource 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 TenantId
colonne pour classer les résultats ou les filtrer dans la requête Kusto.
Classer les résultats 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 des journaux, telles que la consommation de processeur et de mémoire :
- Définissez la propriété
LogsQueryOptions.includeQueryStatistics
surtrue
. - Accédez au
statistics
champ à l’intérieur de l’objetLogsQueryResult
.
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 varie selon la statistics
requête, un Record<string, unknown>
type de retour est utilisé. Il contient la réponse JSON brute. Les statistiques se trouvent dans la query
propriété 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
surtrue
. - Accédez au
visualization
champ à l’intérieur de l’objetLogsQueryResult
.
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 varie selon la visualization
requête, un Record<string, unknown>
type de retour 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 est normalement au 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 , sélectionnez le lien Affichage JSON .
- Dans le json résultant, copiez la valeur de la
id
propriété .
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 des metricsResponse
métriques sont classés en fonction de l’ordre dans lequel l’utilisateur spécifie les noms de métriques dans l’argument metricNames
tableau de la queryResource
fonction. Si l’utilisateur spécifie [firstMetricName, secondMetricName]
, le résultat pour firstMetricName
apparaîtra avant le résultat pour secondMetricName
dans le metricResponse
.
Gérer la réponse de requête des métriques
La fonction metrics queryResource
retourne un QueryMetricsResult
objet. L’objet QueryMetricsResult
contient des propriétés telles qu’une liste d’objets Metric
-typed, interval
, namespace
et timespan
. La Metric
liste d’objets est accessible à l’aide de la metrics
propriété . Chaque Metric
objet de cette liste contient une liste d’objets TimeSeriesElement
. Chaque TimeSeriesElement
contient des data
propriétés 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 les métriques pour plusieurs ressources
Pour interroger des métriques pour plusieurs ressources Azure dans une seule requête, utilisez la MetricsClient.queryResources
méthode . Cette méthode :
- Appelle une API différente des
MetricsClient
méthodes. - 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.
- Le même abonnement Azure.
En outre :
- L’utilisateur doit être autorisé à lire les données de supervision 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 Métriques et catégories de journaux 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 du service Azure Monitor.
Contribution
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, qui vous obligent à 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 dans
sample.env
.env
- Ouvrez le
.env
fichier dans un éditeur et renseignez les valeurs. npm run test
.
Pour plus d’informations, consultez notre dossier de tests .
Projets associés
Azure SDK for JavaScript
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour