Dela via

Inaktuell ⚠️: Det här paketet har blivit inaktuellt och är inte längre under aktiv utveckling. Migrera till följande paket:

Nya funktioner och buggfixar som inte är säkerhetsrelaterade kommer att läggas till i ersättningsbiblioteken som listas ovan.

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 samt 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

Mer information finns i vår supportprincip.

Förutsättningar

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 DefaultAzureCredential från @azure/identity paketet.

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

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

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

Använder för närvarande MetricsQueryClient ARM-slutpunkten (Azure Resource Manager) 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 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

kan LogsQueryClient användas för att fråga en Log Analytics-arbetsyta med hjälp av Kusto-frågespråk. kan timespan.duration 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 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 LogsQueryClient.queryWorkspace vill fråga efter arbetsyte-ID använder du metoden:

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

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. Till exempel /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

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

  1. Gå till resurssidan i Azure-portalen.
  2. På bladet Översikt väljer du länken JSON-vy .
  3. I den resulterande JSON-filen kopierar du värdet för egenskapen id .
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);
    }
  }
}

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:

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

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 med BatchQuery objekt.

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

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:

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

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 LogsQueryOptions används objektets egenskap för att öka serverns serverTimeoutInSeconds tidsgräns till 10 minuter:

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;

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:

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;

Om du vill visa resultaten för varje arbetsyta använder du kolumnen TenantId för att antingen ordna 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:

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

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

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

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

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

Till exempel:

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

Eftersom nyttolastens visualization struktur 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:

  1. Gå till resurssidan i Azure-portalen.
  2. På bladet Översikt väljer du länken JSON-vy .
  3. I den resulterande JSON-filen kopierar du värdet för egenskapen id .
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}`);
}

I föregående exempel sorteras måttresultaten i metricsResponse enligt den ordning i vilken användaren anger måttnamnen i metricNames matrisargumentet för queryResource funktionen. 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

Metrics-funktionen queryResource returnerar ett QueryMetricsResult objekt. Objektet QueryMetricsResult innehåller egenskaper, t.ex. en lista med Metricobjekt som -typed, interval, namespaceoch timespan. Objektlistan Metric kan nås med hjälp av egenskapen metrics . Varje Metric objekt i den här listan innehåller en lista med TimeSeriesElement objekt. Var TimeSeriesElement och en innehåller data och metadataValues egenskaper. 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 { 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}`);
      }
    }
  }
}

Ett fullständigt exempel finns här.

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

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

  • Anropar ett annat API än metoderna MetricsClient .
  • 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:

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

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.

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:

  1. pnpm install
  2. pnpm build --filter @azure/monitor-query...
  3. cd into sdk/monitor/monitor-query
  4. Kopiera filen sample.env till .env
  5. .env Öppna filen i en redigerare och fyll i värdena.
  6. npm run test.

För mer information, se vår testmapp .