Sdílet prostřednictvím

Zastaralé ⚠️: Tento balíček je zastaralý a již není v aktivním vývoji. Migrujte prosím na následující balíčky:

Do výše uvedených náhradních knihoven budou přidány nové funkce a opravy chyb nesouvisejících se zabezpečením.

Klientská knihovna dotazů služby Azure Monitor se používá ke spouštění dotazů jen pro čtení na dvou datových platformách služby Azure Monitor:

  • Protokoly – Shromažďuje a organizuje data protokolů a výkonu z monitorovaných zdrojů. Data z různých zdrojů, jako jsou protokoly platforem ze služeb Azure, data o protokolech a výkonu z agentů virtuálních počítačů a data o využití a výkonu z aplikací, lze konsolidovat do jednoho pracovního prostoru služby Azure Log Analytics. Různé datové typy lze analyzovat společně pomocí dotazovacího jazyka Kusto.
  • Metriky – Shromažďuje číselná data z monitorovaných prostředků do databáze časových řad. Metriky jsou číselné hodnoty, které se shromažďují v pravidelných intervalech a popisují určité aspekty systému v určitém okamžiku. Metriky jsou jednoduché a schopné podporovat scénáře téměř v reálném čase, což je užitečné pro upozorňování a rychlé zjišťování problémů.

Prostředky:

Začínáme

Podporovaná prostředí

Další informace najdete v našich zásad podpory.

Požadavky

Instalace balíčku

Nainstalujte klientskou knihovnu Azure Monitor Query pro JavaScript pomocí npm:

npm install --save @azure/monitor-query

Vytvoření klienta

K dotazování protokolů nebo metrik se vyžaduje ověřený klient. K ověření používá následující příklad DefaultAzureCredential z balíčku @azure/identity .

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

Konfigurace klienta pro suverénní cloud Azure

Ve výchozím nastavení jsou klienti knihovny nakonfigurovaní tak, aby používali veřejný cloud Azure. Pokud chcete místo toho použít suverénní cloud, při vytváření instance klienta zadejte správnou hodnotu koncového bodu a cílové skupiny. Například:

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

Poznámka: V současné době MetricsQueryClient používá k dotazování na metriky koncový bod Azure Resource Manager (ARM). Při použití tohoto klienta potřebujete odpovídající koncový bod správy pro váš cloud. Tyto podrobnosti se můžou v budoucnu změnit.

Provedení dotazu

Příklady dotazů na protokoly a metriky najdete v části Příklady .

Klíčové koncepty

Protokoluje limity rychlosti dotazů a omezování.

Služba Log Analytics používá omezování, pokud je frekvence požadavků příliš vysoká. Omezení, jako je například maximální počet vrácených řádků, se také použijí na dotazy Kusto. Další informace naleznete v tématu Rozhraní API pro dotazy.

Datová struktura metrik

Každá sada hodnot metriky je časová řada s následujícími charakteristikami:

  • Čas, kdy byla hodnota shromážděna
  • Prostředek přidružený k hodnotě
  • Obor názvů, který funguje jako kategorie pro metriku
  • Název metriky
  • Samotná hodnota
  • Některé metriky mají více dimenzí, jak je popsáno v multidimenzionálních metrikách. Vlastní metriky můžou mít až 10 dimenzí.

Příklady

Dotaz na protokoly

Dá LogsQueryClient se použít k dotazování na pracovní prostor služby Log Analytics pomocí dotazovacího jazyka Kusto. Lze jej timespan.duration zadat jako řetězec ve formátu doby trvání ISO 8601. Konstanty Durations poskytnuté pro některé běžně používané doby trvání ISO 8601 můžete použít.

Protokoly můžete dotazovat podle ID pracovního prostoru služby Log Analytics nebo ID prostředku Azure. Výsledek se vrátí jako tabulka s kolekcí řádků.

Dotaz na protokoly zaměřené na pracovní prostor

Pokud chcete zadat dotaz podle ID pracovního prostoru, použijte metodu LogsQueryClient.queryWorkspace :

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

Dotaz na protokoly zaměřené na prostředky

Následující příklad ukazuje, jak dotazovat protokoly přímo z prostředku Azure. V tomto případě se použije metoda queryResource a předá se ID prostředku Azure. Například: /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Vyhledání ID prostředku:

  1. Na webu Azure Portal přejděte na stránku vašeho prostředku.
  2. V okně Přehled vyberte odkaz Zobrazení JSON .
  3. Ve výsledném formátu JSON zkopírujte hodnotu id vlastnosti.
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);
    }
  }
}

Zpracování odpovědi dotazu na protokoly

Funkce queryWorkspace vrací LogsQueryClientLogsQueryResult objekt. Typ objektu může být LogsQuerySuccessfulResult nebo LogsQueryPartialResult. Tady je hierarchie odpovědi:

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

Pokud například chcete zpracovat odpověď s tabulkami:

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

Kompletní ukázku naleznete zde.

Dotaz na protokoly služby Batch

Následující příklad ukazuje odesílání více dotazů najednou pomocí rozhraní API dávkového dotazu. Dotazy mohou být reprezentovány BatchQuery jako seznam 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);
    }
  }
}

Zpracování odpovědi dávkového dotazu protokolů

Funkce queryBatch vrací LogsQueryClientLogsQueryBatchResult objekt. LogsQueryBatchResult obsahuje seznam objektů s následujícími možnými typy:

  • LogsQueryPartialResult
  • LogsQuerySuccessfulResult
  • LogsQueryError

Tady je hierarchie odpovědi:

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

Například následující kód zpracovává odpověď dotazu na dávkové protokoly:

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

Kompletní ukázku naleznete zde.

Scénáře dotazů upřesňujících protokolů

Nastavení časového limitu dotazu protokolů

Spuštění některých dotazů protokolů trvá déle než 3 minuty. Výchozí časový limit serveru je 3 minuty. Časový limit serveru můžete zvýšit na maximálně 10 minut. V následujícím příkladu LogsQueryOptions je vlastnost objektu serverTimeoutInSeconds použita ke zvýšení časového limitu serveru na 10 minut:

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;

Dotazování na více pracovních prostorů

Stejný dotaz na protokoly je možné spustit napříč několika pracovními prostory služby Log Analytics. Kromě dotazu Kusto jsou vyžadovány následující parametry:

  • workspaceId - ID prvního (primárního) pracovního prostoru.
  • additionalWorkspaces - Seznam pracovních prostorů s výjimkou pracovní plochy uvedené v parametru workspaceId . Položky seznamu parametrů se můžou skládat z následujících formátů identifikátorů:
    • Kvalifikované názvy pracovních prostorů
    • ID pracovního prostoru
    • ID prostředků Azure

Například následující dotaz se spustí ve třech pracovních prostorech:

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;

Pokud chcete zobrazit výsledky pro jednotlivé pracovní prostory, použijte TenantId sloupec buď k seřazení výsledků, nebo k jejich filtrování v dotazu Kusto.

Seřadit výsledky podle TenantId

AppEvents | order by TenantId

Filtrování výsledků podle TenantId

AppEvents | filter TenantId == "<workspace2>"

Kompletní ukázku naleznete zde.

Zahrnout statistiky

Pokud chcete získat statistiky spouštění dotazů protokolů, jako je využití procesoru a paměti:

  1. Nastavte vlastnost LogsQueryOptions.includeQueryStatistics na true.
  2. Získejte přístup k statistics poli uvnitř LogsQueryResult objektu.

Následující příklad vytiskne dobu provádění dotazu:

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

Protože se struktura statistics datové části liší podle dotazu, použije se návratový Record<string, unknown> typ. Obsahuje nezpracovanou odpověď JSON. Statistiky se nacházejí ve query vlastnosti JSON. Například:

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

Zahrnout vizualizaci

Získání vizualizačních dat pro dotazy na logy pomocí operátoru render:

  1. Nastavte vlastnost LogsQueryOptions.includeVisualization na true.
  2. Získejte přístup k visualization poli uvnitř LogsQueryResult objektu.

Například:

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

Protože se struktura visualization datové části liší podle dotazu, použije se návratový Record<string, unknown> typ. Obsahuje nezpracovanou odpověď JSON. Například:

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

Dotaz metrik

Následující příklad získá metriky pro předplatné Azure Metrics Advisor . Identifikátor URI prostředku musí být prostředek, pro který se dotazují metriky. Obvykle je formátu /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Vyhledání identifikátoru URI prostředku:

  1. Na webu Azure Portal přejděte na stránku vašeho prostředku.
  2. V okně Přehled vyberte odkaz Zobrazení JSON .
  3. Ve výsledném formátu JSON zkopírujte hodnotu id vlastnosti.
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}`);
}

V předchozí ukázce jsou výsledky metricsResponse metrik seřazeny podle pořadí, ve kterém uživatel zadá názvy metrik v argumentu metricNames pole pro funkci queryResource . Pokud uživatel určí [firstMetricName, secondMetricName], výsledek pro firstMetricName se zobrazí před výsledkem for secondMetricName v .metricResponse

Zpracování odpovědi dotazu na metriky

Funkce metrics queryResource vrací QueryMetricsResult objekt. Objekt QueryMetricsResult obsahuje vlastnosti, jako je seznam Metrictypovaných objektů, interval, namespacea timespan. K Metric seznamu objektů lze přistupovat pomocí metrics této vlastnosti. Každý Metric objekt v tomto seznamu obsahuje seznam TimeSeriesElement objektů. Každý TimeSeriesElement obsahuje data a metadataValues vlastnosti. Ve vizuální podobě se hierarchie objektů odpovědi podobá následující struktuře:

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říklad zpracování odpovědi

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

Kompletní ukázku naleznete zde.

Dotazování metrik pro více prostředků

Pokud chcete dotazovat metriky pro více prostředků Azure v jednom požadavku, použijte tuto MetricsClient.queryResources metodu. Tato metoda:

  • Volá jiné rozhraní API než metody MetricsClient .
  • Při vytváření klienta vyžaduje regionální koncový bod. Například "https://westus3.metrics.monitor.azure.com".

Každý prostředek Azure se musí nacházet:

  • Stejná oblast jako koncový bod zadaný při vytváření klienta.
  • Stejné předplatné Azure.

Mimoto:

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

Seznam metrik a dimenzí dostupných pro každý typ prostředku Azure najdete v tématu Podporované metriky ve službě Azure Monitor.

Řešení problémů

Chcete-li diagnostikovat různé scénáře selhání, přečtěte si průvodce odstraňováním problémů.

Další kroky

Další informace o službě Azure Monitor najdete v dokumentaci ke službě Azure Monitor.

Přispívající

Pokud chcete přispívat do této knihovny, přečtěte si průvodce přispívání a přečtěte si další informace o vytváření a testování kódu.

Testy tohoto modulu jsou kombinací živých testů a testů jednotek, které vyžadují, abyste měli instanci služby Azure Monitor. Pokud chcete testy spustit, budete muset spustit:

  1. pnpm install
  2. pnpm build --filter @azure/monitor-query...
  3. cd into sdk/monitor/monitor-query
  4. Zkopírujte sample.env soubor do složky .env
  5. Otevřete soubor v editoru .env a vyplňte hodnoty.
  6. npm run test.

Pro více informací si prohlédněte naši složku tests .

  • Last updated on