Azure Event Hubs biblioteka klienta dla JavaScript - wersja 6.0.3

Azure Event Hubs to wysoce skalowalna usługa publik-subskrybacja, która może pobierać miliony zdarzeń na sekundę i przesyłać je do wielu konsumentów. Umożliwia to przetwarzanie i analizowanie ogromnych ilości danych generowanych przez połączone urządzenia i aplikacje. Jeśli chcesz dowiedzieć się więcej o Azure Event Hubs, możesz przejrzeć recenzję: Czym jest Event Hubs?

Biblioteka klienta Azure Event Hub pozwala wysyłać i odbierać zdarzenia w aplikacji Node.js.

Kluczowe linki:

• Kod źródłowy
• Pakiet (npm)
• Dokumentacja referencyjna interfejsu API
• dokumentacja produktu
• Próbki

UWAGA: Jeśli używasz wersji 2.1.0 lub niższej i chcesz przejść do najnowszej wersji tego pakietu, zapoznaj się z naszym przewodnikiem migracji, aby przejść z EventHubs V2 na EventHubs V5

Przykłady wersji 2 i dokumentacja są nadal dostępne tutaj:

Kod źródłowy dla v2.1.0 | Pakiet dla v2.1.0 (npm) | Przykłady dla wersji 2.1.0

Wprowadzenie

Instalowanie pakietu

Zainstaluj bibliotekę klienta Azure Event Hubs za pomocą npm

npm install @azure/event-hubs

Obecnie obsługiwane środowiska

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

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

Wymagania wstępne

• Subskrypcja platformy Azure
• Przestrzeń nazw Event Hubs

Configure TypeScript

Użytkownicy TypeScript muszą mieć zainstalowane definicje typów węzłów:

npm install @types/node

Musisz też włączyć compilerOptions.allowSyntheticDefaultImports swoje tsconfig.json. Zwróć uwagę, że jeśli masz włączone compilerOptions.esModuleInterop, domyślnie allowSyntheticDefaultImports jest włączone. Więcej informacji można znaleźć w podręczniku opcji kompilatora TypeScript .

Pakiet JavaScript

Aby użyć tej biblioteki klienta w przeglądarce, najpierw należy użyć pakietu. Aby uzyskać szczegółowe informacje o tym, jak to zrobić, zapoznaj się z naszą dokumentacją dotyczącą tworzenia pakietów .

Oprócz opisanych tam funkcji, biblioteka ta wymaga dodatkowych wypełnień poligonów dla następujących modułów core NodeJS, aby działać poprawnie w przeglądarkach:

• buffer
• os
• path
• process

Łączenie z Webpackiem

Jeśli używasz Webpack v5, możesz zainstalować następujące zależności deweloperskie

• npm install --save-dev os-browserify path-browserify

Następnie dodaj do swojego webpack.config.js

 const path = require("path");
+const webpack = require("webpack");

 module.exports = {
   entry: "./src/index.ts",
@@ -12,8 +13,21 @@ module.exports = {
       },
     ],
   },
+  plugins: [
+    new webpack.ProvidePlugin({
+      process: "process/browser",
+    }),
+    new webpack.ProvidePlugin({
+      Buffer: ["buffer", "Buffer"],
+    }),
+  ],
   resolve: {
     extensions: [".ts", ".js"],
+    fallback: {
+      buffer: require.resolve("buffer/"),
+      os: require.resolve("os-browserify"),
+      path: require.resolve("path-browserify"),
+    },
   },

Łączenie z Rollupem

Jeśli używasz Rollup bundler, zainstaluj następujące zależności deweloperskie

• npm install --save-dev @rollup/plugin-commonjs @rollup/plugin-inject @rollup/plugin-node-resolve

Następnie uwzględnij w swoim rollup.config.js

+import nodeResolve from "@rollup/plugin-node-resolve";
+import cjs from "@rollup/plugin-commonjs";
+import shim from "rollup-plugin-shim";
+import inject from "@rollup/plugin-inject";

export default {
  // other configs
  plugins: [
+    shim({
+      fs: `export default {}`,
+      net: `export default {}`,
+      tls: `export default {}`,
+      path: `export default {}`,
+      dns: `export function resolve() { }`,
+    }),
+    nodeResolve({
+      mainFields: ["module", "browser"],
+      preferBuiltins: false,
+    }),
+    cjs(),
+    inject({
+      modules: {
+        Buffer: ["buffer", "Buffer"],
+        process: "process",
+      },
+      exclude: ["./**/package.json"],
+    }),
  ]
};

Prosimy o zapoznanie się z dokumentacją swojego ulubionego bundlera, aby uzyskać więcej informacji na temat korzystania z polyfillów.

Obsługa React Native

Podobnie jak przeglądarki, React Native nie obsługuje niektórych API JavaScript używanych przez tę bibliotekę SDK, więc musisz zapewnić dla nich polyfilly. Więcej szczegółów znajdziesz w przykładzie Messaging React Native z Expo.

Uwierzytelnianie klienta

Interakcja z Event Hubs zaczyna się od instancji klasy EventHubConsumerClient lub instancji klasy EventHubProducerClient . Istnieją przeciążenia konstruktorów wspierające różne sposoby instancjonowania tych klas, jak pokazano poniżej:

Użyj ciągu połączeń dla przestrzeni nazw Event Hubs

Jeden z przeciążeń konstruktora przyjmuje ciąg połączeń o nazwie formy Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; i jednostki do instancji Event Hub. Możesz utworzyć grupę konsumencką i pobrać ciąg połączeń oraz nazwę podmiotu z portalu Azure.

import { EventHubProducerClient, EventHubConsumerClient } from "@azure/event-hubs";

const producerClient = new EventHubProducerClient("my-connection-string", "my-event-hub");
const consumerClient = new EventHubConsumerClient(
  "my-consumer-group",
  "my-connection-string",
  "my-event-hub",
);

Użyj stringu połączenia do polityki na Event Hub

Kolejne przeciążenie konstruktora przyjmuje ciąg połączeń odpowiadający polityce współdzielonego dostępu, którą zdefiniowałeś bezpośrednio na instancji Event Hub (a nie w przestrzeni nazw Event Hubs). Ten ciąg połączeń będzie miał postać Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name. Kluczową różnicą w formacie ciągu połączeń względem poprzedniego przeciążenia konstruktora jest .;EntityPath=my-event-hub-name

import { EventHubProducerClient, EventHubConsumerClient } from "@azure/event-hubs";

const producerClient = new EventHubProducerClient("my-connection-string-with-entity-path");
const consumerClient = new EventHubConsumerClient(
  "my-consumer-group",
  "my-connection-string-with-entity-path",
);

Użyj przestrzeni nazw Event Hubs i Azure Identity

To przeciążenie konstruktorów przyjmuje nazwę hosta oraz nazwę podmiotu Twojego Event Huba oraz dane uwierzytelniające implementujące interfejs TokenCredential. Pozwala to uwierzytelnić się za pomocą principalu Azure Active Directory. Implementacje tego TokenCredential interfejsu są dostępne w pakiecie @azure/identity . Nazwa hosta to format <yournamespace>.servicebus.windows.net. Podczas korzystania z Azure Active Directory, Twój partner musi mieć przypisaną rolę umożliwiającą dostęp do Event Hubów, na przykład rolę właściciela danych Azure Event Hubs. Aby uzyskać więcej informacji na temat korzystania z autoryzacji Azure Active Directory z Event Hubs, zapoznaj się z powiązaną dokumentacją.

import { DefaultAzureCredential } from "@azure/identity";
import { EventHubProducerClient, EventHubConsumerClient } from "@azure/event-hubs";

const credential = new DefaultAzureCredential();
const producerClient = new EventHubProducerClient("my-host-name", "my-event-hub", credential);
const consumerClient = new EventHubConsumerClient(
  "my-consumer-group",
  "my-host-name",
  "my-event-hub",
  credential,
);

Najważniejsze pojęcia

• Producent Event Hub to źródło danych telemetrycznych, informacji diagnostycznych, dzienników użytkowania lub innych danych logowych, będących częścią rozwiązania urządzenia wbudowanego, aplikacji mobilnej, tytułu gry działającej na konsoli lub innym urządzeniu, jakiegoś rozwiązania biznesowego opartego na kliencie lub serwerze albo strony internetowej.

• Konsument Event Hub pobiera takie informacje z Event Hub i przetwarza je. Przetwarzanie może obejmować agregację, złożone obliczenia i filtrowanie. Przetwarzanie może również obejmować dystrybucję lub przechowywanie informacji w surowej lub przekształconej formie. Konsumenci Event Hub to często solidne i wysokoskalowe elementy infrastruktury platformowej z wbudowanymi funkcjami analitycznymi, takie jak Azure Stream Analytics, Apache Spark czy Apache Storm.

• Podział to uporządkowana sekwencja zdarzeń przechowywana w Event Hub. Podziały są środkiem organizacji danych związanym z równoległością wymaganą przez konsumentów zdarzeń. Azure Event Hubs umożliwia przesyłanie wiadomości przez podzielony wzór konsumencki, w którym każdy konsument odczytuje tylko określony podzbiór, czyli partycję, strumienia wiadomości. Gdy pojawiają się nowsze wydarzenia, są one dodawane na końcu tej sekwencji. Liczba partycji jest określana w momencie tworzenia Event Huba i nie może być zmieniona.

• Grupa konsumencka to widok całego Event Hub. Grupy konsumenckie umożliwiają wielu aplikacjom konsumującym oddzielny widok strumienia zdarzeń oraz samodzielne odczytywanie strumienia we własnym tempie i z własnej pozycji. Na jednej partycji na grupę konsumencką może być maksymalnie 5 jednoczesnych czytników; zaleca się jednak, aby dla pary partycji i grupy konsumenckiej istniał tylko jeden aktywny konsument. Każdy aktywny czytelnik otrzymuje wszystkie zdarzenia ze swojego podziału; Jeśli na tej samej partycji znajduje się wiele czytników, otrzymają one zduplikowane zdarzenia.

Więcej koncepcji i głębszą dyskusję znajdziesz w odpowiedzi: Funkcje Event Hubs

Wytyczne dotyczące powtórek prób

I EventHubConsumerClient akceptujeEventHubProducerClient, options gdzie możesz ustawić, retryOptions co pozwala dostosować sposób, w jaki SDK obsługuje błędy przejściowe. Przykładami błędów przejściowych są tymczasowe problemy sieciowe lub usługowe.

Ponowne próby przy konsumpcji zdarzeń

Jeśli podczas odbierania zdarzeń przez SDK wystąpi przejściowy błąd (np. tymczasowy problem sieciowy), spróbuje ponownie odebrać zdarzenia na podstawie opcji powtórki przekazanych do .EventHubConsumerClient Jeśli maksymalna liczba prób ponownej próby zostanie wyczerpana, processError funkcja zostanie wywołana.

Możesz użyć ustawień powtórki, aby kontrolować, jak szybko jesteś informowany o tymczasowych problemach, takich jak problem z połączeniem sieciowym. Na przykład, jeśli musisz od razu wiedzieć, kiedy pojawi się problem sieciowy, możesz obniżyć wartości dla maxRetries i retryDelayInMs.

Po wykonaniu processError funkcji klient nadal otrzymywał zdarzenia z partycji, o ile błąd był możliwy do powtórzenia. W przeciwnym razie klient wywołuje funkcję dostarczoną processClose przez użytkownika. Funkcja ta jest również wywoływana, gdy zatrzymujesz subskrypcję lub gdy klient przestaje odczytywać zdarzenia z bieżącej partycji, ponieważ zostaną one wykryte przez inną instancję Twojej aplikacji w ramach równoważenia obciążenia.

Funkcja ta processClose umożliwia aktualizację punktów kontrolnych w razie potrzeby. Po uruchomieniu processClose, klient (lub w przypadku równoważenia obciążenia, klient z innej instancji Twojej aplikacji) wywoła funkcję dostarczoną processInitialize przez użytkownika, aby wznowić odczyt zdarzeń z ostatnio zaktualizowanego punktu kontrolnego dla tej samej partycji.

Jeśli chcesz przestać próbować czytać wydarzenia, musisz skorzystać close() z powrotu subscriptionsubscribe przez ten system.

Przykłady

Poniższe sekcje zawierają fragmenty kodu obejmujące niektóre z typowych zadań korzystających z Azure Event Hubs

• Sprawdź centrum zdarzeń
• Publikuj wydarzenia w Event Hub
• Konsumuj wydarzenia z Event Hub
• Korzystaj z EventHubConsumerClient do współpracy z IotHub

Sprawdź centrum zdarzeń

Wiele operacji Event Hub odbywa się w ramach konkretnej partycji. Ponieważ partycje należą do Event Hub, ich nazwy są przypisywane w momencie tworzenia. Aby zrozumieć, jakie partycje są dostępne, zapytujesz Event Hub za pomocą jednego z dwóch dostępnych klientów: EventHubProducerClient lub EventHubConsumerClient

W poniższym przykładzie używamy .EventHubProducerClient

import { EventHubProducerClient } from "@azure/event-hubs";

const client = new EventHubProducerClient("connectionString", "eventHubName");

const partitionIds = await client.getPartitionIds();

await client.close();

Publikuj wydarzenia w Event Hub

Aby opublikować wydarzenia, musisz stworzyć .EventHubProducerClient Poniższy przykład pokazuje jeden ze sposobów tworzenia klienta, ale zobacz sekcję Authenticate the client, aby dowiedzieć się innych sposobów instancji klienta.

Możesz publikować zdarzenia na konkretnej partycji lub pozwolić usłudze Event Hubs zdecydować, na które partycje mają być publikowane. Zaleca się stosowanie automatycznego routingu, gdy publikowanie zdarzeń musi być bardzo dostępne lub gdy dane zdarzeń powinny być równomiernie rozdzielone między partycje. W poniższym przykładzie wykorzystamy automatyczne trasowanie.

• Utwórz EventDataBatch obiekt za pomocą createBatch
• Dodaj zdarzenia do partii za pomocą metody tryAdd (tryAdd ). Możesz to robić do momentu osiągnięcia maksymalnego limitu wielkości partii lub do momentu, gdy skończysz dodawać liczbę wybranych zdarzeń, w zależności od tego, co nastąpi wcześniej. Ta metoda zwracałaby false się, aby wskazać, że nie można dodać więcej zdarzeń do partii z powodu osiągnięcia maksymalnego rozmiaru partii.
• Wyślij partię zdarzeń za pomocą metody sendBatch .

W poniższym przykładzie próbujemy wysłać 10 zdarzeń do Azure Event Hubs.

import { EventHubProducerClient } from "@azure/event-hubs";

const producerClient = new EventHubProducerClient("connectionString", "eventHubName");

const eventDataBatch = await producerClient.createBatch();
let numberOfEventsToSend = 10;

while (numberOfEventsToSend > 0) {
  const wasAdded = eventDataBatch.tryAdd({ body: "my-event-body" });
  if (!wasAdded) {
    break;
  }
  numberOfEventsToSend--;
}

await producerClient.sendBatch(eventDataBatch);
await producerClient.close();

Istnieją opcje, które możesz przekazać na różnych etapach, aby kontrolować proces wysyłania zdarzeń do Azure Event Hubs.

• Konstruktor przyjmuje EventHubProducerClient opcjonalny parametr typu EventHubClientOptions , którego możesz użyć do określenia opcji takich jak liczba prób.
• Metoda przyjmuje createBatch opcjonalny parametr typu CreateBatchOptions , który możesz wykorzystać do określenia maksymalnego rozmiaru partii obsługiwanego przez tworzoną partię.
• Metoda przyjmuje sendBatch opcjonalny parametr typu SendBatchOptions , którego można użyć do anulowania abortSignal bieżącej operacji.
• Jeśli chcesz wysłać do konkretnej partycji, przeciążenie sendBatch metody pozwala przekazać identyfikator partycji do wysyłania zdarzeń. Powyższy przykład Inspect an Event Hub pokazuje, jak pobrać dostępne identyfikatory partycji.

Uwaga: Podczas pracy z Azure Stream Analytics, treść wysyłanego zdarzenia powinna być również obiektem JSON. Przykład: body: { "message": "Hello World" }

Konsumuj wydarzenia z Event Hub

Aby konsumować wydarzenia z instancji Event Hub, musisz również wiedzieć, do której grupy odbiorców chcesz kierować. Gdy już to poznasz, możesz stworzyć EventHubConsumerClient. Poniższy przykład pokazuje jeden ze sposobów tworzenia klienta, ale zobacz sekcję Authenticate the client, aby dowiedzieć się innych sposobów instancji klienta.

Metoda subscribe na kliencie ma przeciążenia, które w połączeniu z konstruktorem mogą obsługiwać kilka sposobów konsumpcji zdarzeń:

• Konsumuj zdarzenia w jednym procesie
• Konsumowanie zdarzeń z równowagą obciążenia na wielu procesach
• Konsumowanie zdarzeń z jednej partycji

Metoda przyjmuje subscribe opcjonalny parametr typu SubscriptionOptions , który pozwala określić opcje takie jak maxBatchSize (liczba zdarzeń do oczekiwania) oraz maxWaitTimeInSeconds (czas oczekiwania na nadejście zdarzeń maxBatchSize).

Konsumuj zdarzenia w jednym procesie

Zacznij od utworzenia instancji EventHubConsumerClient, a następnie wywołaj metodę subscribe() na niej, aby rozpocząć konsumowanie zdarzeń.

Metoda przyjmuje subscribe wywołania zwrotne, aby przetwarzać zdarzenia odbierane z Azure Event Hubs. Aby zatrzymać odbiór zdarzeń, możesz wywołać close() obiekt zwrócony przez metodę subscribe() .

import { EventHubConsumerClient, earliestEventPosition } from "@azure/event-hubs";

const client = new EventHubConsumerClient("my-consumer-group", "connectionString", "eventHubName");

// In this sample, we use the position of earliest available event to start from
// Other common options to configure would be `maxBatchSize` and `maxWaitTimeInSeconds`
const subscriptionOptions = {
  startPosition: earliestEventPosition,
};

const subscription = client.subscribe(
  {
    processEvents: async (events, context) => {
      // event processing code goes here
    },
    processError: async (err, context) => {
      // error reporting/handling code here
    },
  },
  subscriptionOptions,
);

// Wait for a few seconds to receive events before closing
setTimeout(async () => {
  await subscription.close();
  await client.close();
  console.log(`Exiting sample`);
}, 3 * 1000);

Konsumowanie zdarzeń z równowagą obciążenia na wielu procesach

Azure Event Hubs jest w stanie obsłużyć miliony zdarzeń na sekundę. Aby skalować aplikację przetwarzającą, możesz uruchamiać wiele instancji aplikacji i równoważyć obciążenie między sobą.

Zacznij od stworzenia instancji , EventHubConsumerClient używając jednego z przeciążeń konstruktorów, które pobierają , CheckpointStorea następnie wywołaj metodę subscribe() , aby rozpocząć konsumowanie zdarzeń. Sklep checkpoint umożliwi subskrybentom w grupie konsumenckiej koordynację przetwarzania między wieloma instancjami Twojej aplikacji.

W tym przykładzie użyjemy pakietu BlobCheckpointStore from the @azure/eventhubs-checkpointstore-blob package, który implementuje wymagane odczyty/zapisy do trwałego magazynu za pomocą Azure Blob Storage.

Metoda przyjmuje subscribe wywołania zwrotne, aby przetwarzać zdarzenia odbierane z Azure Event Hubs. Aby zatrzymać odbiór zdarzeń, możesz wywołać close() obiekt zwrócony przez metodę subscribe() .

import { ContainerClient } from "@azure/storage-blob";
import { BlobCheckpointStore } from "@azure/eventhubs-checkpointstore-blob";
import { EventHubConsumerClient } from "@azure/event-hubs";

const storageAccountConnectionString = "storage-account-connection-string";
const containerName = "container-name";
const eventHubConnectionString = "eventhub-connection-string";
const consumerGroup = "my-consumer-group";
const eventHubName = "eventHubName";

const blobContainerClient = new ContainerClient(storageAccountConnectionString, containerName);

if (!(await blobContainerClient.exists())) {
  await blobContainerClient.create();
}

const checkpointStore = new BlobCheckpointStore(blobContainerClient);
const consumerClient = new EventHubConsumerClient(
  consumerGroup,
  eventHubConnectionString,
  eventHubName,
  checkpointStore,
);

const subscription = consumerClient.subscribe({
  processEvents: async (events, context) => {
    // event processing code goes here
    if (events.length === 0) {
      // If the wait time expires (configured via options in maxWaitTimeInSeconds) Event Hubs
      // will pass you an empty array.
      return;
    }

    // Checkpointing will allow your service to pick up from
    // where it left off when restarting.
    //
    // You'll want to balance how often you checkpoint with the
    // performance of your underlying checkpoint store.
    await context.updateCheckpoint(events[events.length - 1]);
  },
  processError: async (err, context) => {
    // handle any errors that occur during the course of
    // this subscription
    console.log(`Errors in subscription to partition ${context.partitionId}: ${err}`);
  },
});

// Wait for a few seconds to receive events before closing
await new Promise((resolve) => setTimeout(resolve, 10 * 1000));

await subscription.close();
await consumerClient.close();
console.log(`Exiting sample`);

Aby dowiedzieć się więcej, zobacz Balance partition load na wielu instancjach swojej aplikacji .

Konsumowanie zdarzeń z jednej partycji

Zacznij od utworzenia instancji EventHubConsumerClient, a następnie wywołaj metodę subscribe() na niej, aby rozpocząć konsumowanie zdarzeń. Przekaż id partycji, którą chcesz skierować, do metody subscribe() , która konsumuje tylko z tej partycji.

W poniższym przykładzie używamy pierwszej partycji.

Metoda przyjmuje subscribe wywołania zwrotne, aby przetwarzać zdarzenia odbierane z Azure Event Hubs. Aby zatrzymać odbiór zdarzeń, możesz wywołać close() obiekt zwrócony przez metodę subscribe() .

import { EventHubConsumerClient, earliestEventPosition } from "@azure/event-hubs";

const client = new EventHubConsumerClient("my-consumer-group", "connectionString", "eventHubName");
const partitionIds = await client.getPartitionIds();

// In this sample, we use the position of earliest available event to start from
// Other common options to configure would be `maxBatchSize` and `maxWaitTimeInSeconds`
const subscriptionOptions = {
  startPosition: earliestEventPosition,
};

const subscription = client.subscribe(
  partitionIds[0],
  {
    processEvents: async (events, context) => {
      // event processing code goes here
    },
    processError: async (err, context) => {
      // error reporting/handling code here
    },
  },
  subscriptionOptions,
);

// Wait for a few seconds to receive events before closing
setTimeout(async () => {
  await subscription.close();
  await client.close();
  console.log(`Exiting sample`);
}, 3 * 1000);

Korzystaj z EventHubConsumerClient do współpracy z IotHub

Możesz też korzystać EventHubConsumerClient z IotHub. Jest to przydatne do odbierania danych telemetrycznych IotHub z połączonego EventHub. Powiązany ciąg połączenia nie będzie miał roszczeń wysyłających, dlatego wysyłanie zdarzeń nie jest możliwe.

• Prosimy zauważyć, że ciąg połączeń musi być dla punktu końcowego kompatybilnego z Event Hub (np. "Endpoint=sb://my-iothub-namespace-[uid].servicebus.windows.net/; SharedAccessKeyName=my-SA-name; SharedAccessKey=my-SA-key; EntityPath=my-iot-hub-name")

import { EventHubConsumerClient } from "@azure/event-hubs";

const client = new EventHubConsumerClient(
  "my-consumer-group",
  "Endpoint=sb://my-iothub-namespace-[uid].servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-iot-hub-name",
);

await client.getEventHubProperties();

// retrieve partitionIds from client.getEventHubProperties() or client.getPartitionIds()
const partitionId = "0";
await client.getPartitionProperties(partitionId);

await client.close();

Rozwiązywanie problemów

Zależności AMQP

Biblioteka Event Hubs polega na bibliotece rhea-promise do zarządzania połączeniami, wysyłania i odbierania zdarzeń za pośrednictwem protokołu AMQP .

Przemysł drzewny

Możesz ustawić zmienną środowiskowąAZURE_LOG_LEVEL, aby umożliwić logowanie na :stderr

export AZURE_LOG_LEVEL=verbose

Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując setLogLevel w @azure/logger:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Aby uzyskać bardziej szczegółowe instrukcje dotyczące włączania dzienników, zapoznaj się z dokumentami dotyczącymi pakietów @azure/rejestratora.

Alternatywnie można ustawić zmienną środowiskową DEBUG w celu pobrania dzienników podczas korzystania z tej biblioteki. Może to być przydatne, jeśli chcesz również emitować dzienniki z zależności rhea-promise i rhea.

Uwaga: AZURE_LOG_LEVEL, jeśli ustawiono, ma pierwszeństwo przed debugowaniem. Nie należy określać żadnych bibliotek azure za pomocą debugowania podczas określania również AZURE_LOG_LEVEL lub wywoływania polecenia setLogLevel.

• Otrzymuję tylko dzienniki debugowania na poziomie informacji z SDK Event Hubs.

export DEBUG=azure:*:info

• Pobieranie logów debugowania z SDK Event Hubs i biblioteki na poziomie protokołu.

export DEBUG=azure*,rhea*

• Jeśli nie chcesz wyświetlać nieprzetworzonych danych zdarzeń (które zużywa dużą ilość miejsca na dysku/konsoli), możesz ustawić zmienną środowiskową DEBUG w następujący sposób:

export DEBUG=azure*,rhea*,-rhea:raw,-rhea:message

• Jeśli interesuje Cię tylko błędy i ostrzeżenia zestawu SDK, możesz ustawić zmienną środowiskową DEBUG w następujący sposób:

export DEBUG=azure:*:(error|warning),rhea-promise:error,rhea:events,rhea:frames,rhea:io,rhea:flow

Dalsze kroki

Więcej przykładowego kodu

Prosimy zajrzeć do katalogu przykładów , gdzie znajdziesz szczegółowe przykłady korzystania z tej biblioteki do wysyłania i odbierania zdarzeń do/z Event Hubs.

Contributing

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