Partilhar via

Preterido ⚠️: Este pacote foi preterido e não está mais em desenvolvimento ativo. Migre para os seguintes pacotes:

Novos recursos e correções de bugs não relacionados à segurança serão adicionados às bibliotecas de substituição listadas acima.

A biblioteca de cliente do Azure Monitor Query é usada para executar consultas somente leitura nas duas plataformas de dados do Azure Monitor:

  • Logs - Coleta e organiza dados de log e desempenho de recursos monitorados. Dados de diferentes fontes, como logs de plataforma de serviços do Azure, dados de log e desempenho de agentes de máquinas virtuais e dados de uso e desempenho de aplicativos, podem ser consolidados em um único espaço de trabalho do Azure Log Analytics. Os vários tipos de dados podem ser analisados em conjunto usando a Kusto Query Language.
  • Métricas - Coleta dados numéricos de recursos monitorados em um banco de dados de séries temporais. As métricas são valores numéricos que são coletados em intervalos regulares e descrevem algum aspeto de um sistema em um determinado momento. As métricas são leves e capazes de suportar cenários quase em tempo real, tornando-as úteis para alertas e deteção rápida de problemas.

Recursos:

Primeiros passos

Ambientes suportados

Para obter mais informações, consulte nossa política de suporte .

Pré-requisitos

  • Uma assinatura do Azure
  • Uma implementação de TokenCredential, como um tipo de credencial da biblioteca Azure Identity do .
  • Para consultar Logs, você precisa de uma das seguintes coisas:
  • Para consultar Métricas, você precisa de um recurso do Azure de qualquer tipo (Conta de Armazenamento, Cofre de Chaves, Cosmos DB, etc.).

Instalar o pacote

Instale a biblioteca de cliente do Azure Monitor Query para JavaScript com npm:

npm install --save @azure/monitor-query

Criar o cliente

Um cliente autenticado é necessário para consultar logs ou métricas. Para autenticar, o exemplo a seguir usa DefaultAzureCredential do pacote @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);

Configurar o cliente para a nuvem soberana do Azure

Por padrão, os clientes da biblioteca são configurados para usar a Nuvem Pública do Azure. Para usar uma nuvem soberana em vez disso, forneça o valor correto de ponto de extremidade e audiência ao instanciar um cliente. Por exemplo:

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

Observação: atualmente, MetricsQueryClient usa o ponto de extremidade do Azure Resource Manager (ARM) para consultar métricas. Você precisa do ponto de extremidade de gerenciamento correspondente para sua nuvem ao usar este cliente. Este detalhe está sujeito a alterações no futuro.

Executar a consulta

Para obter exemplos de consultas de Logs e Métricas, consulte a seção Exemplos .

Conceitos-chave

Registra limites de taxa de consulta e limitação

O serviço Log Analytics aplica limitação quando a taxa de solicitação é muito alta. Limites, como o número máximo de linhas retornadas, também são aplicados nas consultas Kusto. Para obter mais informações, consulte API de consulta.

Estrutura de dados de métricas

Cada conjunto de valores métricos é uma série temporal com as seguintes características:

  • O momento em que o valor foi recolhido
  • O recurso associado ao valor
  • Um namespace que atua como uma categoria para a métrica
  • Um nome de métrica
  • O valor em si
  • Algumas métricas têm várias dimensões, conforme descrito em métricas multidimensionais. As métricas personalizadas podem ter até 10 dimensões.

Exemplos

Consulta de logs

O LogsQueryClient pode ser usado para consultar um espaço de trabalho do Log Analytics usando a Kusto Query Language. O timespan.duration pode ser especificado como uma cadeia de caracteres em um formato de duração ISO 8601. Você pode usar as Durations constantes fornecidas para algumas durações ISO 8601 comumente usadas.

Você pode consultar logs pela ID do espaço de trabalho do Log Analytics ou pela ID do recurso do Azure. O resultado é retornado como uma tabela com uma coleção de linhas.

Consulta de logs centrada no espaço de trabalho

Para consultar por ID de espaço de trabalho, use o LogsQueryClient.queryWorkspace método:

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

Consulta de logs centrada em recursos

O exemplo a seguir demonstra como consultar logs diretamente de um recurso do Azure. Aqui, o queryResource método é usado e uma ID de recurso do Azure é passada. Por exemplo, /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Para encontrar o ID do recurso:

  1. Navegue até a página do seu recurso no portal do Azure.
  2. Na folha Visão geral , selecione o link Exibição JSON .
  3. No JSON resultante, copie o id valor da propriedade.
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);
    }
  }
}

Manipular a resposta da consulta de logs

A queryWorkspace função de LogsQueryClient retorna um LogsQueryResult objeto. O tipo de objeto pode ser LogsQuerySuccessfulResult ou LogsQueryPartialResult. Aqui está uma hierarquia da resposta:

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

Por exemplo, para manipular uma resposta com tabelas:

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

Uma amostra completa pode ser encontrada aqui.

Consulta de logs em lote

O exemplo a seguir demonstra o envio de várias consultas ao mesmo tempo usando a API de consulta em lote. As consultas podem ser representadas como uma lista de BatchQuery objetos.

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

Manipular logs de resposta de consulta em lote

A queryBatch função de LogsQueryClient retorna um LogsQueryBatchResult objeto. LogsQueryBatchResult Contém uma lista de objetos com os seguintes tipos possíveis:

  • LogsQueryPartialResult
  • LogsQuerySuccessfulResult
  • LogsQueryError

Aqui está uma hierarquia da resposta:

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

Por exemplo, o código a seguir manipula uma resposta de consulta de logs em lote:

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

Uma amostra completa pode ser encontrada aqui.

Cenários avançados de consulta de logs

Definir tempo limite de consulta de logs

Algumas consultas de logs levam mais de 3 minutos para serem executadas. O tempo limite padrão do servidor é de 3 minutos. Você pode aumentar o tempo limite do servidor para um máximo de 10 minutos. No exemplo a seguir, a LogsQueryOptions propriedade do serverTimeoutInSeconds objeto é usada para aumentar o tempo limite do servidor para 10 minutos:

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;

Consultar vários espaços de trabalho

A mesma consulta de logs pode ser executada em vários espaços de trabalho do Log Analytics. Além da consulta Kusto, os seguintes parâmetros são necessários:

  • workspaceId - O primeiro ID de espaço de trabalho (principal).
  • additionalWorkspaces - Uma lista de espaços de trabalho, excluindo o espaço de trabalho fornecido no workspaceId parâmetro. Os itens da lista do parâmetro podem consistir nos seguintes formatos de identificador:
    • Nomes de espaços de trabalho qualificados
    • IDs do espaço de trabalho
    • IDs de recursos do Azure

Por exemplo, a consulta a seguir é executada em três espaços de trabalho:

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;

Para exibir os resultados de cada espaço de trabalho, use a TenantId coluna para ordenar os resultados ou filtrá-los na consulta Kusto.

Resultados da encomenda por TenantId

AppEvents | order by TenantId

Filtrar resultados por TenantId

AppEvents | filter TenantId == "<workspace2>"

Uma amostra completa pode ser encontrada aqui.

Incluir estatísticas

Para obter estatísticas de execução de consulta de logs, como consumo de CPU e memória:

  1. Defina a propriedade LogsQueryOptions.includeQueryStatistics como true.
  2. Acesse o statistics campo dentro do LogsQueryResult objeto.

O exemplo a seguir imprime o tempo de execução da consulta:

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

Como a estrutura da carga varia de acordo com a statistics consulta, um Record<string, unknown> tipo de retorno é usado. Ele contém a resposta JSON bruta. As estatísticas são encontradas dentro da query propriedade do JSON. Por exemplo:

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

Incluir visualização

Para obter dados de visualização para consultas de logs usando o operador de renderização:

  1. Defina a propriedade LogsQueryOptions.includeVisualization como true.
  2. Acesse o visualization campo dentro do LogsQueryResult objeto.

Por exemplo:

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

Como a estrutura da carga varia de acordo com a visualization consulta, um Record<string, unknown> tipo de retorno é usado. Ele contém a resposta JSON bruta. Por exemplo:

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

Consulta de métricas

O exemplo a seguir obtém métricas para uma assinatura do Azure Metrics Advisor . O URI do recurso deve ser o do recurso para o qual as métricas estão sendo consultadas. Normalmente é do formato /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Para localizar o URI do recurso:

  1. Navegue até a página do seu recurso no portal do Azure.
  2. Na folha Visão geral , selecione o link Exibição JSON .
  3. No JSON resultante, copie o id valor da propriedade.
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}`);
}

No exemplo anterior, os resultados da métrica são metricsResponse ordenados de acordo com a ordem na qual o usuário especifica os nomes de métricas no metricNames argumento de matriz para a queryResource função. Se o usuário especificar [firstMetricName, secondMetricName], o resultado para firstMetricName aparecerá antes do resultado para secondMetricName no metricResponse.

Manipular a resposta da consulta de métricas

A função metrics queryResource retorna um QueryMetricsResult objeto. O QueryMetricsResult objeto contém propriedades como uma lista de Metricobjetos -typed, interval, namespacee timespan. A Metric lista de objetos pode ser acessada usando a metrics propriedade. Cada Metric objeto nesta lista contém uma lista de TimeSeriesElement objetos. Cada um TimeSeriesElement contém data e metadataValues propriedades. Na forma visual, a hierarquia de objetos da resposta é semelhante à seguinte estrutura:

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)

Exemplo de manipulação de resposta

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

Uma amostra completa pode ser encontrada aqui.

Métricas de consulta para vários recursos

Para consultar métricas para vários recursos do Azure em uma única solicitação, use o MetricsClient.queryResources método. Este método:

  • Chama uma API diferente dos MetricsClient métodos.
  • Requer um ponto de extremidade regional ao criar o cliente. Por exemplo, "https://westus3.metrics.monitor.azure.com".

Cada recurso do Azure deve residir em:

  • A mesma região que o ponto de extremidade especificado ao criar o cliente.
  • A mesma assinatura do Azure.

Além disso:

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

Para obter um inventário de métricas e dimensões disponíveis para cada tipo de recurso do Azure, consulte Métricas suportadas com o Azure Monitor.

Solução de problemas

Para diagnosticar vários cenários de falha, consulte o guia de solução de problemas.

Próximos passos

Para saber mais sobre o Azure Monitor, consulte a documentação do serviço Azure Monitor.

Contribuição

Se você quiser contribuir para esta biblioteca, leia o guia de contribuição para saber mais sobre como criar e testar o código.

Os testes deste módulo são uma mistura de testes ao vivo e de unidade, que exigem que você tenha uma instância do Azure Monitor. Para executar os testes, você precisará executar:

  1. pnpm install
  2. pnpm build --filter @azure/monitor-query...
  3. cd into sdk/monitor/monitor-query
  4. Copie o sample.env ficheiro para .env
  5. Abra o .env arquivo em um editor e preencha os valores.
  6. npm run test.

Para mais detalhes, consulte a nossa pasta de testes .

  • Last updated on