Elavult ⚠️: Ez a csomag elavult, és már nincs aktív fejlesztés alatt. Kérjük, térjen át a következő csomagokra:

• LogsQueryClient: @azure/monitor-query-logs - áttelepítési útmutató: Lekérdezési naplók áttelepítésének figyelése • npm: @azure/monitor-query-logs
• MetricsClient: @azure/monitor-query-metrics - migrálási útmutató: Lekérdezési metrikák migrálásának figyelése • npm: @azure/monitor-query-metrics
• MetricsQueryClient: Migrálás a felügyeleti kódtárba @azure/arm-monitor – útmutató: MetricsQueryClient → @azure/arm-monitor

A fent felsorolt helyettesítő könyvtárak új funkciókkal és nem biztonsági hibajavításokkal egészülnek ki.

A Azure Monitor Query ügyféloldali kódtár csak olvasható lekérdezések végrehajtására szolgál a 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ületen összevonhatók. A különböző adattípusok együtt elemezhetők a Kusto lekérdezési nyelv használatával.
• Metrikák – Numerikus adatokat gyűjt a figyelt erőforrásokból egy idősorozat-adatbázisba. A metrikák olyan numerikus értékek, amelyeket rendszeres időközönként gyűjtünk össze, és egy rendszer bizonyos aspektusát ismertetjük egy adott időpontban. A metrikák könnyűek, és képesek támogatni a közel valós idejű forgatókönyveket, így hasznosak a riasztásokhoz és a problémák gyors észleléséhez.

Erőforrások:

• forráskód
• Csomag (npm)
• API-referenciadokumentáció
• Szervizdokumentáció
• Minták
• Változások naplója

Kezdő lépések

Támogatott környezetek

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

További információ: támogatási szabályzat.

Előfeltételek

• Azure-előfizetés
• Egy TokenCredential implementáció, például egy Azure Identity Library hitelesítő adattípus.
• A naplók lekérdezéséhez a következő dolgok egyikére van szüksége:
  • Egy Azure Log Analytics-munkaterület
  • Bármilyen típusú Azure-erőforrás (Storage-fiók, Key Vault, Cosmos DB stb.)
• A metrikák lekérdezéséhez bármilyen típusú Azure-erőforrásra (Storage-fiók, Key Vault, Cosmos DB stb.) van szükség.

A csomag telepítése

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

npm install --save @azure/monitor-query

Az ügyfél létrehozása

A naplók vagy metrikák lekérdezéséhez hitelesített ügyfélre van szükség. A hitelesítéshez az alábbi példa a @azure/identity csomag DefaultAzureCredential értékét használja.

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

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

Alapértelmezés szerint a kódtár ügyfelei az Azure nyilvános felhő használatára vannak konfigurálva. Ha ehelyett szuverén felhőt szeretne használni, adja meg a megfelelő végpontot és célközönség értékét az ügyfél példányosításakor. Például:

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

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ő megfelelő felügyeleti végpontjára. Ez a részlet a jövőben változhat.

Hajtsa végre a lekérdezést

A naplók és metrikák lekérdezéseire vonatkozó példákért tekintse meg a Példák szakaszt.

Főbb fogalmak

Naplók lekérdezési sebességkorlátai és szabályozása

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

Metrikák adatszerkezete

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

• Az érték begyű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
• Metrika neve
• Maga az érték
• Egyes mutatók több dimenzióval rendelkeznek a többdimenziós metrikákban leírtak szerint. Az egyéni mutatók legfeljebb 10 dimenzióból állhatnak.

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
• Kötegelt naplók lekérdezése
  • Naplók kezelése kötegelt lekérdezési válasz
• 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
  • Statisztikák 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

Naplók lekérdezése

A LogsQueryClient Log Analytics-munkaterület lekérdezésére használható a Kusto lekérdezési nyelv használatával. Karakterláncként timespan.duration adható meg ISO 8601 időtartamú formátumban. Használhatja az Durations ISO 8601 gyakran használt időtartamokhoz megadott állandókat.

A naplókat a Log Analytics-munkaterület azonosítója vagy az Azure-erőforrás-azonosító alapján kérdezheti le. Az eredményt a rendszer sorok gyűjteményét tartalmazó táblázatként adja vissza.

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

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

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

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

Az alábbi példa bemutatja, hogyan kérdezheti le a naplókat közvetlenül egy Azure-erőforrásból. Itt a queryResource metódust használjuk, és a rendszer átadja az 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:

1. Lépjen az erőforrás oldalára a Azure Portal.
2. Az Áttekintés panelen válassza a JSON-nézet hivatkozást.
3. Az eredményül kapott JSON-ban másolja ki a id tulajdonság értékét.

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

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 A válasz hierarchiája a következő:

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

Például egy válasz táblákkal való kezeléséhez:

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

A teljes minta itt található.

Kötegelt naplók lekérdezése

Az alábbi példa több lekérdezés egyidejű küldését mutatja be a kötegelt lekérdezési API használatával. A lekérdezések objektumok listájaként BatchQuery ábrázolhatók.

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

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

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

• LogsQueryPartialResult
• LogsQuerySuccessfulResult
• LogsQueryError

A válasz hierarchiája a következő:

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 egy kötegelt naplók lekérdezési választ kezel:

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

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 3 percnél tovább tart. A kiszolgáló alapértelmezett időtúllépése 3 perc. A kiszolgáló időtúllépését legfeljebb 10 percre növelheti. A következő példában az LogsQueryOptions objektum serverTimeoutInSeconds tulajdonságával 10 percre növelheti a kiszolgáló időtúllépését:

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;

Több munkaterület lekérdezése

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

• workspaceId - Az első (elsődleges) munkaterület-azonosító.
• additionalWorkspaces - A munkaterületek listája, kivéve a workspaceId paraméterben megadott munkaterületet. 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:

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;

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

Eredmények rendelése TenantId szerint

AppEvents | order by TenantId

Eredmények szűrése TenantId szerint

AppEvents | filter TenantId == "<workspace2>"

A teljes minta itt található.

Statisztikák belefoglalása

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

1. Állítsa a LogsQueryOptions.includeQueryStatistics tulajdonságot trueértékre.
2. Nyissa meg az objektumon statistics belüli mezőtLogsQueryResult.

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

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

Mivel a statistics hasznos adatok szerkezete lekérdezésenként változik, a rendszer 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

Vizualizációs adatok lekérése naplólekérdezésekhez a render operátor használatával:

1. Állítsa a LogsQueryOptions.includeVisualization tulajdonságot trueértékre.
2. Nyissa meg az objektumon visualization belüli mezőtLogsQueryResult.

Például:

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

Mivel a visualization hasznos adatok szerkezete lekérdezésenként változik, a rendszer 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 egy Azure Metrics Advisor-előfizetés metrikáit kapja meg. Az erőforrás URI-jának annak az erőforrásnak az URI-jának kell lennie, amelyhez a metrikákat lekérdezi. Általában a formátum /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Az erőforrás URI megkeresése:

1. Lépjen az erőforrás oldalára a Azure Portal.
2. Az Áttekintés panelen válassza a JSON-nézet hivatkozást.
3. Az eredményül kapott JSON-ban másolja ki a id tulajdonság értékét.

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

Az előző példában a metrikaeredmények metricsResponse a függvény tömbargumentumában metricNames megadott queryResource sorrendben vannak rendezve. Ha a felhasználó megadja [firstMetricName, secondMetricName]a , az eredmény firstMetricNamesecondMetricNamemetricResponsea .

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

A metrics queryResource függvény egy objektumot QueryMetricsResult ad vissza. Az QueryMetricsResult objektum olyan tulajdonságokat tartalmaz, mint a -typed objektumok listája Metric, interval, namespace, és timespan. Az Metric objektumok listája a metrics tulajdonság segítségével érhető el. A listában szereplő minden Metric objektum tartalmazza az objektumok listáját TimeSeriesElement . Mindegyik TimeSeriesElement tartalmazza data és a 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 { 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}`);
      }
    }
  }
}

A teljes minta itt található.

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

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

• A metódusoktól eltérő API-t MetricsClient hív meg.
• 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.

Továbbá:

• A felhasználónak engedéllyel kell rendelkeznie a monitorozási adatok Azure-előfizetés szintjén történő olvasására. Például a lekérdezni kívánt előfizetés figyelési olvasó szerepköre .
• 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.

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

Az egyes Azure-erőforrástípusokhoz elérhető metrikák és dimenziók leltárát lásd: Támogatott metrikák a Azure Monitor.

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

További információ a Azure Monitor: Azure Monitor szolgáltatás dokumentációja.

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.

Ennek a modulnak a 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őt kell futtatnia:

1. pnpm install
2. pnpm build --filter @azure/monitor-query...
3. cd into sdk/monitor/monitor-query
4. Másolja a fájlt sample.env a .env
5. Nyissa meg a fájlt .env egy szerkesztőben, és töltse ki az értékeket.
6. npm run test.

További részletekért tekintse meg a tesztek mappát.

Kapcsolódó projektek

• JavaScripthez készült Microsoft Azure SDK
• Azure Monitor