Azure Event Hubs client library for JavaScript - version 6.0.4

Az Azure Event Hubs egy rendkívül skálázható publish-subscribe szolgáltatás, amely másodpercenként milliókat képes befogadni, és több fogyasztóhoz továbbítani azokat. Ez lehetővé teszi a csatlakoztatott eszközök és alkalmazások által előállított nagy mennyiségű adat feldolgozását és elemzését. Ha többet szeretnél megtudni az Azure Event Hubs-ról, érdemes lehet áttekinteni: Mi az az Event Hubs?

Az Azure Event Hubs klienskönyvtára lehetővé teszi, hogy eseményeket küldj és fogadj a Node.js alkalmazásodban.

Főbb linkek:

• forráskód
• Csomag (npm)
• API referenciadokumentációja
• termékdokumentáció
• Minták

MEGJEGYZÉS: Ha a 2.1.0 vagy alacsonyabb verziót használod, és szeretnél átköltözni a csomag legújabb verziójára, kérjük, nézd meg migrációs útmutatónkat, hogy az EventHubs V2-ről az EventHubs V5-re válts

A v2 mintái és dokumentációja még mindig elérhetők itt:

Forráskód v2.1.0-hoz | Csomag v2.1.0-hoz (npm) | Minták v2.1.0-hoz

Kezdő lépések

A csomag telepítése

Install the Azure Event Hubs client library using npm

npm install @azure/event-hubs

Jelenleg támogatott környezetek

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

További részletekért tekintse meg támogatási szabályzatunkat.

Előfeltételek

• Azure-előfizetés
• Egy eseményközpont névtér

Konfiguráld a TypeScript

A TypeScript felhasználóknak Node típus definíciókat kell telepíteniük:

npm install @types/node

A tsconfig.jsonis be kell kapcsolnod compilerOptions.allowSyntheticDefaultImports a . Fontos megjegyezni, hogy ha engedélyezted compilerOptions.esModuleInterop, akkor allowSyntheticDefaultImports alapértelmezés szerint engedélyezve van. További információért lásd a TypeScript fordítóbeállítások kézikönyvét .

JavaScript-csomag

Ahhoz, hogy ezt az ügyfélkódtárat a böngészőben használhassa, először egy kötegelőt kell használnia. Ennek részleteiért tekintse meg a csomagküldő dokumentációt.

A leírottakon túl ehhez a könyvtárhoz további polifillekre is szükség van a következő NodeJS mag beépített modulokhoz, hogy megfelelően működjön a böngészőkben:

• buffer
• os
• path
• process

Csomagolás a Webpackhez

Ha Webpack v5-öt használsz, telepítheted a következő fejlesztői függőségeket

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

Ezután add a következőket a 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"),
+    },
   },

Csomagolás a Rollup-pal

Ha Rollup bundlert használsz, telepítsd a következő fejlesztői függőségeket

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

Ezután a következőket is belefoglald 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"],
+    }),
  ]
};

További információért kérjük, tekintse meg kedvenc bundlerének dokumentációját a polifillek használatáról.

React natív támogatás

A böngészőkhöz hasonlóan a React Native nem támogatja bizonyos JavaScript API-kat, amelyeket ez az SDK könyvtár használ, ezért polifilleket kell biztosítani hozzájuk. További részletekért lásd az Expo-val való Messaging React Native mintát .

Az ügyfél hitelesítése

Az Event Hubs-szal való interakció vagy az EventHubConsumerClient osztály egy példányával, vagy az EventHubProducerClient osztály egy példányával kezdődik. Vannak konstruktor túlterhelések, amelyek különböző módokat támogatnak ezeknek az osztályoknak a megvalósításához, ahogy az alábbiakban látható:

Használj connection stringet az Event Hubs névtérhez

Az egyik konstruktor túlterhelés egy kapcsolati láncsort visz az űrlap Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; és az entitás nevének egy Event Hub példányába. Létrehozhatsz egy fogyasztói csoportot, és megkaphatod a kapcsolati láncszálat, valamint az entitás nevét az Azure portálból.

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

Használd a kapcsolati stringet a szabályzathoz az Event Hubon

Egy másik konstruktor túlterhelés a Event Hub példányban (és nem az Event Hubs névtérben) meghatározott megosztott hozzáférési szabályzatnak megfelelő kapcsolati láncsort veszi fel. Ez a kapcsolati lánc a következő formában Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-namelesz. A csatlakozási string formátum kulcsfontosságú különbsége az előző konstruktor túlterheléséhez képest a ;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",
);

Használd az Event Hubs névteret és Azure Identity

Ez a konstruktor túlterhelés a Event Hub példányod hosztnevét és entitásnevét veszi fel, valamint a TokenCredential interfészt megvalósító hitelesítő leveled. Ez lehetővé teszi, hogy Azure Active Directory alapvetéllyel hitelesíts. Az TokenCredential interfész megvalósításai elérhetők az @azure/identity csomagban. A hoszt neve a formátumból <yournamespace>.servicebus.windows.netáll. Azure Active Directory használatakor a főnevednek olyan szerepet kell kapnia, amely lehetővé teszi az Event Hubokhoz való hozzáférést, például az Azure Event Hubs Data Owner szerepét. További információért az Azure Active Directory hitelesítés Event Hubs-kal való használatáról kérjük, tekintse meg a kapcsolódó dokumentációt.

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

Főbb fogalmak

• Az Event Hub gyártó telemetriai adatok, diagnosztikai információk, használati naplók vagy egyéb naplóadatok forrása, amely egy beágyazott eszközmegoldás, mobileszköz alkalmazás, konzolon vagy más eszközön futó játékjáték, kliens vagy szerver alapú üzleti megoldás, vagy weboldal részeként.

• Az Event Hub fogyasztója ilyen információkat vesz fel az Event Hubból és feldolgozza azokat. A feldolgozás magában foglalhatja az aggregálást, összetett számítást és szűrést. A feldolgozás magában foglalhatja az információ nyers vagy átalakított módon történő terjesztését vagy tárolását is. Az Event Hub fogyasztói gyakran robusztus és nagyszabású platforminfrastruktúra részek, beépített analitikai képességekkel, mint például az Azure Stream Analytics, Apache Spark vagy Apache Storm.

• A partíció egy rendezett eseménysorozat, amely egy Event Hubban található. A partíciók az adatszervezés egyik eszköze, amely az eseményfogyasztók által megkövetelt párhuzamossághoz kapcsolódik. Az Azure Event Hubs egy partíciós fogyasztói mintán keresztül biztosítja az üzenetküldést, amelyben minden felhasználó csak egy adott részhalmazt, vagyis partíciót olvas az üzenetfolyamnak. Ahogy újabb események érkeznek, ezek hozzáadódnak a sorozat végéhez. A partíciók számát az Event Hub létrehozásakor határozzák meg, és nem lehet változtatni.

• A fogyasztói csoport egy egész eseményközpont képe. A fogyasztói csoportok lehetővé teszik, hogy több fogyasztó alkalmazás külön nézőpontot kapjon az eseményfolyamról, és függetlenül olvassák a streamet saját tempójukban és saját pozíciójukból. Egy partíción legfeljebb 5 párhuzamos olvasó lehet fogyasztói csoporton; azonban ajánlott, hogy egy adott partíció és fogyasztói csoport párosításhoz csak egy aktív fogyasztó legyen. Minden aktív olvasó az összes eseményt a saját partíciójáról kapja; Ha ugyanazon a partíción több olvasó van, akkor duplikált eseményeket kapnak.

További fogalmakért és mélyebb vitáért lásd: Event Hubs Features

Útmutatás az újrapróbálkozásokkal kapcsolatban

És EventHubConsumerClientEventHubProducerClient elfogadod options , hol állíthatod be, retryOptions hogy az SDK hogyan kezeli az átmeneti hibákat. Átmeneti hibák példái közé tartoznak az ideiglenes hálózati vagy szolgáltatási problémák.

Újrapróbálkozások események fogyasztása közben

Ha átmeneti hiba (például ideiglenes hálózati probléma) jelentkezik az esemény fogadása közben, az SDK újra megpróbálja az események fogadását a visszaigazolási opciók alapján, amelyek a EventHubConsumerClient. Ha a maximális újrapróbálkozási kísérletek kimerülnek, a processError függvény megidéződik.

A újrapróbálkozási beállításokat arra használhatod, hogy szabályozd, milyen gyorsan értesülsz ideiglenes problémákról, például hálózati kapcsolati problémáról. Például, ha azonnal tudni kell, mikor van hálózati probléma, csökkentheted az értékeket és maxRetriesretryDelayInMsesetén.

A processError függvény végrehajtása után a kliens továbbra is kap eseményeket a partícióról, amíg a hiba újrapróbálható. Ellenkező esetben a kliens meghívja a felhasználó által biztosított processClose funkciót. Ez a funkció akkor is aktiválódik, amikor vagy leállítod az előfizetést, vagy amikor a kliens nem olvassa az aktuális partíció eseményeit, mert egy másik példány veszi fel az alkalmazásod terheléselosztás részeként.

A processClose funkció lehetőséget ad az ellenőrzőpontok frissítésére, ha szükséges. A futtatás processCloseután az ügyfél (vagy terhelés elrendezés esetén egy másik példányból származó kliens) behívja a felhasználó által processInitialize biztosított függvényt, hogy folytassa az események olvasását az utolsó frissített ellenőrzőpontról ugyanannak a partíción.

Ha abba akarod hagyni az események olvasását, a módszer által vissza kell hívnod close()subscriptionsubscribe .

Példák

Az alábbi szakaszok kódrészleteket tartalmaznak, amelyek az Azure Event Hubs használatával kapcsolatos gyakori feladatokat fedik le

• Ellenőrizz egy eseményközpontot
• Események közzététele egy eseményközpontban
• Események fogyasztása egy eseményközpontból
• Használd az EventHubConsumerClient-t az IotHub alkalmazásához

Ellenőrizz egy eseményközpontot

Számos Event Hub művelet egy adott partíció hatókörén belül zajlik. Mivel a partíciók az Event Hub tulajdonában vannak, a nevüket a létrehozás pillanatában rendelik meg. Ahhoz, hogy megértsük, mely partíciók állnak rendelkezésre, az Event Hub-ban a két elérhető kliens egyikével kérdezzük: EventHubProducerClient vagy EventHubConsumerClient

Az alábbi példában egy EventHubProducerClient.

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

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

const partitionIds = await client.getPartitionIds();

await client.close();

Események közzététele egy eseményközpontban

Ahhoz, hogy eseményeket publikálhass, létre kell hoznod egy EventHubProducerClient. Bár az alábbi példa egy módot mutat a kliens létrehozásának, lásd a kliens hitelesítése szekciót, ahol más módszereket is megtanulhatsz az ügyfél megvalósítására.

Közzéteheted az eseményeket egy adott partíción, vagy hagyhatod az Event Hubs szolgáltatásnak, hogy eldöntse, melyik partíció eseményeit kell közzétenni. Ajánlott az automatikus útvonalválasztás alkalmazása, amikor az események közzétételének nagyon elérhetőnek kell lennie, vagy amikor az eseményadatokat egyenletesen kell elosztani a partíciók között. Az alábbi példában kihasználjuk az automatikus útvonalválasztást.

• Hozz létre objektumot EventDataBatch a createBatch segítségével
• Hozzáadj eseményeket a batch-hoz a tryAdd módszerrel. Ezt addig csinálhatod, amíg el nem éred a maximális tételméret-korlátot, vagy amíg nem adsz hozzá annyi eseményt, amelyik előbb jön. Ez a módszer visszatér false , jelezve, hogy a maximális tételméret elérése miatt nem lehet több eseményt hozzáadni a batchhez.
• Küldd el az eseménycsomagot a sendBatch módszerrel.

Az alábbi példában megpróbálunk 10 eseményt küldeni az Azure Event Hubs-nak.

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

Különböző szakaszokban vannak lehetőségek, amelyeket az események küldésének folyamatának irányítására lehet használni az Azure Event Hubs-ba.

• A EventHubProducerClient konstruktor egy opcionális paramétert EventHubClientOptions vesz fel, amivel lehetőségeket lehet megadni, például a próbálkozások számát.
• A createBatch módszer egy opcionális paramétert CreateBatchOptions vesz fel, amivel a létrehozott tétel által támogatott maximális tételméretet tudod megjelölni.
• A sendBatch metódus egy opcionális paramétert SendBatchOptions használ, amellyel abortSignal megadhatod az aktuális művelet megszüntetését.
• Ha egy adott partícióra szeretnél küldeni, a metódus túlterhelése sendBatch lehetővé teszi, hogy átadd annak a partíciónak az azonosítóját, ahová az eseményeket küldheted. A fenti Inspect an Event Hub példa megmutatja, hogyan lehet letölteni az elérhető partíciók azonosítóit.

Megjegyzés: Az Azure Stream Analytics-szel való munkavégzéskor az esemény testének is JSON objektumnak kell lennie. Például: body: { "message": "Hello World" }

Események fogyasztása egy eseményközpontból

Az események fogyasztásához egy Event Hub példányból azt is tudnia kell, hogy melyik fogyasztói csoportot szeretnéd megcélozni. Ha ezt megtudod, készen állsz egy EventHubConsumerClient létrehozására. Bár az alábbi példa egy módot mutat a kliens létrehozásának, lásd a kliens hitelesítése szekciót, ahol más módszereket is megtanulhatsz az ügyfél megvalósítására.

A kliensen lévő subscribe módszernek túlterhelései vannak, amelyek a konstruktorral együtt többféle eseményfogyasztási módot is kielégíthetnek:

• Események fogyasztása egyetlen folyamatban
• Események fogyasztása terhelés kiegyensúlyozott több folyamat között
• Egyetlen partícióból származó események fogyasztása

A subscribe módszer egy opcionális paramétert SubscriptionOptions használ, amivel megadhatod olyan opciókat, mint a maxBatchSize (várandó események száma) és maxWaitTimeInSeconds (a maxBatchSize események megérkezésére várható idő).

Események fogyasztása egyetlen folyamatban

Kezdjük azzal, hogy létrehozunk egy példányt , EventHubConsumerClientmajd hívjuk a subscribe() metódust rajta, hogy elkezdje az események fogyasztását.

A subscribe módszer visszahívásokat vesz fel az események feldolgozására, ahogy azokat az Azure Event Hubs-ról érkeznek. Az események close() megállításához hívhatod a metódus által visszaadott subscribe() objektumot.

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

Események fogyasztása terhelés kiegyensúlyozott több folyamat között

Az Azure Event Hubs képes milliói eseményekkel kezelni másodpercenként. A feldolgozó alkalmazás skálázásához több példányt futtathatsz az alkalmazásodból, és az egyensúlyozhatja a terhelést egymás között.

Kezdjük azzal, hogy létrehozz egy példányt EventHubConsumerClient az egyik konstruktor túlterheléssel, amely egy CheckpointStore, igényel, majd hívjuk a subscribe() metódust, hogy elkezdje az események fogyasztását. A checkpoint áruház lehetővé teszi a fogyasztói csoport előfizetőinek számára, hogy koordinálják a feldolgozást az alkalmazásod több példánya között.

Ebben a példában a from the BlobCheckpointStore package függvényt fogjuk @azure/eventhubs-checkpointstore-blob használni, amely Azure Blob Storage segítségével valósítja meg a szükséges olvasási/írásokat egy tartós tárolóhoz.

A subscribe módszer visszahívásokat vesz fel az események feldolgozására, ahogy azokat az Azure Event Hubs-ról érkeznek. Az események close() megállításához hívhatod a metódus által visszaadott subscribe() objektumot.

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

További információért kérjük , lásd a Partíciós terhelés kiegyenlítése több alkalmazási példány között.

Egyetlen partícióból származó események fogyasztása

Kezdjük azzal, hogy létrehozunk egy példányt , EventHubConsumerClientmajd hívjuk a subscribe() metódust rajta, hogy elkezdje az események fogyasztását. Add át a célzott partíció azonosítóját annak a subscribe() metódusnak, hogy csak az adott partícióból fogyasztasz.

Az alábbi példában az első partíciót használjuk.

A subscribe módszer visszahívásokat vesz fel az események feldolgozására, ahogy azokat az Azure Event Hubs-ról érkeznek. Az események close() megállításához hívhatod a metódus által visszaadott subscribe() objektumot.

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

Használd az EventHubConsumerClient-t az IotHub alkalmazásához

EventHubConsumerClient Használhatod az IotHub-ban is. Ez hasznos az IotHub telemetriai adatainak fogadásához a kapcsolt EventHubból. A hozzá tartozó kapcsolati lánc nem lesz küldési igény, így események küldése nem lehetséges.

• Kérjük, vegye figyelembe, hogy a kapcsolati láncsornak egy Event Hub-kompatibilis végponthoz kell lennie (pl. "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();

Hibaelhárítás

AMQP függőségei

Az Event Hubs könyvtár a rhea-promise könyvtárra támaszkodik a kapcsolatok kezeléséhez, események küldéséhez és fogadásához az AMQP protokollon keresztül.

Logging

A AZURE_LOG_LEVEL környezeti változót beállíthatod, hogy engedélyezze a naplózást:stderr

export AZURE_LOG_LEVEL=verbose

Alternatívaként a naplózás futásidőben is engedélyezhető a setLogLevel hívásával a @azure/logger.

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

setLogLevel("info");

A naplók engedélyezésére vonatkozó részletesebb útmutatásért tekintse meg a @azure/logger csomag dokumentációit.

Másik lehetőségként beállíthatja a DEBUG környezeti változót, hogy naplókat kapjon a kódtár használatakor. Ez akkor lehet hasznos, ha a rhea-promise és rhea függőségekből is szeretne naplókat kibocsátani.

Megjegyzés: ha be van állítva, AZURE_LOG_LEVEL elsőbbséget élvez a DEBUG-nak. Ne adjon meg azure kódtárakat a DEBUG használatával, ha AZURE_LOG_LEVEL vagy a setLogLevel hívását is megadja.

• Csak információs szintű hibakereső naplókat kapok az Event Hubs SDK-ról.

export DEBUG=azure:*:info

• Hibakeresési naplók beszerzése az Event Hubs SDK-ból és a protokollszintű könyvtárból.

export DEBUG=azure*,rhea*

• Ha nem szeretné megtekinteni a nyers eseményadatokat (amely nagy mennyiségű konzolt/lemezterületet használ fel), akkor az alábbi módon állíthatja be a DEBUG környezeti változót:

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

• Ha csak hibák és SDK-figyelmeztetésekérdekli, akkor a DEBUG környezeti változót az alábbiak szerint állíthatja be:

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

Következő lépések

További mintakód

Kérjük, nézze meg a mintakönyvtárat részletes példákért arra, hogyan használhatod ezt a könyvtárat események küldésére és fogadására az Event Hubs-ba/onnan.

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.