Biblioteka klienta zapytań usługi Azure Monitor dla języka JavaScript — wersja 1.3.2

Biblioteka klienta zapytań usługi Azure Monitor służy do wykonywania zapytań tylko do odczytu względem dwóch platform danych usługi Azure Monitor:

• Dzienniki — zbiera i organizuje dane dzienników i wydajności z monitorowanych zasobów. Dane z różnych źródeł, takie jak dzienniki platformy z usług platformy Azure, dane dzienników i wydajności z agentów maszyn wirtualnych oraz dane użycia i wydajności z aplikacji, można skonsolidować w jednym obszarze roboczym usługi Azure Log Analytics. Różne typy danych można analizować razem przy użyciu język zapytań Kusto.
• Metryki — zbiera dane liczbowe z monitorowanych zasobów do bazy danych szeregów czasowych. Metryki to wartości liczbowe, które są zbierane w regularnych odstępach czasu i opisują jakiś aspekt systemu w określonym czasie. Metryki są lekkie i mogą obsługiwać scenariusze niemal w czasie rzeczywistym, co ułatwia alerty i szybkie wykrywanie problemów.

Zasoby:

• Kod źródłowy
• Pakiet (npm)
• Dokumentacja referencyjna interfejsu API
• Dokumentacja serwisowa
• Próbki
• Dziennik zmian

Wprowadzenie

Obsługiwane środowiska

• Wersje LTS systemu Node.js
• Najnowsze wersje przeglądarek Safari, Chrome, Microsoft Edge i Firefox

Aby uzyskać więcej informacji, zobacz nasze zasady pomocy technicznej .

Warunki wstępne

• Subskrypcja platformy Azure
• Implementacja TokenCredential, taka jak typ poświadczeń biblioteki tożsamości platformy Azure.
• Aby wykonać zapytanie dotyczące dzienników, potrzebne są następujące elementy:
  • Obszar roboczy usługi Azure Log Analytics
  • Zasób platformy Azure dowolnego rodzaju (konto magazynu, usługa Key Vault, usługa Cosmos DB itp.)
• Do wykonywania zapytań dotyczących metryk potrzebny jest zasób platformy Azure dowolnego rodzaju (konto magazynu, usługa Key Vault, usługa Cosmos DB itp.).

Instalowanie pakietu

Zainstaluj bibliotekę klienta zapytań usługi Azure Monitor dla języka JavaScript za pomocą narzędzia npm:

npm install --save @azure/monitor-query

Tworzenie klienta

Uwierzytelniony klient jest wymagany do wykonywania zapytań dotyczących dzienników lub metryk. Aby uwierzytelnić, w poniższym przykładzie użyto elementu DefaultAzureCredential z pakietu @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);

Konfigurowanie klienta dla suwerennej chmury platformy Azure

Domyślnie klienci biblioteki są skonfigurowani do korzystania z chmury publicznej platformy Azure. Aby zamiast tego użyć suwerennej chmury, podaj prawidłową wartość punktu końcowego i odbiorców podczas tworzenia wystąpienia klienta. Na przykład:

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

Uwaga: MetricsQueryClient Obecnie używa punktu końcowego usługi Azure Resource Manager (ARM) do wykonywania zapytań dotyczących metryk. Potrzebny jest odpowiedni punkt końcowy zarządzania dla chmury podczas korzystania z tego klienta. Te szczegóły mogą ulec zmianie w przyszłości.

Wykonywanie zapytania

Aby zapoznać się z przykładami zapytań dzienników i metryk, zobacz sekcję Przykłady .

Kluczowe pojęcia

Rejestruje limity szybkości zapytań i ograniczanie przepustowości

Usługa Log Analytics stosuje ograniczanie przepustowości, gdy szybkość żądań jest zbyt wysoka. Limity, takie jak maksymalna liczba zwracanych wierszy, są również stosowane w zapytaniach Kusto. Aby uzyskać więcej informacji, zobacz Interfejs API zapytań.

Struktura danych metryk

Każdy zestaw wartości metryk jest szeregiem czasowym o następujących cechach:

• Czas zbierania wartości
• Zasób skojarzony z wartością
• Przestrzeń nazw, która działa jak kategoria dla metryki
• Nazwa metryki
• Sama wartość
• Niektóre metryki mają wiele wymiarów zgodnie z opisem w metrykach wielowymiarowych. Metryki niestandardowe mogą mieć maksymalnie 10 wymiarów.

Przykłady

• Zapytanie o dzienniki
  • Zapytanie dotyczące dzienników skoncentrowanych na obszarze roboczym
  • Zapytanie dotyczące dzienników skoncentrowanych na zasobach
  • Obsługa odpowiedzi na zapytanie dzienników
• Zapytanie dotyczące dzienników wsadowych
  • Obsługa odpowiedzi na zapytanie wsadowe dzienników
• Zaawansowane scenariusze zapytań dzienników
  • Ustawianie limitu czasu zapytania dzienników
  • Wykonywanie zapytań dotyczących wielu obszarów roboczych
  • Uwzględnij statystyki
  • Dołącz wizualizację
• Zapytanie o metryki
  • Obsługa odpowiedzi na zapytanie dotyczące metryk
  • Przykład obsługi odpowiedzi
  • Metryki zapytań dla wielu zasobów

Zapytanie dotyczące dzienników

Może LogsQueryClient służyć do wykonywania zapytań dotyczących obszaru roboczego usługi Log Analytics przy użyciu język zapytań Kusto. Można timespan.duration go określić jako ciąg w formacie czasu trwania ISO 8601. Można użyć Durations stałych przewidzianych dla niektórych powszechnie używanych czasów trwania ISO 8601.

Możesz wykonywać zapytania dotyczące dzienników według identyfikatora obszaru roboczego usługi Log Analytics lub identyfikatora zasobu platformy Azure. Wynik jest zwracany jako tabela z kolekcją wierszy.

Zapytanie dotyczące dzienników skoncentrowanych na obszarze roboczym

Aby wykonać zapytanie według identyfikatora obszaru roboczego LogsQueryClient.queryWorkspace , użyj metody:

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

Zapytanie dotyczące dzienników skoncentrowanych na zasobach

W poniższym przykładzie pokazano, jak wykonywać zapytania dotyczące dzienników bezpośrednio z zasobu platformy Azure. queryResource W tym miejscu jest używana metoda i przekazywany jest identyfikator zasobu platformy Azure. Na przykład /subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider}/{resource-type}/{resource-name}.

Aby znaleźć identyfikator zasobu:

1. Przejdź do strony zasobu w witrynie Azure Portal.
2. W bloku Przegląd wybierz link Widok JSON .
3. W wynikowym kodzie JSON skopiuj wartość id właściwości.

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

Obsługa odpowiedzi na zapytania dotyczące dzienników

Funkcja queryWorkspace of LogsQueryClient zwraca LogsQueryResult obiekt. Typem obiektu może być LogsQuerySuccessfulResult lub LogsQueryPartialResult. Oto hierarchia odpowiedzi:

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

Aby na przykład obsłużyć odpowiedź z tabelami:

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

Pełną próbkę można znaleźć tutaj.

Zapytanie dotyczące dzienników wsadowych

W poniższym przykładzie pokazano wysyłanie wielu zapytań jednocześnie przy użyciu interfejsu API zapytań wsadowych. Zapytania mogą być reprezentowane jako lista BatchQuery obiektów.

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

Obsługa odpowiedzi zapytania wsadowego dzienników

Funkcja queryBatch of LogsQueryClient zwraca LogsQueryBatchResult obiekt. LogsQueryBatchResult Zawiera listę obiektów z następującymi możliwymi typami:

• LogsQueryPartialResult
• LogsQuerySuccessfulResult
• LogsQueryError

Oto hierarchia odpowiedzi:

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

Na przykład następujący kod obsługuje odpowiedź zapytania dzienników wsadowych:

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

Pełną próbkę można znaleźć tutaj.

Zaawansowane scenariusze zapytań dzienników

Ustawianie limitu czasu zapytania dzienników

Wykonanie niektórych zapytań dzienników trwa dłużej niż 3 minuty. Domyślny limit czasu serwera wynosi 3 minuty. Limit czasu serwera można zwiększyć do maksymalnie 10 minut. W poniższym przykładzie LogsQueryOptions właściwość obiektu serverTimeoutInSeconds służy do zwiększenia limitu czasu serwera do 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;

Wykonywanie zapytań dotyczących wielu obszarów roboczych

To samo zapytanie dzienników można wykonać w wielu obszarach roboczych usługi Log Analytics. Oprócz zapytania Kusto wymagane są następujące parametry:

• workspaceId - Pierwszy (podstawowy) identyfikator obszaru roboczego.
• additionalWorkspaces - Lista obszarów roboczych, z wyłączeniem obszaru roboczego podanego w workspaceId parametrze. Elementy listy parametru mogą składać się z następujących formatów identyfikatorów:
  • Kwalifikowane nazwy obszarów roboczych
  • Identyfikatory obszarów roboczych
  • Identyfikatory zasobów platformy Azure

Na przykład następujące zapytanie jest wykonywane w trzech obszarach roboczych:

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;

Aby wyświetlić wyniki dla każdego obszaru roboczego, użyj kolumny TenantId , aby uporządkować wyniki lub przefiltrować je w zapytaniu Kusto.

Zamawianie wyników według identyfikatora TenantId

AppEvents | order by TenantId

Filtrowanie wyników według identyfikatora dzierżawy

AppEvents | filter TenantId == "<workspace2>"

Pełną próbkę można znaleźć tutaj.

Uwzględnij statystyki

Aby uzyskać statystyki wykonywania zapytań dzienników, takie jak użycie procesora CPU i pamięci:

1. Ustaw właściwość LogsQueryOptions.includeQueryStatistics na wartość true.
2. Uzyskaj dostęp do statistics pola wewnątrz obiektu LogsQueryResult .

Poniższy przykład wyświetla czas wykonywania zapytania:

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

Ponieważ struktura ładunku statistics różni się w zależności od zapytania, używany jest typ zwracany Record<string, unknown> . Zawiera on nieprzetworzoną odpowiedź JSON. Statystyki znajdują się query we właściwości JSON. Na przykład:

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

Uwzględnij wizualizację

Aby uzyskać dane wizualizacji dla zapytań dzienników przy użyciu operatora renderowania:

1. Ustaw właściwość LogsQueryOptions.includeVisualization na wartość true.
2. Uzyskaj dostęp do visualization pola wewnątrz obiektu LogsQueryResult .

Na przykład:

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

Ponieważ struktura ładunku visualization różni się w zależności od zapytania, używany jest typ zwracany Record<string, unknown> . Zawiera on nieprzetworzoną odpowiedź JSON. Na przykład:

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

Zapytanie metryk

Poniższy przykład pobiera metryki dla subskrypcji usługi Azure Metrics Advisor . Identyfikator URI zasobu musi być identyfikatorem zasobu, dla którego są wykonywane zapytania dotyczące metryk. Zwykle jest to format /subscriptions/<id>/resourceGroups/<rg-name>/providers/<source>/topics/<resource-name>.

Aby znaleźć identyfikator URI zasobu:

1. Przejdź do strony zasobu w witrynie Azure Portal.
2. W bloku Przegląd wybierz link Widok JSON .
3. W wynikowym kodzie JSON skopiuj wartość id właściwości.

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

W poprzednim przykładzie wyniki metryk są metricsResponse uporządkowane zgodnie z kolejnością, w której użytkownik określa nazwy metryk w argumencie tablicy metricNamesqueryResource dla funkcji. Jeśli użytkownik określi [firstMetricName, secondMetricName], wynik for firstMetricName pojawi się przed wynikiem dla secondMetricName w pliku .metricResponse

Obsługa odpowiedzi na zapytanie metryk

Funkcja metrics queryResource zwraca QueryMetricsResult obiekt. Obiekt QueryMetricsResult zawiera właściwości, takie jak lista Metricobiektów o typie -type, interval, namespacei timespan. Dostęp Metric do listy obiektów można uzyskać za pomocą metrics właściwości. Każdy Metric obiekt na tej liście zawiera listę TimeSeriesElement obiektów. Każdy z nich TimeSeriesElement zawiera data i metadataValues właściwości. W formie wizualizacji hierarchia obiektów odpowiedzi przypomina następującą 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)

Przykład obsługi odpowiedzi

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

Pełną próbkę można znaleźć tutaj.

Wykonywanie zapytań dotyczących metryk dla wielu zasobów

Aby wykonywać zapytania dotyczące metryk dla wielu zasobów platformy Azure w jednym żądaniu, użyj MetricsClient.queryResources metody. Ta metoda:

• Wywołuje inny interfejs API niż MetricsClient metody.
• Wymaga regionalnego punktu końcowego podczas tworzenia klienta. Na przykład "https://westus3.metrics.monitor.azure.com".

Każdy zasób platformy Azure musi znajdować się w:

• Ten sam region co punkt końcowy określony podczas tworzenia klienta.
• Ta sama subskrypcja platformy Azure.

Ponadto:

• Użytkownik musi mieć uprawnienia do odczytywania danych monitorowania na poziomie subskrypcji platformy Azure. Na przykład rola Czytelnik monitorowania w subskrypcji, która ma być odpytywana.
• Należy podać przestrzeń nazw metryki zawierającej metryki do wykonania zapytania. Aby uzyskać listę przestrzeni nazw metryk, zobacz Obsługiwane metryki i kategorie dzienników według typu zasobu.

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

Aby uzyskać spis metryk i wymiarów dostępnych dla każdego typu zasobu platformy Azure, zobacz Obsługiwane metryki w usłudze Azure Monitor.

Rozwiązywanie problemów

Aby zdiagnozować różne scenariusze awarii, zapoznaj się z przewodnikiem rozwiązywania problemów.

Następne kroki

Aby dowiedzieć się więcej na temat usługi Azure Monitor, zobacz dokumentację usługi Azure Monitor.

Przyczyniając się

Jeśli chcesz współtworzyć tę bibliotekę, przeczytaj przewodnik dotyczący współtworzenia , aby dowiedzieć się więcej na temat tworzenia i testowania kodu.

Testy tego modułu to mieszanka testów na żywo i testów jednostkowych, które wymagają posiadania wystąpienia usługi Azure Monitor. Aby wykonać testy, należy uruchomić następujące polecenie:

1. rush update
2. rush build -t @azure/monitor-query
3. cd into sdk/monitor/monitor-query
4. Skopiuj sample.env plik do .env
5. .env Otwórz plik w edytorze i uzupełnij wartości.
6. npm run test.

Aby uzyskać więcej informacji, zapoznaj się z naszym folderem testów .

Powiązane projekty

• Zestaw Microsoft Azure SDK dla języka JavaScript
• Azure Monitor