Azure Monitor Query ügyfélkódtár JavaScripthez – 1.2.0-s verzió

Cikk
03/27/2024

Az Azure Monitor Query ügyfélkódtárával írásvédett lekérdezéseket hajthat végre az Azure Monitor két adatplatformján:

Naplók – Napló- és teljesítményadatokat gyűjt és rendszerez a figyelt erőforrásokból. A különböző forrásokból származó adatok, például az Azure-szolgáltatások platformnaplói, a virtuálisgép-ügynökök napló- és teljesítményadatai, valamint az alkalmazások használati és teljesítményadatai egyetlen Azure Log Analytics-munkaterületbe konszolidálhatók. A különböző adattípusok együtt elemezhetők a Kusto lekérdezésnyelv használatával.
Metrikák – Numerikus adatokat gyűjt a figyelt erőforrásokból egy idősor-adatbázisba. A metrikák olyan numerikus értékek, amelyeket rendszeres időközönként gyűjtünk össze, és a rendszer bizonyos aspektusait írják le egy adott időpontban. A metrikák egyszerűek, és képesek közel valós idejű forgatókönyvek támogatására, így hasznosak a riasztásokhoz és a problémák gyors észleléséhez.

Erőforrások:

Első lépések

Támogatott környezetek

A Node.jsLTS-verziói
A Safari, a Chrome, a Microsoft Edge és a Firefox legújabb verziói

További információért tekintse meg támogatási szabályzatunkat.

Előfeltételek

Azure-előfizetés
TokenCredential implementáció, például egy Azure Identity-kódtár hitelesítő adattípusa.
A naplók lekérdezéséhez az alábbi műveletek egyikére van szüksége:
- Azure Log Analytics-munkaterület
- Bármilyen Típusú Azure-erőforrás (Tárfiók, Key Vault, Cosmos DB stb.)
A metrikák lekérdezéséhez bármilyen Azure-erőforrásra van szüksége (tárfiók, Key Vault, Cosmos DB stb.).

A csomag telepítése

Telepítse a JavaScripthez készült Azure Monitor Query ügyfélkódtárat az npm használatával:

npm install @azure/monitor-query

Az ügyfél létrehozása

A naplók vagy metrikák lekérdezéséhez hitelesített ügyfél szükséges. A hitelesítéshez az alábbi példa a defaultAzureCredential értéket használja a @azure/identitáscsomagból .

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

Ügyfél konfigurálása az Azure szuverén felhőhöz

Alapértelmezés szerint a LogsQueryClient és MetricsQueryClient az Azure Public Cloud használatára van konfigurálva. Szuverén felhő használatához adja meg a megfelelő endpoint argumentumot. Például:

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

Megjegyzés: Jelenleg MetricsQueryClient az Azure Resource Manager (ARM) végpontot használja a metrikák lekérdezéséhez. Az ügyfél használatakor szüksége van a felhőhöz tartozó felügyeleti végpontra. Ez a részlet a jövőben változhat.

Hajtsa végre a lekérdezést

Példák a Naplók és metrikák lekérdezésekre: Példák szakasz.

Fő fogalmak

Naplózza a lekérdezési sebességkorlátokat és a szabályozást

A Log Analytics szolgáltatás szabályozást alkalmaz, ha a kérések száma túl magas. A Kusto-lekérdezésekre is korlátozások vonatkoznak, például a visszaadott sorok maximális száma. További információ: Query API.

Metrikák adatstruktúrája

A metrikaértékek minden egyes készlete egy idősor, amely a következő jellemzőkkel rendelkezik:

Az érték gyűjtésének időpontja
Az értékhez társított erőforrás
A metrika kategóriájaként működő névtér
Metrikanév
Maga az érték
Egyes metrikák több dimenzióval rendelkeznek a többdimenziós metrikákban leírtak szerint. Az egyéni metrikák legfeljebb 10 dimenzióval rendelkezhetnek.

Példák

Naplók lekérdezése
Batch-naplók lekérdezése
- Naplók kötegelt lekérdezési válaszának kezelése
Speciális naplók lekérdezési forgatókönyvei
- Naplók lekérdezési időtúllépésének beállítása
- Több munkaterület lekérdezése
Metrikák lekérdezése

Naplók lekérdezése

A LogsQueryClient használatával lekérdezhet egy Log Analytics-munkaterületet a Kusto lekérdezésnyelv használatával. A timespan.duration sztringként megadható ISO 8601-es időtartamformátumban. A gyakran használt ISO 8601-időtartamokhoz megadott állandókat használhatja Durations .

A naplókat munkaterület-azonosító vagy erőforrás-azonosító alapján kérdezheti le. Az eredmény egy sorgyűjteményt tartalmazó táblázatként lesz visszaadva.

Munkaterület-központú naplók lekérdezése

A munkaterület-azonosító alapján történő lekérdezéshez használja a LogsQueryClient.queryWorkspace következő módszert:

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

Erőforrás-központú naplók lekérdezése

Az alábbi példa bemutatja, hogyan kérdezhet le naplókat közvetlenül egy Azure-erőforrásból. Itt a queryResource metódust használja a rendszer, és átad egy Azure-erőforrás-azonosítót. Például: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Az erőforrás-azonosító megkeresése:

Lépjen az erőforrás lapjára a Azure Portal.
Az Áttekintés panelen válassza a JSON-nézet hivatkozást.
Az eredményként kapott JSON-fájlban másolja ki a id tulajdonság értékét.

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

Naplók lekérdezési válaszának kezelése

A queryWorkspace függvény LogsQueryClient egy objektumot LogsQueryResult ad vissza. Az objektum típusa lehet LogsQuerySuccessfulResult vagy LogsQueryPartialResult. Íme a válasz hierarchiája:

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

Ha például táblákkal szeretné kezelni a választ:

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

A teljes minta itt található.

Batch-naplók lekérdezése

Az alábbi példa több lekérdezés egyidejű küldését mutatja be a batch query API használatával. A lekérdezések objektumlistaként BatchQuery is megjeleníthetők.

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

Naplók kötegelt lekérdezési válaszának kezelése

A queryBatch függvény LogsQueryClient egy objektumot LogsQueryBatchResult ad vissza. LogsQueryBatchResult a következő lehetséges típusokkal rendelkező objektumok listáját tartalmazza:

LogsQueryPartialResult
LogsQuerySuccessfulResult
LogsQueryError

Íme a válasz hierarchiája:

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

A következő kód például a batch logs lekérdezési választ kezeli:

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

A teljes minta itt található.

Speciális naplók lekérdezési forgatókönyvei

Naplók lekérdezési időtúllépésének beállítása

Egyes napló lekérdezések végrehajtása több mint 3 percet vesz igénybe. A kiszolgáló alapértelmezett időtúllépése 3 perc. A kiszolgáló időtúllépése legfeljebb 10 percre növelhető. Az alábbi példában az LogsQueryOptions objektum tulajdonsága serverTimeoutInSeconds 10 percre növeli a kiszolgáló időtúllépését:

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

Több munkaterület lekérdezése

Ugyanazt a napló lekérdezést több Log Analytics-munkaterületen is végrehajthatja. A Kusto-lekérdezés mellett a következő paraméterekre van szükség:

workspaceId – Az első (elsődleges) munkaterület azonosítója.
additionalWorkspaces – A munkaterületek listája, a paraméterben workspaceId megadott munkaterület kivételével. A paraméter listaelemei a következő azonosítóformátumokból állhatnak:
- Minősített munkaterületnevek
- Munkaterület-azonosítók
- Azure-erőforrásazonosítók

A következő lekérdezés például három munkaterületen fut:

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

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

Az egyes munkaterületek eredményeinek megtekintéséhez az TenantId oszlop használatával rendezze el az eredményeket, vagy szűrje őket a Kusto-lekérdezésben.

Rendelési eredmények Bérlőazonosító szerint

AppEvents | order by TenantId

Eredmények szűrése Bérlőazonosító szerint

AppEvents | filter TenantId == "<workspace2>"

A teljes minta itt található.

Statisztika belefoglalása

Naplók lekérdezés-végrehajtási statisztikáinak lekérése, például a processzor- és memóriahasználat:

Állítsa a tulajdonságot a LogsQueryOptions.includeQueryStatistics értékre true.
statistics Az objektumon belüli LogsQueryResult mező elérése.

Az alábbi példa a lekérdezés végrehajtási idejét nyomtatja ki:

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

Mivel a statistics hasznos adat szerkezete lekérdezésenként változik, a rendszer egy visszatérési típust Record<string, unknown> használ. A nyers JSON-választ tartalmazza. A statisztikák a query JSON tulajdonságában találhatók. Például:

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

Vizualizáció belefoglalása

A naplók lekérdezéseinek vizualizációs adatainak lekérése a renderelési operátorral:

Állítsa a tulajdonságot a LogsQueryOptions.includeVisualization értékre true.
visualization Az objektumon belüli LogsQueryResult mező elérése.

Például:

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

Mivel a visualization hasznos adat szerkezete lekérdezésenként változik, a rendszer egy visszatérési típust Record<string, unknown> használ. A nyers JSON-választ tartalmazza. Például:

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

Metrikák lekérdezése

Az alábbi példa beolvassa az Azure Metrics Advisor-előfizetés metrikáit . Az erőforrás URI-jának annak az erőforrásnak kell lennie, amelyhez a metrikákat lekérdezik. Általában a formátuma /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Az erőforrás URI-jának megkeresése:

Lépjen az erőforrás lapjára a Azure Portal.
Az Áttekintés panelen válassza a JSON-nézet hivatkozást.
Az eredményként kapott JSON-fájlban másolja ki a id tulajdonság értékét.

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

Az előző mintában a metrikaeredmények sorrendje metricsResponse annak a sorrendnek megfelelően van rendezve, amelyben a felhasználó a függvény tömbargumentumában megadja a metricNamesqueryResource metrikaneveket. Ha a felhasználó a értéket adja meg [firstMetricName, secondMetricName], akkor a eredménye firstMetricName a következő eredménye előtt jelenik meg: secondMetricNamemetricResponse.

Metrikák lekérdezési válaszának kezelése

A metrikák queryResource függvény egy objektumot QueryMetricsResult ad vissza. Az QueryMetricsResult objektum olyan tulajdonságokat tartalmaz, mint a -typed objektumok listája Metric, intervala , namespaceés timespana . Az Metric objektumok listája a metrics tulajdonság használatával érhető el. A lista minden Metric objektuma tartalmaz egy objektumlistát TimeSeriesElement . Mindegyik TimeSeriesElement tartalmaz data és metadataValues tulajdonságokat. Vizuális formában a válasz objektumhierarchiája a következő struktúrához hasonlít:

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)

Példa a válasz kezelésére

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

A teljes minta itt található.

Több erőforrás metrikáinak lekérdezése

Ha egyetlen kérelemben több Azure-erőforrás metrikáit szeretné lekérdezni, használja a metódust MetricsQueryClient.queryResources . Ez a módszer:

Más API-t hív meg, mint a MetricsQueryClient metódusok.
Az ügyfél létrehozásakor regionális végpontra van szükség. Például: "https://westus3.metrics.monitor.azure.com".

Minden Azure-erőforrásnak a következő helyen kell lennie:

Ugyanaz a régió, mint az ügyfél létrehozásakor megadott végpont.
Ugyanaz az Azure-előfizetés.

Emellett meg kell adni a lekérdezni kívánt metrikákat tartalmazó metrikanévteret. A metrikanévterek listáját lásd: Támogatott metrikák és naplókategóriák erőforrástípus szerint.

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

Az egyes Azure-erőforrástípusokhoz elérhető metrikák és dimenziók készletét lásd: Támogatott metrikák az Azure Monitorral.

Hibaelhárítás

A különböző hibaforgatókönyvek diagnosztizálásához tekintse meg a hibaelhárítási útmutatót.

Következő lépések

Az Azure Monitorral kapcsolatos további információkért tekintse meg az Azure Monitor szolgáltatás dokumentációját.

Közreműködés

Ha hozzá szeretne járulni ehhez a kódtárhoz, olvassa el a közreműködői útmutatót , amelyből többet is megtudhat a kód összeállításáról és teszteléséről.

A modul tesztjei élő és egységtesztek keverékei, amelyekhez Azure Monitor-példányra van szükség. A tesztek végrehajtásához a következőket kell futtatnia:

rush update
rush build -t @azure/monitor-query
cd into sdk/monitor/monitor-query
A fájl másolása a sample.env következőre: .env
Nyissa meg a .env fájlt egy szerkesztőben, és töltse ki az értékeket.
npm run test.

További részletekért tekintse meg a tesztmappánkat .

Megjelenések

Azure Monitor Query ügyfélkódtár JavaScripthez – 1.2.0-s verzió

Első lépések

Támogatott környezetek

Előfeltételek

A csomag telepítése

Az ügyfél létrehozása

Ügyfél konfigurálása az Azure szuverén felhőhöz

Hajtsa végre a lekérdezést

Fő fogalmak

Naplózza a lekérdezési sebességkorlátokat és a szabályozást

Metrikák adatstruktúrája

Példák

Naplók lekérdezése

Munkaterület-központú naplók lekérdezése

Erőforrás-központú naplók lekérdezése

Naplók lekérdezési válaszának kezelése

Batch-naplók lekérdezése

Naplók kötegelt lekérdezési válaszának kezelése

Speciális naplók lekérdezési forgatókönyvei

Naplók lekérdezési időtúllépésének beállítása

Több munkaterület lekérdezése

Statisztika belefoglalása

Vizualizáció belefoglalása

Metrikák lekérdezése

Metrikák lekérdezési válaszának kezelése

Példa a válasz kezelésére

Több erőforrás metrikáinak lekérdezése

Hibaelhárítás

Következő lépések

Közreműködés

Visszajelzés

További források

Azure Monitor Query ügyfélkódtár JavaScripthez – 1.2.0-s verzió

Első lépések

Támogatott környezetek

Előfeltételek

A csomag telepítése

Az ügyfél létrehozása

Ügyfél konfigurálása az Azure szuverén felhőhöz

Hajtsa végre a lekérdezést

Fő fogalmak

Naplózza a lekérdezési sebességkorlátokat és a szabályozást

Metrikák adatstruktúrája

Példák

Naplók lekérdezése

Munkaterület-központú naplók lekérdezése

Erőforrás-központú naplók lekérdezése

Naplók lekérdezési válaszának kezelése

Batch-naplók lekérdezése

Naplók kötegelt lekérdezési válaszának kezelése

Speciális naplók lekérdezési forgatókönyvei

Naplók lekérdezési időtúllépésének beállítása

Több munkaterület lekérdezése

Statisztika belefoglalása

Vizualizáció belefoglalása

Metrikák lekérdezése

Metrikák lekérdezési válaszának kezelése

Példa a válasz kezelésére

Több erőforrás metrikáinak lekérdezése

Hibaelhárítás

Következő lépések

Közreműködés

Kapcsolódó projektek

Visszajelzés

További források