Azure Event Hubs JavaScript ügyfélkódtár – 5.12.0-s verzió

Azure Event Hubs egy nagymértékben skálázható közzétételi-feliratkozási szolgáltatás, amely másodpercenként több millió eseményt képes beemelni, és több fogyasztónak streamelni. Ez lehetővé teszi a csatlakoztatott eszközök és alkalmazások által létrehozott nagy mennyiségű adat feldolgozását és elemzését. Ha többet szeretne megtudni a Azure Event Hubs, tekintse át a következőt: Mi az az Event Hubs?

Az Azure Event Hubs ügyfélkódtár lehetővé teszi események küldését és fogadását az Node.js alkalmazásban.

Főbb hivatkozások:

• Forráskód
• Csomag (npm)
• API-referenciadokumentáció
• Termékdokumentáció
• Példák

MEGJEGYZÉS: Ha a 2.1.0-s vagy újabb verziót használja, és a csomag legújabb verziójára szeretne migrálni, tekintse meg migrálási útmutatónkat az EventHubs V2-ről az EventHubs V5-be való áttéréshez

A v2-hez és a dokumentációhoz továbbra is elérhetők minták:

Forráskód a 2.1.0-s | verzióhozCsomag a 2.1.0-s verzióhoz (npm) | Minták a 2.1.0-s verzióhoz

Első lépések

A csomag telepítése

Az Azure Event Hubs ügyfélkódtár telepítése az npm használatával

npm install @azure/event-hubs

Jelenleg támogatott környezetek

• A Node.jsLTS-verziói
• 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
• Event Hubs-névtér

TypeScript konfigurálása

A TypeScript-felhasználóknak telepítve kell lenniük a csomóponttípus-definícióknak:

npm install @types/node

A tsconfig.json is engedélyeznie compilerOptions.allowSyntheticDefaultImports kell. Vegye figyelembe, hogy ha engedélyeztecompilerOptions.esModuleInteropallowSyntheticDefaultImports, a alapértelmezés szerint engedélyezve van. További információt a TypeScript fordítóbeállítási kézikönyvében talál.

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 módjáról a csomagkontraszt dokumentációjában talál további információt.

Az itt leírtakon kívül a kódtárnak további polifillekre is szüksége van a nodeJS core beépített moduljaihoz, hogy megfelelően működjenek a böngészőkben:

• buffer
• os
• path
• process

Bundling with Webpack

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

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

majd adja hozzá 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"),
+    },
   },

Összevonás kumulatív frissítéssel

Kumulatív csomagkezelő használata esetén telepítse 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 adja meg a következőket a 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"],
+    }),
  ]
};

A polifillek használatáról a kedvenc kötegelő dokumentációjában talál további információt.

React Native támogatás

A böngészőkhöz hasonlóan a React Native nem támogatja az SDK-kódtár által használt JavaScript API-t, ezért polifilleket kell biztosítania számukra. További részletekért tekintse meg az Üzenetkezelés React Native mintát az Expóval.

Az ügyfél hitelesítése

Az Event Hubs-interakció az EventHubConsumerClient osztály egy példányával vagy az EventHubProducerClient osztály egy példányával kezdődik. A konstruktorok túlterhelései támogatják az osztályok példányosításának különböző módjait az alábbiak szerint:

Kapcsolati karakterlánc használata az Event Hubs-névtérhez

Az egyik konstruktor-túlterhelés az űrlap Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key; és az entitás nevének kapcsolati karakterlánc veszi át az Event Hub-példányra. Létrehozhat egy fogyasztói csoportot, és lekérheti a kapcsolati karakterlánc és az entitás nevét a Azure Portal.

const { EventHubProducerClient, EventHubConsumerClient } = require("@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"
);

A kapcsolati karakterlánc használata az eseményközpont szabályzatához

Egy másik konstruktor túlterhelése a közvetlenül az Event Hub-példányon (és nem az Event Hubs-névtérben) definiált megosztott hozzáférési szabályzatnak megfelelő kapcsolati karakterlánc veszi át. Ez a kapcsolati karakterlánc lesz a következő formábanEndpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name: . Az előző konstruktor-túlterhelés kapcsolati karakterlánc formátumának fő különbsége a ;EntityPath=my-event-hub-name.

const { EventHubProducerClient, EventHubConsumerClient } = require("@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"
);

Az Event Hubs-névtér és az Azure Identity használata

Ez a konstruktor-túlterhelés az Event Hub-példány gazdagépnevét és entitásnevét, valamint a TokenCredential felületet megvalósító hitelesítő adatokat veszi fel. Ez lehetővé teszi a hitelesítést egy Azure Active Directory-résztvevővel. Az interfésznek vannak implementációi a TokenCredential@azure/identity csomagban. Az állomásnév formátuma <yournamespace>.servicebus.windows.net. Az Azure Active Directory használatakor a rendszerbiztonsági taghoz olyan szerepkört kell hozzárendelni, amely lehetővé teszi az Event Hubshoz való hozzáférést, például az Azure Event Hubs Adattulajdonos szerepkört. Az Azure Active Directory-hitelesítés event hubokkal való használatával kapcsolatos további információkért tekintse meg a kapcsolódó dokumentációt.

const { EventHubProducerClient, EventHubConsumerClient } = require("@azure/event-hubs");

const { DefaultAzureCredential } = require("@azure/identity");
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ő fogalmak

• Az Eseményközpont-előállítók telemetriai adatok, diagnosztikai információk, használati naplók vagy egyéb naplóadatok forrásaként szolgálnak beágyazott eszközmegoldás, mobileszköz-alkalmazás, konzolon vagy más eszközön futó játékcímek, ügyfél- vagy kiszolgálóalapú üzleti megoldások vagy webhelyek részeként.

• Az Event Hub-felhasználók felveszik ezeket az információkat az Eseményközpontból, és feldolgozza azokat. A feldolgozás magában foglalhatja az összesítést, az összetett számítást és a szűrést. A feldolgozás magában foglalhatja az információk nyers vagy átalakított módon történő terjesztését vagy tárolását is. Az Event Hub felhasználói gyakran robusztus és nagy léptékű platforminfrastruktúra-részek, amelyek beépített elemzési képességekkel rendelkeznek, például az Azure Stream Analytics, az Apache Spark vagy az Apache Storm.

• A partíció egy eseményközpontban tárolt események rendezett sorozata. A partíciók az eseményfelhasználók által megkövetelt párhuzamossághoz kapcsolódó adatszervezési eszközök. Azure Event Hubs egy particionált fogyasztói mintán keresztül biztosítja az üzenetek streamelésének folyamatát, amelyben minden fogyasztó csak az üzenetstream egy adott részhalmazát vagy partícióját olvassa be. Ha új esemény érkezik, az a sorozat végére kerül. A partíciók száma az eseményközpont létrehozásakor van megadva, és nem módosítható.

• A fogyasztói csoport egy teljes eseményközpont nézete. A fogyasztói csoportok lehetővé teszik, hogy több fogyasztó alkalmazás külön nézetet biztosítson az eseménystreamről, és a streamet a saját tempójukban és a saját helyzetüktől függetlenül olvassák. Fogyasztói csoportonként legfeljebb 5 egyidejű olvasó lehet egy partíción; azonban ajánlott egy adott partíció- és fogyasztóicsoport-párosításhoz csak egy aktív fogyasztót létrehozni. Minden aktív olvasó megkapja az összes eseményt a partíciójáról; Ha több olvasó van ugyanazon a partíción, akkor ismétlődő eseményeket kapnak.

További fogalmakért és részletesebb ismertetésért lásd: Event Hubs-funkciók

Útmutatás az újrapróbálkozásokhoz

A EventHubConsumerClient és EventHubProducerClient elfogadhatja options a beállítást retryOptions , amely lehetővé teszi, hogy az SDK hogyan kezelje az átmeneti hibákat. Az átmeneti hibák közé tartoznak például az ideiglenes hálózati vagy szolgáltatásproblémák.

Újrapróbálkozás események felhasználásakor

Ha átmeneti hiba (például egy ideiglenes hálózati probléma) lép fel, amikor az SDK eseményeket fogad, újra megpróbál eseményeket fogadni a következőnek EventHubConsumerClientátadott újrapróbálkozási beállítások alapján: . Ha a maximális újrapróbálkozási kísérletek kimerülnek, a processError függvény meg lesz hívva.

Az újrapróbálkozási beállítások segítségével szabályozhatja, hogy milyen gyorsan értesüljön az ideiglenes problémákról, például a hálózati kapcsolat problémáiról. Ha például azonnal tudnia kell, hogy hálózati probléma merült fel, csökkentheti a és retryDelayInMsa értékétmaxRetries.

A függvény végrehajtása után az processError ügyfél továbbra is fogad eseményeket a partícióról, feltéve, hogy a hiba újrapróbálható volt. Ellenkező esetben az ügyfél meghívja a felhasználó által megadott processClose függvényt. Ezt a függvényt akkor is meghívja a rendszer, ha leállítja az előfizetést, vagy ha az ügyfél leállítja az események olvasását az aktuális partícióról, mert azt az alkalmazás egy másik példánya a terheléselosztás részeként felvette.

A processClose függvény lehetőséget biztosít az ellenőrzőpontok szükség esetén történő frissítésére. A végrehajtása processCloseután az ügyfél (vagy terheléselosztás esetén az alkalmazás egy másik példányából származó ügyfél) meghívja a felhasználó által biztosított processInitialize függvényt, hogy folytassa az olvasási eseményeket ugyanazon partíció utolsó frissített ellenőrzőpontjáról.

Ha le szeretné állítani az események olvasására tett kísérleteket, a metódus által subscribe visszaadott értéket kell meghívnia.close()subscription

Példák

A következő szakaszok olyan kódrészleteket nyújtanak, amelyek a Azure Event Hubs használatával végzett gyakori feladatok némelyikét ismertetik.

• Eseményközpont vizsgálata
• Események közzététele eseményközpontban
• Események felhasználása eseményközpontból
• Az EventHubConsumerClient használata az IotHub használatához

Eseményközpont vizsgálata

Számos Eseményközpont-művelet egy adott partíció hatókörén belül történik. Mivel a partíciók az Event Hub tulajdonában vannak, a nevük a létrehozáskor lesz hozzárendelve. Annak megértéséhez, hogy mely partíciók érhetők el, lekérdezi az Event Hubot a két elérhető ügyfél valamelyikével: EventHubProducerClient vagy EventHubConsumerClient

Az alábbi példában a következőt EventHubProducerClienthasználjuk: .

const { EventHubProducerClient } = require("@azure/event-hubs");

async function main() {
  const client = new EventHubProducerClient("connectionString", "eventHubName");

  const partitionIds = await client.getPartitionIds();

  await client.close();
}

main();

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

Az események közzétételéhez létre kell hoznia egy EventHubProducerClient. Bár az alábbi példa az ügyfél létrehozásának egyik módját mutatja be, tekintse meg az Ügyfél hitelesítése című szakaszt, amelyből megtudhatja, hogyan lehet más módon példányosítani az ügyfelet.

Eseményeket tehet közzé egy adott partíción, vagy engedélyezheti az Event Hubs szolgáltatásnak, hogy eldöntse, melyik partícióeseményeket kell közzétenni. Ajánlott automatikus útválasztást használni, ha az események közzétételének magas rendelkezésre állásúnak kell lennie, vagy ha az eseményadatokat egyenletesen kell elosztani a partíciók között. Az alábbi példában az automatikus útválasztás előnyeit fogjuk kihasználni.

• EventDataBatch objektum Létrehozás a createBatch használatával
• Adjon hozzá eseményeket a köteghez a tryAdd metódussal. Ezt mindaddig megteheti, amíg el nem éri a köteg maximális méretkorlátját, vagy amíg el nem végzi a kívánt események számának hozzáadását, attól függően, hogy melyik lesz az első. Ez a metódus visszatér false , hogy jelezze, hogy a köteghez nem lehet több eseményt hozzáadni a maximális kötegméret elérése miatt.
• Küldje el az események kötegét a sendBatch metódussal.

Az alábbi példában 10 eseményt próbálunk elküldeni Azure Event Hubs.

const { EventHubProducerClient } = require("@azure/event-hubs");

async function main() {
  const producerClient = new EventHubProducerClient("connectionString", "eventHubName");

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

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

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

main();

Az események Azure Event Hubs való küldésének folyamatát különböző fázisokban is átadhatja.

• A EventHubProducerClient konstruktor egy választható típusú EventHubClientOptions paramétert használ, amellyel megadhatja az olyan beállításokat, mint az újrapróbálkozések száma.
• A createBatch metódus egy választható típusú CreateBatchOptions paramétert használ, amellyel megszúrhatja a létrehozott köteg által támogatott maximális kötegméretet.
• A sendBatch metódus egy választható típusú SendBatchOptions paramétert használ, amellyel megadhatja abortSignal az aktuális művelet megszakítását.
• Ha egy adott partícióra szeretne küldeni, a sendBatch metódus túlterhelése lehetővé teszi a partíció azonosítójának átadását az események küldéséhez. A fenti Eseményközpont vizsgálata példa bemutatja, hogyan lehet lekérni az elérhető partícióazonosítókat.

Megjegyzés: Az Azure Stream Analytics használatakor az elküldött esemény törzsének is JSON-objektumnak kell lennie. Például: body: { "message": "Hello World" }

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

Eseményközpont-példány eseményeinek felhasználásához azt is tudnia kell, hogy melyik fogyasztói csoportot szeretné megcélzni. Ha ezt már tudja, készen áll egy EventHubConsumerClient létrehozására. Bár az alábbi példa az ügyfél létrehozásának egyik módját mutatja be, tekintse meg az Ügyfél hitelesítése című szakaszt, amelyből megtudhatja, hogyan lehet más módon példányosítani az ügyfelet.

Az subscribe ügyfél metódusa túlterheltségekkel rendelkezik, amelyek a konstruktorral kombinálva többféleképpen is képesek eseményeket felhasználni:

• Események felhasználása egyetlen folyamat során
• Események felhasználása több folyamat között elosztott terheléssel
• Események felhasználása egyetlen partícióból

A subscribe metódus egy választható típusú SubscriptionOptions paramétert használ, amellyel megadhatja az olyan beállításokat, mint a maxBatchSize (a várakozni kívánt események száma) és a maxWaitTimeInSeconds (ennyi idő, amíg a maxBatchSize események megérkeznek).

Események felhasználása egyetlen folyamat során

Először hozzon létre egy példányt a EventHubConsumerClient, majd hívja meg a subscribe() metódust az események fogyasztásának megkezdéséhez.

A subscribe metódus visszahívásokat fogad az események feldolgozásához, amint azok Azure Event Hubs érkeznek. Az események fogadásának leállításához meghívhatja close() a metódus által visszaadott objektumot subscribe() .

const { EventHubConsumerClient, earliestEventPosition } = require("@azure/event-hubs");

async function main() {
  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);
}

main();

Események felhasználása több folyamat között elosztott terheléssel

Azure Event Hubs másodpercenként több millió eseményt képes kezelni. A feldolgozási alkalmazás skálázásához futtathatja az alkalmazás több példányát, és eloszthatja a terhelést egymás között.

Először hozzon létre egy példányt az EventHubConsumerClient egyik konstruktor-túlterhelés használatával, amely CheckpointStoreegy , majd hívja meg a metódust az subscribe() események használatának megkezdéséhez. Az ellenőrzőpont-tároló lehetővé teszi, hogy a fogyasztói csoport előfizetői koordinálják az alkalmazás több példánya közötti feldolgozást.

Ebben a példában a BlobCheckpointStore@azure/eventhubs-checkpointstore-blob csomagból származó fájlt fogjuk használni, amely a szükséges olvasási/írási adatokat egy tartós tárolóba implementálja Azure Blob Storage használatával.

A subscribe metódus visszahívásokat fogad az események feldolgozásához, amint azok Azure Event Hubs érkeznek. Az események fogadásának leállításához meghívhatja close() a metódus által visszaadott objektumot subscribe() .

const { EventHubConsumerClient } = require("@azure/event-hubs");
const { ContainerClient } = require("@azure/storage-blob");
const { BlobCheckpointStore } = require("@azure/eventhubs-checkpointstore-blob");

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

async function main() {
  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`);
}

main();

További információ: Partícióterhelés kiegyensúlyozása az alkalmazás több példányában .

Események felhasználása egyetlen partícióból

Először hozzon létre egy példányt a EventHubConsumerClient, majd hívja meg a subscribe() metódust az események fogyasztásának megkezdéséhez. Adja meg a megcélzni kívánt partíció azonosítóját a metódusnak, hogy csak ebből a subscribe() partícióból használja.

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

A subscribe metódus visszahívásokat fogad az események feldolgozásához, amint azok Azure Event Hubs érkeznek. Az események fogadásának leállításához meghívhatja close() a metódus által visszaadott objektumot subscribe() .

const { EventHubConsumerClient, earliestEventPosition } = require("@azure/event-hubs");

async function main() {
  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);
}

main();

Az EventHubConsumerClient használata az IotHub használatához

Használhatja EventHubConsumerClient az IotHub használatát is. Ez hasznos az IotHub telemetriai adatainak a csatolt EventHubról való fogadásához. A társított kapcsolati karakterlánc nem küld jogcímeket, ezért az események küldése nem lehetséges.

• Vegye figyelembe, hogy a kapcsolati karakterlánc egy Event Hub-kompatibilis végpontnak 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")

const { EventHubConsumerClient } = require("@azure/event-hubs");

async function main() {
  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();
}

main();

Hibaelhárítás

AMQP-függőségek

Az Event Hubs-kódtár a kapcsolatok kezeléséhez, az események AMQP protokollon keresztüli küldéséhez és fogadásához szükséges rhea-promise kódtártól függ.

Naplózás

A környezeti változót AZURE_LOG_LEVEL úgy állíthatja be, hogy engedélyezze a naplózást a következő értékre stderr:

export AZURE_LOG_LEVEL=verbose

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

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

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

• Csak információszintű hibakeresési naplók lekérése az Event Hubs SDK-ból.

export DEBUG=azure:*:info

• Hibakeresési naplók lekérése az Event Hubs SDK-ból és a protokollszintű kódtárból.

export DEBUG=azure*,rhea*

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

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

• Ha csak a hibák és az SDK-figyelmeztetések érdeklik, a környezeti változót az DEBUG 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

Tekintse meg a mintakönyvtárat , amelyből részletes példákat talál arra, hogyan küldhet és fogadhat eseményeket az Event Hubsba vagy 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.