Azure Monitor Query-klientbibliotek för JavaScript – version 1.3.1

Artikel
08/02/2024

Azure Monitor Query-klientbiblioteket används för att köra skrivskyddade frågor mot Azure Monitortvå dataplattformar:

Loggar – Samlar in och organiserar logg- och prestandadata från övervakade resurser. Data från olika källor, till exempel plattformsloggar från Azure-tjänster, logg- och prestandadata från agenter för virtuella datorer och användnings- och prestandadata från appar kan konsolideras till en enda Azure Log Analytics-arbetsyta. De olika datatyperna kan analyseras tillsammans med hjälp av Kusto Query Language.
Mått – Samlar in numeriska data från övervakade resurser till en tidsseriedatabas. Mått är numeriska värden som samlas in med jämna mellanrum och beskriver någon aspekt av ett system vid en viss tidpunkt. Mått är enkla och kan stödja scenarier i nära realtid, vilket gör dem användbara för aviseringar och snabb identifiering av problem.

resurser:

Komma igång

Miljöer som stöds

LTS-versioner av Node.js
De senaste versionerna av Safari, Chrome, Microsoft Edge och Firefox

Mer information finns i vår supportprincip.

Förutsättningar

En Azure-prenumeration
En TokenCredential- implementering, till exempel en autentiseringstyp för Azure Identity-biblioteket.
För att köra frågor mot loggar behöver du något av följande:
- En Azure Log Analytics-arbetsyta
- En Azure-resurs av något slag (lagringskonto, Key Vault, Cosmos DB osv.)
För att köra frågor mot mått behöver du en Azure-resurs av något slag (lagringskonto, nyckelvalv, Cosmos DB osv.).

Installera paketet

Installera Azure Monitor Query-klientbiblioteket för JavaScript med npm:

npm install --save @azure/monitor-query

Skapa klienten

En autentiserad klient krävs för att köra frågor mot loggar eller mått. För att autentisera använder följande exempel StandardAzureCredential- från paketet @azure/identitet.

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

Konfigurera klienten för Azures nationella moln

Som standard är bibliotekets klienter konfigurerade för att använda det offentliga Azure-molnet. Om du vill använda ett nationellt moln i stället anger du rätt slutpunkts- och målgruppsvärde när du instansierar en klient. Till exempel:

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

const credential = new DefaultAzureCredential();

const logsQueryClient: LogsQueryClient = new LogsQueryClient(credential, {
  endpoint: "https://api.loganalytics.azure.cn/v1",
  audience: "https://api.loganalytics.azure.cn/.default",
});
// or
const metricsQueryClient: MetricsQueryClient = new MetricsQueryClient(credential, {
  endpoint: "https://management.chinacloudapi.cn",
  audience: "https://monitor.azure.cn/.default",
});
// or
const endPoint: string = "<YOUR_METRICS_ENDPOINT>"; //for example, https://eastus.metrics.monitor.azure.com/

const metricsClient: MetricsClient = new MetricsClient(endPoint, credential, {
  audience: "https://monitor.azure.cn/.default",
});

Obs: För närvarande använder MetricsQueryClient Azure Resource Manager-slutpunkten (ARM) för att fråga efter mått. Du behöver motsvarande hanteringsslutpunkt för ditt moln när du använder den här klienten. Den här informationen kan komma att ändras i framtiden.

Köra frågan

Exempel på loggar och måttfrågor finns i avsnittet Exempel.

Viktiga begrepp

Loggar frågefrekvensgränser och begränsning

Log Analytics-tjänsten tillämpar begränsningar när begärandefrekvensen är för hög. Gränser, till exempel det maximala antalet rader som returneras, tillämpas också på Kusto-frågorna. Mer information finns i Query API.

Datastruktur för mått

Varje uppsättning måttvärden är en tidsserie med följande egenskaper:

Den tid då värdet samlades in
Resursen som är associerad med värdet
Ett namnområde som fungerar som en kategori för måttet
Ett måttnamn
Själva värdet
Vissa mått har flera dimensioner enligt beskrivningen i flerdimensionella mått. Anpassade mått kan ha upp till 10 dimensioner.

Exempel

Logs-fråga
- fråga arbetsytecentrerade loggar
- fråga resurscentrerade loggar
- Hantera loggfrågesvar
Batch-loggar frågar
- Hantera batchfrågesvar för loggar
Frågescenarier för avancerade loggar
Metrics-fråga

Loggfråga

LogsQueryClient kan användas för att fråga en Log Analytics-arbetsyta med hjälp av Kusto Query Language. timespan.duration kan anges som en sträng i ett ISO 8601-varaktighetsformat. Du kan använda Durations konstanter som tillhandahålls för vissa vanliga ISO 8601-varaktigheter.

Du kan köra frågor mot loggar via Log Analytics-arbetsyte-ID eller Azure-resurs-ID. Resultatet returneras som en tabell med en samling rader.

Fråga om arbetsytecentrerade loggar

Om du vill fråga efter arbetsyte-ID använder du metoden LogsQueryClient.queryWorkspace:

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

Fråga om resurscentrerade loggar

I följande exempel visas hur du frågar efter loggar direkt från en Azure-resurs. Här används queryResource-metoden och ett Azure-resurs-ID skickas in. Till exempel /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Så här hittar du resurs-ID:t:

Gå till resurssidan i Azure-portalen.
På bladet Översikt väljer du länken JSON View.
I den resulterande JSON-filen kopierar du värdet för egenskapen id.

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

Hantera loggfrågesvar

Funktionen queryWorkspace för LogsQueryClient returnerar ett LogsQueryResult objekt. Objekttypen kan vara LogsQuerySuccessfulResult eller LogsQueryPartialResult. Här är en hierarki med svaret:

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

Till exempel för att hantera ett svar med tabeller:

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

Ett fullständigt exempel finns här.

Fråga om Batch-loggar

I följande exempel visas hur du skickar flera frågor samtidigt med hjälp av BATCH-fråge-API:et. Frågorna kan representeras som en lista över BatchQuery objekt.

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

Hantera batchfrågesvar för loggar

Funktionen queryBatch för LogsQueryClient returnerar ett LogsQueryBatchResult objekt. LogsQueryBatchResult innehåller en lista över objekt med följande möjliga typer:

LogsQueryPartialResult
LogsQuerySuccessfulResult
LogsQueryError

Här är en hierarki med svaret:

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

Följande kod hanterar till exempel ett frågesvar för batchloggar:

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

Ett fullständigt exempel finns här.

Frågescenarier för avancerade loggar

Ange tidsgräns för loggfrågor

Vissa loggfrågor tar längre tid än 3 minuter att köra. Standardtidsgränsen för servern är 3 minuter. Du kan öka tidsgränsen för servern till högst 10 minuter. I följande exempel används LogsQueryOptions-objektets egenskap serverTimeoutInSeconds för att öka serverns tidsgräns till 10 minuter:

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

Fråga flera arbetsytor

Samma loggfråga kan köras på flera Log Analytics-arbetsytor. Förutom Kusto-frågan krävs följande parametrar:

workspaceId – det första (primära) arbetsyte-ID:t.
additionalWorkspaces – En lista över arbetsytor, exklusive den arbetsyta som anges i parametern workspaceId. Parameterns listobjekt kan bestå av följande identifierarformat:
- Namn på kvalificerade arbetsytor
- Arbetsyte-ID:t
- Azure-resurs-ID:t

Följande fråga körs till exempel på tre arbetsytor:

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

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

Om du vill visa resultatet för varje arbetsyta använder du kolumnen TenantId för att antingen sortera resultaten eller filtrera dem i Kusto-frågan.

Orderresultat efter TenantId

AppEvents | order by TenantId

Filtrera resultat efter TenantId

AppEvents | filter TenantId == "<workspace2>"

Ett fullständigt exempel finns här.

Ta med statistik

Så här hämtar du körningsstatistik för loggar, till exempel processor- och minnesförbrukning:

Ange egenskapen LogsQueryOptions.includeQueryStatistics till true.
Öppna fältet statistics inuti objektet LogsQueryResult.

I följande exempel skrivs frågekörningstiden ut:

const monitorWorkspaceId = "<workspace_id>";
const logsQueryClient = new LogsQueryClient(new DefaultAzureCredential());
const kustoQuery = "AzureActivity | top 10 by TimeGenerated";

const result = await logsQueryClient.queryWorkspace(
  monitorWorkspaceId,
  kustoQuery,
  { duration: Durations.oneDay },
  {
    includeQueryStatistics: true,
  },
);

const executionTime =
  result.statistics && result.statistics.query && result.statistics.query.executionTime;

console.log(
  `Results for query '${kustoQuery}', execution time: ${
    executionTime == null ? "unknown" : executionTime
  }`,
);

Eftersom strukturen för statistics nyttolast varierar beroende på fråga används en Record<string, unknown> returtyp. Den innehåller det råa JSON-svaret. Statistiken finns i egenskapen query för JSON. Till exempel:

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

Inkludera visualisering

Så här hämtar du visualiseringsdata för loggfrågor med hjälp av renderingsoperatorn:

Ange egenskapen LogsQueryOptions.includeVisualization till true.
Öppna fältet visualization inuti objektet LogsQueryResult.

Till exempel:

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

Eftersom strukturen för visualization nyttolast varierar beroende på fråga används en Record<string, unknown> returtyp. Den innehåller det råa JSON-svaret. Till exempel:

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

Fråga om mått

I följande exempel hämtas mått för en Azure Metrics Advisor-prenumeration. Resurs-URI:n måste vara den resurs som måtten efterfrågas för. Det är normalt av formatet /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Så här hittar du resurs-URI:n:

Gå till resurssidan i Azure-portalen.
På bladet Översikt väljer du länken JSON View.
I den resulterande JSON-filen kopierar du värdet för egenskapen id.

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

I föregående exempel sorteras måttresultaten i metricsResponse enligt den ordning som användaren anger måttnamnen i argumentet metricNames matris för funktionen queryResource. Om användaren anger [firstMetricName, secondMetricName]visas resultatet för firstMetricName före resultatet för secondMetricName i metricResponse.

Hantera frågesvar för mått

Måtten queryResource-funktionen returnerar ett QueryMetricsResult objekt. Objektet QueryMetricsResult innehåller egenskaper som en lista över Metric-typade objekt, interval, namespaceoch timespan. Listan Metric objekt kan nås med hjälp av egenskapen metrics. Varje Metric objekt i den här listan innehåller en lista över TimeSeriesElement objekt. Varje TimeSeriesElement innehåller egenskaper för data och metadataValues. I visuell form liknar objekthierarkin för svaret följande struktur:

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)

Exempel på hanteringssvar

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

Ett fullständigt exempel finns här.

Fråga efter mått för flera resurser

Om du vill fråga efter mått för flera Azure-resurser i en enda begäran använder du metoden MetricsClient.queryResources. Den här metoden:

Anropar ett annat API än de MetricsClient metoderna.
Kräver en regional slutpunkt när klienten skapas. Till exempel "https://westus3.metrics.monitor.azure.com".

Varje Azure-resurs måste finnas i:

Samma region som slutpunkten som angavs när klienten skapades.
Samma Azure-prenumeration.

Dessutom:

Användaren måste ha behörighet att läsa övervakningsdata på Azure-prenumerationsnivå. Till exempel rollen övervakningsläsare för prenumerationen som ska frågas.
Det måttnamnområde som innehåller de mått som ska frågas måste anges. En lista över måttnamnområden finns i Mått som stöds och loggkategorier efter resurstyp.

let resourceIds: string[] = [
  "/subscriptions/0000000-0000-000-0000-000000/resourceGroups/test/providers/Microsoft.OperationalInsights/workspaces/test-logs",
  "/subscriptions/0000000-0000-000-0000-000000/resourceGroups/test/providers/Microsoft.OperationalInsights/workspaces/test-logs2",
];
let metricsNamespace: string = "<YOUR_METRICS_NAMESPACE>";
let metricNames: string[] = ["requests", "count"];
const endpoint: string = "<YOUR_METRICS_ENDPOINT>"; //for example, https://eastus.metrics.monitor.azure.com/

const credential = new DefaultAzureCredential();
const metricsClient: MetricsClient = new MetricsClient(
  endpoint,
  credential
);

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

En inventering av mått och dimensioner som är tillgängliga för varje Azure-resurstyp finns i mått som stöds med Azure Monitor.

Felsökning

Information om hur du diagnostiserar olika felscenarier finns i felsökningsguiden för .

Nästa steg

Mer information om Azure Monitor finns i dokumentationen Azure Monitor-tjänsten.

Bidragande

Om du vill bidra till det här biblioteket kan du läsa bidragsguide för att lära dig mer om hur du skapar och testar koden.

Den här modulens tester är en blandning av live- och enhetstester, som kräver att du har en Azure Monitor-instans. Om du vill köra testerna måste du köra:

rush update
rush build -t @azure/monitor-query
cd into sdk/monitor/monitor-query
Kopiera sample.env-filen till .env
Öppna filen .env i ett redigeringsprogram och fyll i värdena.
npm run test.

Mer information finns i mappen tester.

visningar

Dela via

Azure Monitor Query-klientbibliotek för JavaScript – version 1.3.1

Komma igång

Miljöer som stöds

Förutsättningar

Installera paketet

Skapa klienten

Konfigurera klienten för Azures nationella moln

Köra frågan

Viktiga begrepp

Loggar frågefrekvensgränser och begränsning

Datastruktur för mått

Exempel

Loggfråga

Fråga om arbetsytecentrerade loggar

Fråga om resurscentrerade loggar

Hantera loggfrågesvar

Fråga om Batch-loggar

Hantera batchfrågesvar för loggar

Frågescenarier för avancerade loggar

Ange tidsgräns för loggfrågor

Fråga flera arbetsytor

Ta med statistik

Inkludera visualisering

Fråga om mått

Hantera frågesvar för mått

Exempel på hanteringssvar

Fråga efter mått för flera resurser

Felsökning

Nästa steg

Bidragande

Ytterligare resurser

Dela via

Azure Monitor Query-klientbibliotek för JavaScript – version 1.3.1

Komma igång

Miljöer som stöds

Förutsättningar

Installera paketet

Skapa klienten

Konfigurera klienten för Azures nationella moln

Köra frågan

Viktiga begrepp

Loggar frågefrekvensgränser och begränsning

Datastruktur för mått

Exempel

Loggfråga

Fråga om arbetsytecentrerade loggar

Fråga om resurscentrerade loggar

Hantera loggfrågesvar

Fråga om Batch-loggar

Hantera batchfrågesvar för loggar

Frågescenarier för avancerade loggar

Ange tidsgräns för loggfrågor

Fråga flera arbetsytor

Ta med statistik

Inkludera visualisering

Fråga om mått

Hantera frågesvar för mått

Exempel på hanteringssvar

Fråga efter mått för flera resurser

Felsökning

Nästa steg

Bidragande

Relaterade projekt

Ytterligare resurser