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

Artikel
03/27/2024

Azure Monitor Query-klientbiblioteket används för att köra skrivskyddade frågor mot Azure Monitors två 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-frågespråk.
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-bibliotek.
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, Key Vault, Cosmos DB osv.).

Installera paketet

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

npm install @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 DefaultAzureCredential 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 LogsQueryClient och MetricsQueryClient är konfigurerade för att använda Azure Public Cloud. Om du vill använda ett nationellt moln i stället anger du rätt endpoint argument. Exempel:

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

Obs! För närvarande MetricsQueryClient använder azure Resource Manager-slutpunkten (ARM) för att köra frågor mot mått. Du behöver motsvarande hanteringsslutpunkt för molnet när du använder den här klienten. Den här informationen kan komma att ändras i framtiden.

Kör 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 Fråge-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

Loggfråga
Fråga om Batch-loggar
- Hantera batchfrågesvar för loggar
Frågescenarier för avancerade loggar
- Ange tidsgräns för frågor i loggar
- Fråga flera arbetsytor
Måttfråga

Loggfråga

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

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

Fråga om arbetsytecentrerade loggar

Använd metoden för att fråga efter arbetsyte-ID 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. queryResource Här används 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 Portal.
På bladet Översikt väljer du länken JSON-vy .
I den resulterande JSON kopierar du värdet för id egenskapen.

/**
 * @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 svar på loggfrågor

Funktionen queryWorkspace returnerar LogsQueryClient 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

Om du till exempel vill 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 returnerar LogsQueryClient 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 frågor i loggar

Vissa loggfrågor tar längre tid än 3 minuter att köra. Standardserverns tidsgräns är 3 minuter. Du kan öka tidsgränsen för servern till högst 10 minuter. I följande exempel LogsQueryOptions används objektets egenskap för att öka serverns serverTimeoutInSeconds 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 arbetsytan 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 resultaten för varje arbetsyta använder du TenantId kolumnen 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 LogsQueryResult objektet.

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

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

Eftersom nyttolastens struktur varierar beroende på statistics fråga används en Record<string, unknown> returtyp. Den innehåller JSON-råsvaret. Statistiken finns i query JSON-egenskapen. 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 återgivningsoperatorn:

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

Exempel:

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

Eftersom nyttolastens struktur varierar beroende på visualization fråga används en Record<string, unknown> returtyp. Den innehåller JSON-råsvaret. 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
}

Måttfråga

I följande exempel hämtas mått för en Azure Metrics Advisor-prenumeration . Resurs-URI:n måste vara den resurs för vilken mått efterfrågas. 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 Portal.
På bladet Översikt väljer du länken JSON-vy .
I den resulterande JSON kopierar du värdet för id egenskapen.

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 matrisargumentet metricNamesqueryResource för funktionen. Om användaren anger [firstMetricName, secondMetricName]visas resultatet för firstMetricName före resultatet för secondMetricName i metricResponse.

Hantera svar på måttfrågor

queryResource Måttfunktionen returnerar ett QueryMetricsResult objekt. Objektet QueryMetricsResult innehåller egenskaper som en lista över Metric-typade objekt, interval, namespaceoch timespan. Objektlistan Metric kan nås med hjälp av metrics egenskapen . Varje Metric objekt i den här listan innehåller en lista över TimeSeriesElement objekt. Var TimeSeriesElement och en innehåller data och metadataValues egenskaper. I visuellt format 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å hantering av svar

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 MetricsQueryClient.queryResources metoden . Den här metoden:

Anropar ett annat API än MetricsQueryClient 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 måste det måttnamnområde som innehåller de mått som ska efterfrågas anges. En lista över måttnamnområden finns i Mått och loggkategorier som stöds 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 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
);

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.

Nästa steg

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

Bidra

Om du vill bidra till det här biblioteket kan du läsa bidragsguiden 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
sample.env Kopiera filen till.env
.env Öppna filen i en redigerare och fyll i värdena.
npm run test.

Mer information finns i vår testmapp .

Visningar

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

Komma igång

Miljöer som stöds

Förutsättningar

Installera paketet

Skapa klienten

Konfigurera klienten för Azures nationella moln

Kör 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 svar på loggfrågor

Fråga om Batch-loggar

Hantera batchfrågesvar för loggar

Frågescenarier för avancerade loggar

Ange tidsgräns för frågor i loggar

Fråga flera arbetsytor

Ta med statistik

Inkludera visualisering

Måttfråga

Hantera svar på måttfrågor

Exempel på hantering av svar

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

Felsökning

Nästa steg

Bidra

Feedback

Ytterligare resurser

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

Komma igång

Miljöer som stöds

Förutsättningar

Installera paketet

Skapa klienten

Konfigurera klienten för Azures nationella moln

Kör 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 svar på loggfrågor

Fråga om Batch-loggar

Hantera batchfrågesvar för loggar

Frågescenarier för avancerade loggar

Ange tidsgräns för frågor i loggar

Fråga flera arbetsytor

Ta med statistik

Inkludera visualisering

Måttfråga

Hantera svar på måttfrågor

Exempel på hantering av svar

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

Felsökning

Nästa steg

Bidra

Relaterade projekt

Feedback

Ytterligare resurser