Condividi tramite

Libreria client di query di Monitoraggio di Azure per JavaScript - versione 1.3.2

  • Articolo

La libreria client di query di Monitoraggio di Azure viene usata per eseguire query di sola lettura sulle due piattaforme dati di Monitoraggio di Azure:

  • Log : raccoglie e organizza i dati di log e le prestazioni dalle risorse monitorate. I dati provenienti da origini diverse, ad esempio i log della piattaforma dai servizi di Azure, i dati di log e prestazioni dagli agenti di macchine virtuali e i dati sull'utilizzo e le prestazioni dalle app possono essere consolidati in un'unica area di lavoro di Azure Log Analytics. I vari tipi di dati possono essere analizzati insieme usando il linguaggio di query Kusto.
  • Metriche : raccoglie i dati numerici dalle risorse monitorate in un database di serie temporali. Le metriche sono valori numerici che vengono raccolti a intervalli regolari e che descrivono un aspetto di un sistema in un determinato momento. Le metriche sono leggere e in grado di supportare scenari quasi in tempo reale, il che le rende utili per gli avvisi e il rilevamento rapido dei problemi.

Risorse:

Come iniziare

Ambienti supportati

Per altre informazioni, vedere i criteri di supporto .

Prerequisiti

  • Una sottoscrizione di Azure
  • Un'implementazione di TokenCredential, come un tipo di credenziale della libreria Azure Identity .
  • Per eseguire query sui log, è necessario uno degli elementi seguenti:
  • Per eseguire query sulle metriche, è necessaria una risorsa di Azure di qualsiasi tipo (account di archiviazione, Key Vault, Cosmos DB e così via).

Installare il pacchetto

Installare la libreria client di query di Monitoraggio di Azure per JavaScript con npm:

npm install --save @azure/monitor-query

Creare il client

Per eseguire query sui log o sulle metriche è necessario un client autenticato. Per eseguire l'autenticazione, nell'esempio seguente viene usato DefaultAzureCredential dal pacchetto @azure/identity .

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

Configurare il client per il cloud sovrano di Azure

Per impostazione predefinita, i client della libreria sono configurati per l'uso del cloud pubblico di Azure. Per usare invece un cloud sovrano, fornire il valore corretto dell'endpoint e del gruppo di destinatari durante la creazione di un'istanza di un client. Per esempio:

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",
});

Nota: attualmente MetricsQueryClient usa l'endpoint Azure Resource Manager (ARM) per l'esecuzione di query sulle metriche. Quando si usa questo client, è necessario l'endpoint di gestione corrispondente per il cloud. Questo dettaglio è soggetto a modifiche in futuro.

Esecuzione della query

Per esempi di query di log e metriche, vedere la sezione Esempi .

Concetti chiave

Limiti di frequenza delle query dei log e limitazione

Il servizio Log Analytics applica la limitazione quando la frequenza delle richieste è troppo elevata. I limiti, ad esempio il numero massimo di righe restituite, vengono applicati anche alle query Kusto. Per ulteriori informazioni, vedere API di query.

Struttura dei dati delle metriche

Ogni set di valori metrici è una serie temporale con le caratteristiche seguenti:

  • Ora in cui è stato raccolto il valore
  • La risorsa associata al valore
  • Spazio dei nomi che funge da categoria per la metrica
  • Nome della metrica
  • Valore stesso
  • Alcune metriche hanno più dimensioni, come descritto in Metriche multidimensionali. Le metriche personalizzate possono avere fino a 10 dimensioni.

Esempi

Query dei log

Può LogsQueryClient essere usato per eseguire query su un'area di lavoro Log Analytics usando il linguaggio di query Kusto. Può timespan.duration essere specificato come stringa in un formato di durata ISO 8601. È possibile utilizzare le Durations costanti fornite per alcune durate ISO 8601 di uso comune.

È possibile eseguire query sui log in base all'ID dell'area di lavoro Log Analytics o all'ID risorsa di Azure. Il risultato viene restituito come tabella con un insieme di righe.

Query dei log incentrata sull'area di lavoro

Per eseguire una query in base all'ID dell'area di lavoro, utilizzare il LogsQueryClient.queryWorkspace metodo:

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 dei log incentrata sulle risorse

Nell'esempio seguente viene illustrato come eseguire query sui log direttamente da una risorsa di Azure. In questo caso, viene usato il queryResource metodo e viene passato un ID risorsa di Azure. Ad esempio: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Per trovare l'ID risorsa:

  1. Passare alla pagina della risorsa nel portale di Azure.
  2. Nel pannello Panoramica selezionare il collegamento Visualizzazione JSON .
  3. Nel codice JSON risultante copiare il valore della id proprietà.
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);
    }
  }
}

Gestire la risposta alle query dei log

La queryWorkspace funzione di LogsQueryClient restituisce un LogsQueryResult oggetto. Il tipo di oggetto può essere LogsQuerySuccessfulResult o LogsQueryPartialResult. Ecco una gerarchia della risposta:

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

Ad esempio, per gestire una risposta con le tabelle:

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

Un esempio completo può essere trovato qui.

Query dei log batch

Nell'esempio seguente viene illustrato l'invio di più query contemporaneamente utilizzando l'API di query batch. Le query possono essere rappresentate come un elenco di BatchQuery oggetti.

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

Gestire la risposta alle query batch dei log

La queryBatch funzione di LogsQueryClient restituisce un LogsQueryBatchResult oggetto. LogsQueryBatchResult Contiene un elenco di oggetti con i seguenti tipi possibili:

  • LogsQueryPartialResult
  • LogsQuerySuccessfulResult
  • LogsQueryError

Ecco una gerarchia della risposta:

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

Ad esempio, il codice seguente gestisce una risposta alla query dei log batch:

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

Un esempio completo può essere trovato qui.

Scenari avanzati di query dei log

Impostare il timeout delle query dei log

L'esecuzione di alcune query di log richiede più di 3 minuti. Il timeout predefinito del server è di 3 minuti. È possibile aumentare il timeout del server fino a un massimo di 10 minuti. Nell'esempio seguente, la proprietà dell'oggetto LogsQueryOptionsserverTimeoutInSeconds viene utilizzata per aumentare il timeout del server a 10 minuti:

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;

Eseguire query su più aree di lavoro

La stessa query di log può essere eseguita in più aree di lavoro Log Analytics. Oltre alla query Kusto, sono necessari i parametri seguenti:

  • workspaceId - Il primo ID dell'area di lavoro (primario).
  • additionalWorkspaces - Un elenco di aree di lavoro, esclusa l'area di lavoro fornita nel workspaceId parametro. Gli elementi dell'elenco del parametro possono essere costituiti dai seguenti formati di identificatore:
    • Nomi completi dell'area di lavoro
    • ID area di lavoro
    • ID risorsa di Azure

Ad esempio, la query seguente viene eseguita in tre aree di lavoro:

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;

Per visualizzare i risultati per ogni area di lavoro, usare la TenantId colonna per ordinare i risultati o filtrarli nella query Kusto.

Risultati dell'ordine in base a TenantId

AppEvents | order by TenantId

Filtrare i risultati in base a TenantId

AppEvents | filter TenantId == "<workspace2>"

Un esempio completo può essere trovato qui.

Includi statistiche

Per ottenere le statistiche di esecuzione delle query sui log, ad esempio il consumo di CPU e memoria:

  1. Impostare la proprietà LogsQueryOptions.includeQueryStatistics su true.
  2. Accedi al statistics campo all'interno dell'oggetto LogsQueryResult .

Nell'esempio seguente viene stampato il tempo di esecuzione della query:

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}`,
);

Poiché la struttura del payload varia in base alla statistics query, viene utilizzato un Record<string, unknown> tipo restituito. Contiene la risposta JSON non elaborata. Le statistiche si trovano all'interno query della proprietà del JSON. Per esempio:

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

Includi visualizzazione

Per ottenere i dati di visualizzazione per le query di log utilizzando l'operatore render:

  1. Impostare la proprietà LogsQueryOptions.includeVisualization su true.
  2. Accedi al visualization campo all'interno dell'oggetto LogsQueryResult .

Per esempio:

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

Poiché la struttura del payload varia in base alla visualization query, viene utilizzato un Record<string, unknown> tipo restituito. Contiene la risposta JSON non elaborata. Per esempio:

{
  "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 sulle metriche

Nell'esempio seguente vengono ottenute le metriche per una sottoscrizione di Azure Metrics Advisor . L'URI della risorsa deve essere quello della risorsa per la quale vengono eseguite query sulle metriche. Normalmente è del formato /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Per trovare l'URI della risorsa:

  1. Passare alla pagina della risorsa nel portale di Azure.
  2. Nel pannello Panoramica selezionare il collegamento Visualizzazione JSON .
  3. Nel codice JSON risultante copiare il valore della id proprietà.
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}`);
}

Nell'esempio precedente, i risultati delle metriche vengono ordinati in metricsResponse base all'ordine in cui l'utente specifica i nomi delle metriche nell'argomento della metricNames matrice per la queryResource funzione. Se l'utente specifica [firstMetricName, secondMetricName], il risultato per firstMetricName verrà visualizzato prima del risultato per secondMetricName in metricResponse.

Gestire la risposta alle query sulle metriche

La funzione metrics queryResource restituisce un QueryMetricsResult oggetto. L'oggetto QueryMetricsResult contiene proprietà quali un elenco di Metricoggetti tipizzati, interval, namespace, e timespan. È possibile accedere all'elenco Metric degli oggetti utilizzando la metrics proprietà. Ogni Metric oggetto in questo elenco contiene un elenco di TimeSeriesElement oggetti. Ognuno TimeSeriesElement contiene data e metadataValues proprietà. In forma visiva, la gerarchia degli oggetti della risposta è simile alla struttura seguente:

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)

Esempio di gestione della risposta

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

Un esempio completo può essere trovato qui.

Query sulle metriche per più risorse

Per eseguire query sulle metriche per più risorse di Azure in una singola richiesta, usare il MetricsClient.queryResources metodo. Questo metodo:

  • Chiama un'API diversa rispetto ai MetricsClient metodi.
  • Richiede un endpoint a livello di area durante la creazione del client. Ad esempio, "https://westus3.metrics.monitor.azure.com".

Ogni risorsa di Azure deve risiedere in:

  • La stessa area dell'endpoint specificato durante la creazione del client.
  • La stessa sottoscrizione di Azure.

Inoltre:

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

Per un inventario delle metriche e delle dimensioni disponibili per ogni tipo di risorsa di Azure, vedere Metriche supportate con Monitoraggio di Azure.

Risoluzione dei problemi

Per diagnosticare vari scenari di errore, vedere la guida alla risoluzione dei problemi.

Passaggi successivi

Per altre informazioni su Monitoraggio di Azure, vedere la documentazione del servizio Monitoraggio di Azure.

Contribuire

Per contribuire a questa libreria, leggere la guida contribuire per altre informazioni su come compilare e testare il codice.

I test di questo modulo sono una combinazione di test live e unit test, che richiedono la presenza di un'istanza di Monitoraggio di Azure. Per eseguire i test, è necessario eseguire:

  1. rush update
  2. rush build -t @azure/monitor-query
  3. cd into sdk/monitor/monitor-query
  4. Copia il sample.env file in .env
  5. Aprire il .env file in un editor e inserire i valori.
  6. npm run test.

Per maggiori dettagli, consulta la nostra cartella dei test .