Libreria client di Query di Monitoraggio di Azure per JavaScript - versione 1.2.0

Articolo
03/27/2024

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

Log : raccoglie e organizza i dati dei log e delle prestazioni dalle risorse monitorate. I dati provenienti da origini diverse, ad esempio i log della piattaforma, i servizi di Azure, i log e i dati sulle prestazioni degli agenti delle macchine virtuali, nonché i dati sull'utilizzo e sulle prestazioni delle app possono essere consolidati in un'unica area di lavoro di Azure Log Analytics. I vari tipi di dati possono essere analizzati insieme usando la 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 semplici e in grado di supportare scenari quasi in tempo reale, rendendoli utili per l'avviso e il rilevamento rapido dei problemi.

Risorse:

Guida introduttiva

Ambienti supportati

Versioni LTS di Node.js
Versioni più recenti di Safari, Chrome, Microsoft Edge e Firefox

Per altre informazioni, vedere i criteri di supporto.

Prerequisiti

Una sottoscrizione di Azure
Implementazione di TokenCredential , ad esempio un tipo di credenziali della libreria di identità di Azure.
Per eseguire query sui log, è necessario uno degli elementi seguenti:
- Un'area di lavoro di Azure Log Analytics
- Risorsa di Azure di qualsiasi tipo (account di archiviazione, Key Vault, Cosmos DB e così via)
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 @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, 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
);

Configurare il client per il cloud sovrano di Azure

Per impostazione predefinita, LogsQueryClient e MetricsQueryClient sono configurati per l'uso del cloud pubblico di Azure. Per usare invece un cloud sovrano, specificare l'argomento corretto endpoint . Ad esempio:

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

const credential = new DefaultAzureCredential();

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

// or
const metricsQueryClient = new MetricsQueryClient(credential{
  endpoint: "https://management.chinacloudapi.cn",
});

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

Esecuzione della query

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

Concetti chiave

Log limiti di frequenza di query 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 restituiti, vengono applicati anche alle query Kusto. Per altre informazioni, vedere API query.

Struttura dei dati delle metriche

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

Ora in cui è stato raccolto il valore
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 nelle metriche multidimensionali. Le metriche personalizzate possono avere fino a 10 dimensioni.

Esempio

Query sui log
Query sui log batch
- Gestire la risposta alle query batch dei log
Scenari di query di log avanzati
- Impostare il timeout delle query dei log
- Eseguire query su più aree di lavoro
Query sulle metriche

Query sui 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 usare le Durations costanti fornite per alcune durate ISO 8601 comunemente usate.

È possibile eseguire query sui log in base all'ID dell'area di lavoro o all'ID risorsa. Il risultato viene restituito come tabella con una raccolta di righe.

Query sui log incentrati sulle aree di lavoro

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

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

Query sui log incentrati 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:

Passare alla pagina della risorsa nel portale di Azure.
Nel pannello Panoramica selezionare il collegamento Visualizzazione JSON .
Nel codice JSON risultante copiare il valore della id proprietà.

/**
 * @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);
});

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 tabelle:

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

Un esempio completo è disponibile qui.

Query sui log batch

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

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

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 tipi possibili seguenti:

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 di query dei log batch:

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

Un esempio completo è disponibile qui.

Scenari di query di log avanzati

Impostare il timeout delle query dei log

Alcune query di log richiedono più di 3 minuti per l'esecuzione. Il timeout predefinito del server è di 3 minuti. È possibile aumentare il timeout del server fino a un massimo di 10 minuti. Nell'esempio seguente viene usata la LogsQueryOptions proprietà dell'oggetto per aumentare il timeout del serverTimeoutInSeconds server a 10 minuti:

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

Eseguire query su più aree di lavoro

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

workspaceId - Il primo ID dell'area di lavoro (primaria).
additionalWorkspaces - Elenco di aree di lavoro, escluse le aree di lavoro fornite nel workspaceId parametro. Gli elementi dell'elenco dei parametri possono essere costituiti dai formati di identificatore seguenti:
- Nomi di area di lavoro qualificati
- ID area di lavoro
- ID risorsa di Azure

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

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

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

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

Ordinare i risultati per TenantId

AppEvents | order by TenantId

Filtrare i risultati per TenantId

AppEvents | filter TenantId == "<workspace2>"

Un esempio completo è disponibile qui.

Includere le statistiche

Per ottenere le statistiche di esecuzione delle query dei log, ad esempio l'utilizzo della CPU e della memoria:

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

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

const workspaceId = "<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
  }`
);

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

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

Includere la visualizzazione

Per ottenere i dati di visualizzazione per le query di log usando l'operatore di rendering:

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

Ad esempio:

const workspaceId = "<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 visualization payload varia in base alla query, viene usato un Record<string, unknown> tipo restituito. Contiene la risposta JSON non elaborata. Ad 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

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

Per trovare l'URI della risorsa:

Passare alla pagina della risorsa nel portale di Azure.
Nel pannello Panoramica selezionare il collegamento Visualizzazione JSON .
Nel codice JSON risultante copiare il valore della id proprietà.

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

Nell'esempio precedente, i risultati metricsResponse delle metriche vengono ordinati in base all'ordine in cui l'utente specifica i nomi delle metriche nell'argomento 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 metriche restituisce queryResource un QueryMetricsResult oggetto. L'oggetto QueryMetricsResult contiene proprietà come un elenco di Metricoggetti tipizzati, , interval, namespacee timespan. È Metric possibile accedere all'elenco di oggetti usando la metrics proprietà . Ogni Metric oggetto in questo elenco contiene un elenco di TimeSeriesElement oggetti. Ogni TimeSeriesElement oggetto contiene data e metadataValues proprietà. In formato visivo, la gerarchia di 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 { 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);
});

Un esempio completo è disponibile qui.

Metriche di query per più risorse

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

Chiama un'API diversa dai MetricsQueryClient 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 trovarsi in:

La stessa area dell'endpoint specificata durante la creazione del client.
Stessa sottoscrizione di Azure.

Inoltre, è necessario specificare lo spazio dei nomi delle metriche contenente le metriche da eseguire. Per un elenco degli spazi dei nomi delle metriche, vedere Metriche supportate e categorie di log in base al tipo di risorsa.

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 batchEndPoint: string = "<YOUR_METRICS_ENDPOINT>"; //for example, https://eastus.metrics.monitor.azure.com/

const credential = new DefaultAzureCredential();
const metricsQueryClient: MetricsQueryClient = new MetricsQueryClient(
  batchEndPoint,
  credential
);

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

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.

Contributo

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

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

rush update
rush build -t @azure/monitor-query
cd into sdk/monitor/monitor-query
Copiare il sample.env file in .env
Aprire il .env file in un editor e compilare i valori.
npm run test.

Per altri dettagli, visualizzare la cartella test .

Impression

Libreria client di Query di Monitoraggio di Azure per JavaScript - versione 1.2.0

Guida introduttiva

Ambienti supportati

Prerequisiti

Installare il pacchetto

Creare il client

Configurare il client per il cloud sovrano di Azure

Esecuzione della query

Concetti chiave

Log limiti di frequenza di query e limitazione

Struttura dei dati delle metriche

Esempio

Query sui log

Query sui log incentrati sulle aree di lavoro

Query sui log incentrati sulle risorse

Gestire la risposta alle query dei log

Query sui log batch

Gestire la risposta alle query batch dei log

Scenari di query di log avanzati

Impostare il timeout delle query dei log

Eseguire query su più aree di lavoro

Includere le statistiche

Includere la visualizzazione

Query sulle metriche

Gestire la risposta alle query sulle metriche

Esempio di gestione della risposta

Metriche di query per più risorse

Risoluzione dei problemi

Passaggi successivi

Contributo

Commenti e suggerimenti

Risorse aggiuntive

Libreria client di Query di Monitoraggio di Azure per JavaScript - versione 1.2.0

Guida introduttiva

Ambienti supportati

Prerequisiti

Installare il pacchetto

Creare il client

Configurare il client per il cloud sovrano di Azure

Esecuzione della query

Concetti chiave

Log limiti di frequenza di query e limitazione

Struttura dei dati delle metriche

Esempio

Query sui log

Query sui log incentrati sulle aree di lavoro

Query sui log incentrati sulle risorse

Gestire la risposta alle query dei log

Query sui log batch

Gestire la risposta alle query batch dei log

Scenari di query di log avanzati

Impostare il timeout delle query dei log

Eseguire query su più aree di lavoro

Includere le statistiche

Includere la visualizzazione

Query sulle metriche

Gestire la risposta alle query sulle metriche

Esempio di gestione della risposta

Metriche di query per più risorse

Risoluzione dei problemi

Passaggi successivi

Contributo

Progetti correlati

Commenti e suggerimenti

Risorse aggiuntive