Biblioteca de clientes de Consulta do Azure Monitor para JavaScript – versão 1.2.0
A biblioteca de clientes de Consulta do Azure Monitor é 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 workspace do Log Analytics do Azure. Os vários tipos de dados podem ser analisados juntos usando o Linguagem de Consulta Kusto.
- Métricas – coleta dados numéricos de recursos monitorados em um banco de dados de série temporal. Métricas são valores numéricos que são coletados a intervalos regulares e descrevem algum aspecto de um sistema em um determinado momento. As métricas são leves e capazes de dar suporte a cenários quase em tempo real, tornando-as úteis para alertas e detecção rápida de problemas.
Recursos:
- Código-fonte
- Pacote (npm)
- Documentação de referência da API
- Documentação do serviço
- Amostras
- Log de alterações
Introdução
Ambientes compatíveis
- Versões LTS do Node.js
- Versões mais recentes do Safari, Chrome, Microsoft Edge e Firefox
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 de biblioteca de identidade do Azure.
- Para consultar logs, você precisa de uma das seguintes coisas:
- Um workspace do Azure Log Analytics
- Um recurso do Azure de qualquer tipo (Conta de Armazenamento, Key Vault, Cosmos DB etc.)
- Para consultar Métricas, você precisa de um recurso do Azure de qualquer tipo (Conta de Armazenamento, Key Vault, Cosmos DB etc.).
Instalar o pacote
Instale a biblioteca de clientes de Consulta do Azure Monitor para JavaScript com o npm:
npm install @azure/monitor-query
Crie o cliente
Um cliente autenticado é necessário para consultar Logs ou Métricas. Para autenticar, o exemplo a seguir usa DefaultAzureCredential do pacote de @azure/identidade .
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
);
Configurar o cliente para a nuvem soberana do Azure
Por padrão, LogsQueryClient
e MetricsQueryClient
são configurados para usar a Nuvem Pública do Azure. Para usar uma nuvem soberana, forneça o argumento correto endpoint
. Por exemplo:
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",
});
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 esse cliente. Esse 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 .
Principais conceitos
Limites e limitação da taxa de consulta de logs
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 de métrica é uma série temporal com as seguintes características:
- A hora em que o valor foi coletado
- O recurso associado ao valor
- Um namespace que funciona 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
- Consulta de logs do lote
- Cenários de consulta de logs avançados
- Consulta de métricas
Consulta de logs
O LogsQueryClient
pode ser usado para consultar um workspace do Log Analytics usando o Linguagem de Consulta Kusto. 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 do ISO 8601 comumente usadas.
Você pode consultar logs por ID do workspace ou ID do recurso. O resultado é retornado como uma tabela com uma coleção de linhas.
Consulta de logs centrada no workspace
Para consultar por ID do workspace, use o LogsQueryClient.queryWorkspace
método :
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));
Consulta de logs centrados 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 localizar a ID do recurso:
- Navegue até a página do recurso no portal do Azure.
- Na folha Visão geral , selecione o link Modo de Exibição JSON .
- No JSON resultante, copie o valor da
id
propriedade .
/**
* @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);
});
Lidar com 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 lidar com uma resposta com tabelas:
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);
}
}
}
Um exemplo completo pode ser encontrado aqui.
Consulta de logs do 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.
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);
}
}
}
Lidar com a resposta da consulta em lote de logs
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 de lote:
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);
}
}
}
Um exemplo completo pode ser encontrado aqui.
Cenários de consulta de logs avançados
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 objeto é usada para aumentar o tempo limite do serverTimeoutInSeconds
servidor para 10 minutos:
// 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;
Consultar vários espaços de trabalho
A mesma consulta de logs pode ser executada em vários workspaces do Log Analytics. Além da consulta Kusto, os seguintes parâmetros são necessários:
workspaceId
- A primeira ID do workspace (primário).additionalWorkspaces
– Uma lista de workspaces, excluindo o workspace fornecido noworkspaceId
parâmetro . Os itens de lista do parâmetro podem consistir nos seguintes formatos de identificador:- Nomes de workspace qualificados
- Workspace IDs
- IDs de recursos do Azure
Por exemplo, a seguinte consulta é executada em três workspaces:
const queryLogsOptions: LogsQueryOptions = {
additionalWorkspaces: ["<workspace2>", "<workspace3>"],
};
const kustoQuery = "AppEvents | limit 10";
const result = await logsQueryClient.queryWorkspace(
azureLogAnalyticsWorkspaceId,
kustoQuery,
{ duration: Durations.twentyFourHours },
queryLogsOptions
);
Para exibir os resultados de cada workspace, use a TenantId
coluna para ordenar os resultados ou filtrá-los na consulta Kusto.
Ordenar resultados por TenantId
AppEvents | order by TenantId
Filtrar resultados por TenantId
AppEvents | filter TenantId == "<workspace2>"
Um exemplo completo pode ser encontrado aqui.
Incluir estatísticas
Para obter estatísticas de execução de consulta de logs, como consumo de CPU e memória:
- Defina a propriedade
LogsQueryOptions.includeQueryStatistics
comotrue
. - Acesse o
statistics
campo dentro doLogsQueryResult
objeto .
O exemplo a seguir imprime o tempo de execução da consulta:
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
}`
);
Como a estrutura do statistics
conteúdo varia de acordo com a 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:
- Defina a propriedade
LogsQueryOptions.includeVisualization
comotrue
. - Acesse o
visualization
campo dentro doLogsQueryResult
objeto .
Por exemplo:
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);
Como a estrutura do visualization
conteúdo varia de acordo com a 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 Assistente de Métricas do Azure .
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:
- Navegue até a página do recurso no portal do Azure.
- Na folha Visão geral , selecione o link Modo de Exibição JSON .
- No JSON resultante, copie o valor da
id
propriedade .
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);
});
No exemplo anterior, os resultados da métrica em metricsResponse
são ordenados de acordo com a ordem na qual o usuário especifica os nomes de métrica no argumento de metricNames
matriz para a queryResource
função. Se o usuário especificar [firstMetricName, secondMetricName]
, o resultado de firstMetricName
aparecerá antes do resultado para secondMetricName
no metricResponse
.
Manipular a resposta da consulta de métricas
A função de métricas queryResource
retorna um QueryMetricsResult
objeto . O QueryMetricsResult
objeto contém propriedades como uma lista de Metric
objetos com tipo , interval
, namespace
e 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 TimeSeriesElement
contém data
as propriedades e metadataValues
. 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 tratamento de resposta
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);
});
Um exemplo completo pode ser encontrado 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 MetricsQueryClient.queryResources
método . Este método:
- Chama uma API diferente dos
MetricsQueryClient
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, o namespace de métrica que contém as métricas a serem consultadas deve ser fornecido. Para obter uma lista de namespaces de métrica, consulte Categorias de log e métricas com suporte por tipo de recurso.
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
);
Para obter um inventário de métricas e dimensões disponíveis para cada tipo de recurso do Azure, consulte Métricas com suporte 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óximas etapas
Para saber mais sobre o Azure Monitor, confira a documentação do serviço Azure Monitor.
Contribuição
Se você quiser contribuir com essa biblioteca, leia o guia de contribuição para saber como criar e testar o código.
Os testes deste módulo são uma combinação de testes dinâmicos e de unidade, que exigem que você tenha uma instância do Azure Monitor. Para executar os testes, você precisará executar:
rush update
rush build -t @azure/monitor-query
cd into sdk/monitor/monitor-query
- Copiar o
sample.env
arquivo para.env
- Abra o
.env
arquivo em um editor e preencha os valores. npm run test
.
Para obter mais detalhes, veja nossa pasta de testes .
Projetos relacionados
Azure SDK for JavaScript
Comentários
https://aka.ms/ContentUserFeedback.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulteEnviar e exibir comentários de