@eventferry/kafka 3.0.0 → 3.2.0

package/README.md

@@ -35,6 +35,255 @@ const publisher = new KafkaPublisher({
 
 You can also pass a `customDriver` implementing the `KafkaDriver` interface.
 
+## Authentication & TLS
+
+### One-way TLS
+
+```ts
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: true, // uses the driver's default trust store
+});
+```
+
+### mTLS (mutual TLS)
+
+```ts
+import { readFileSync } from "node:fs";
+
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: {
+    ca: readFileSync("/etc/ssl/kafka-ca.pem"),
+    cert: readFileSync("/etc/ssl/client.pem"),
+    key: readFileSync("/etc/ssl/client-key.pem"),
+    passphrase: "optional",
+    // servername: "broker.example.com",   // SNI override if cert SAN differs
+  },
+});
+```
+
+> `rejectUnauthorized` is intentionally NOT a knob. TLS verification is
+> non-negotiable. For dev clusters with self-signed certs, pass the cluster
+> CA via `ca` so verification succeeds.
+
+### SASL — username + password (PLAIN / SCRAM)
+
+```ts
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: true,
+  sasl: {
+    mechanism: "scram-sha-512", // or "plain" | "scram-sha-256"
+    username: process.env.KAFKA_USER!,
+    password: process.env.KAFKA_PASSWORD!,
+  },
+});
+```
+
+### SASL/OAUTHBEARER (Azure Event Hubs, OIDC, MSK IAM)
+
+```ts
+new KafkaPublisher({
+  brokers: ["broker:9093"],
+  ssl: true,
+  sasl: {
+    mechanism: "oauthbearer",
+    oauthBearerProvider: async () => {
+      const token = await myTokenIssuer();
+      return {
+        value: token.value,           // required for both drivers
+        principal: token.principal,   // required for confluent driver
+        lifetime: token.expiresInMs,  // required for confluent driver
+        extensions: token.extensions, // optional
+      };
+    },
+  },
+});
+```
+
+> **Driver asymmetry:** `kafkajs` reads only `value`; `@confluentinc/kafka-javascript` requires `value` + `principal` + `lifetime` (in milliseconds) and accepts an optional `extensions` map. Cross-driver portable providers should populate all four fields.
+
+## Producer tuning
+
+The high-throughput recipe (confluent driver):
+
+```ts
+new KafkaPublisher({
+  driver: "confluent",
+  brokers: ["broker:9092"],
+  idempotent: true,
+  compression: "zstd",
+  lingerMs: 25,        // batch up to 25ms for higher throughput
+  batchSize: 131_072,  // 128 KB per partition batch
+  maxInFlightRequests: 5,
+  maxRequestSize: 2_000_000,
+});
+```
+
+Driver support matrix:
+
+| Knob | `kafkajs` | `confluent` |
+|---|:--:|:--:|
+| `transactionTimeoutMs` | ✅ | ✅ |
+| `requestTimeoutMs` | ✅ | ✅ |
+| `maxInFlightRequests` | ✅ | ✅ |
+| `lingerMs` | ⚠️ warn + ignore | ✅ |
+| `batchSize` | ⚠️ warn + ignore | ✅ |
+| `deliveryTimeoutMs` | ⚠️ warn + ignore | ✅ |
+| `maxRequestSize` | ⚠️ warn + ignore | ✅ |
+
+`kafkajs` has no equivalent producer-level config for the last four — its batching is sticky-partitioner + hardcoded internals. The typed API accepts them for portability; on the kafkajs driver they log a one-time warning and are otherwise ignored. Use the confluent driver when you need fine-grained tuning.
+
+## Partitioning
+
+### Default (key-based, java-compatible)
+
+By default a record's `key` is hashed (murmur2, matching the Java client) and the partition derived from it. Same key → same partition → ordered stream per aggregate. No config needed.
+
+### Explicit partition override
+
+Pin a record to a specific partition by setting `partition` on the
+`PublishableMessage` — for compacted topics with application-managed sharding, tenant-affinity routing, or geo-pinning:
+
+```ts
+const msg: PublishableMessage = {
+  topic: "orders.created",
+  key: "tenant-a:order-42",
+  value: encoded,
+  headers: {},
+  recordId: row.id,
+  messageId: row.message_id,
+  partition: 3, // ← pins this record to partition 3
+};
+```
+
+### kafkajs partitioner choice
+
+The kafkajs driver exposes the v2 partitioner selection (and silences the
+`KafkaJSPartitionerNotSpecified` warning):
+
+```ts
+new KafkaPublisher({
+  driver: "kafkajs",
+  brokers: ["broker:9092"],
+  partitioner: "java-compatible", // (default) | "legacy" | "default"
+});
+```
+
+- `"java-compatible"` — kafkajs's `JavaCompatiblePartitioner`; greenfield recommendation, matches the Java client's murmur2.
+- `"legacy"` — pre-v2 hashing. Use when migrating an existing topic to keep hash continuity.
+- `"default"` — kafkajs's current default. May change in future major versions.
+
+## Transactions (EOS)
+
+### Callable `transactionalId`
+
+`transactionalId` accepts a sync or async resolver — useful when the id depends on runtime context that isn't known at construction time (pod name, AZ + replica index, k8s ordinal):
+
+```ts
+new KafkaPublisher({
+  brokers,
+  transactional: true,
+  transactionalId: () =>
+    `${process.env.POD_NAME}-${process.env.REPLICA_INDEX}`,
+});
+```
+
+For multi-instance EOS, the resolved id MUST be stable across a single instance's restarts but UNIQUE across instances. The plain-string form remains supported and unchanged.
+
+### Abort-aware `onTransactionAbort`
+
+When a transactional `sendBatch` triggers the abort path (mid-batch error, broker rejection), the publisher fires `hooks.onTransactionAbort(err)` so dashboards and metrics catch EOS failure rates:
+
+```ts
+new KafkaPublisher({
+  brokers,
+  transactional: true,
+  transactionalId: "orders-tx",
+  hooks: {
+    onTransactionAbort: (err) => metrics.txAborts.inc({ reason: err.name }),
+  },
+});
+```
+
+Best-effort: the hook is safe-wrapped (a throwing hook never breaks the abort path).
+
+## Observability
+
+### Hooks
+
+Wire lifecycle hooks into your metrics / logging stack without subclassing or wrapping the publisher:
+
+```ts
+new KafkaPublisher({
+  brokers,
+  hooks: {
+    onConnect:     ()       => readinessProbe.up(),
+    onDisconnect:  ()       => readinessProbe.down(),
+    onPublish:    (r, msg)  => metrics.publishCounter.inc({ ok: String(r.ok) }),
+    onError:      (e, msg)  => sentry.captureException(e, { msg }),
+    onTransactionAbort: (e) => metrics.txAborts.inc(),
+  },
+});
+```
+
+Hooks are **safe by construction**: a throwing hook never breaks publishing; the publisher swallows the error and logs it via the configured `logger`.
+
+### OpenTelemetry tracing
+
+The publisher wraps each `publish()` in a span that follows the current stable [OpenTelemetry messaging semantic conventions](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/messaging/kafka.md). No dependency on `@opentelemetry/api` — wire your tracer through a thin adapter:
+
+```ts
+import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import type { KafkaTracer, SpanLike } from "@eventferry/kafka";
+
+const otel = trace.getTracer("@eventferry/kafka");
+
+const tracer: KafkaTracer = {
+  startPublishSpan(name, attributes) {
+    const span = otel.startSpan(name, { kind: SpanKind.PRODUCER, attributes });
+    return {
+      setAttribute: (k, v) => span.setAttribute(k, v),
+      setAttributes: (a) => span.setAttributes(a),
+      setStatus: (s) =>
+        span.setStatus({
+          code: s.code === "ok" ? SpanStatusCode.OK : SpanStatusCode.ERROR,
+          message: s.message,
+        }),
+      recordException: (e) => span.recordException(e),
+      end: () => span.end(),
+    } satisfies SpanLike;
+  },
+};
+
+new KafkaPublisher({ brokers, tracer });
+```
+
+Per the spec, eventferry emits **one span per `publish()` call**, named `"{topic} publish"`, with attributes:
+
+| Attribute | Always | Notes |
+|---|:--:|---|
+| `messaging.system` | ✅ | `"kafka"` |
+| `messaging.operation.type` | ✅ | `"publish"` |
+| `messaging.destination.name` | ✅ | First topic in the batch |
+| `messaging.batch.message_count` | ✅ | Including single-message batches |
+
+The user-supplied tracer SHOULD set `SpanKind.PRODUCER` on the span; the adapter above does this explicitly.
+
+### Logger
+
+Pass a `Logger` (the same interface used by `@eventferry/core`) to route the publisher's own diagnostics — driver warnings, hook failures — through your logging stack:
+
+```ts
+new KafkaPublisher({
+  brokers,
+  logger: pinoLoggerAdapter, // anything implementing { debug, info, warn, error }
+});
+```
+
+When omitted, the publisher is silent and the driver falls back to `console.warn` for its diagnostics (preserves prior behavior).
+
 📖 **Full documentation:** [github.com/SametGoktepe/eventferry](https://github.com/SametGoktepe/eventferry#readme)
 
 ## License

package/dist/index.cjs

@@ -33,8 +33,12 @@ __export(index_exports, {
   ConfluentDriver: () => ConfluentDriver,
   KafkaJsDriver: () => KafkaJsDriver,
   KafkaPublisher: () => KafkaPublisher,
+  NoopKafkaTracer: () => NoopKafkaTracer,
+  _resetKafkajsWarnDedup: () => _resetKafkajsWarnDedup,
+  buildConfluentClientConfig: () => buildConfluentClientConfig,
   classifyConfluentError: () => classifyConfluentError,
-  classifyKafkajsError: () => classifyKafkajsError
+  classifyKafkajsError: () => classifyKafkajsError,
+  safeHook: () => safeHook
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -125,7 +129,27 @@ var CODE_TO_KIND = /* @__PURE__ */ new Map([
   // INVALID_RECORD
 ]);
 
+// src/transactional-id.ts
+async function resolveTransactionalId(input) {
+  if (input === void 0) {
+    throw new Error("transactionalId is required when transactional=true");
+  }
+  const raw = typeof input === "function" ? await input() : input;
+  if (typeof raw !== "string" || raw.length === 0) {
+    throw new Error(
+      "transactionalId resolver must return a non-empty string"
+    );
+  }
+  return raw;
+}
+
 // src/kafkajs-driver.ts
+var UNSUPPORTED_BY_KAFKAJS = [
+  "lingerMs",
+  "batchSize",
+  "deliveryTimeoutMs",
+  "maxRequestSize"
+];
 var KafkaJsDriver = class {
   transactional;
   producer = null;
@@ -138,6 +162,7 @@ var KafkaJsDriver = class {
         "KafkaJsDriver: transactionalId is required when transactional=true"
       );
     }
+    warnUnsupportedKafkajsOptions(opts);
   }
   async connect() {
     this.producer = await this.createProducer();
@@ -152,13 +177,37 @@ var KafkaJsDriver = class {
     const kafka = new mod.Kafka({
       clientId: this.opts.clientId ?? "eventferry",
       brokers: this.opts.brokers,
+      // kafkajs accepts `ssl: tls.ConnectionOptions` directly — Buffer + PEM
+      // string both supported. Our TlsConfig is a structural subset of that
+      // (`rejectUnauthorized` intentionally omitted; the cluster CA goes via
+      // `ca`). No translation needed.
       ssl: this.opts.ssl,
+      // SASL: PLAIN / SCRAM-SHA-256 / SCRAM-SHA-512 / OAUTHBEARER. kafkajs's
+      // shape matches ours; for OAUTHBEARER kafkajs reads only `value` from
+      // the provider's returned token (other fields are ignored).
       sasl: this.opts.sasl
     });
+    const createPartitioner = resolveCreatePartitioner(
+      mod.Partitioners,
+      this.opts.partitioner,
+      this.transactional
+    );
+    const resolvedTxId = this.transactional ? await resolveTransactionalId(this.opts.transactionalId) : void 0;
     return kafka.producer({
       idempotent: this.opts.idempotent ?? true,
-      maxInFlightRequests: this.transactional ? 1 : void 0,
-      transactionalId: this.transactional ? this.opts.transactionalId : void 0
+      // Idempotent / transactional producers cap maxInFlight at 5. When the
+      // user picks transactional we force 1 to keep strict ordering across
+      // retries on classic (non-idempotent) clusters that haven't migrated
+      // to the broker-side fence.
+      maxInFlightRequests: this.transactional ? 1 : this.opts.maxInFlightRequests,
+      transactionalId: resolvedTxId,
+      // kafkajs accepts these directly when set; undefined falls through to
+      // the kafkajs default.
+      requestTimeout: this.opts.requestTimeoutMs,
+      transactionTimeout: this.opts.transactionTimeoutMs,
+      // Setting any partitioner choice silences kafkajs's
+      // KafkaJSPartitionerNotSpecified warning.
+      createPartitioner
     });
   }
   async disconnect() {
@@ -176,6 +225,11 @@ var KafkaJsDriver = class {
         return messages.map((m) => ({ recordId: m.recordId, ok: true }));
       } catch (err) {
         await txn.abort().catch(() => void 0);
+        const error = err instanceof Error ? err : new Error(String(err));
+        try {
+          this.opts.onTransactionAbort?.(error);
+        } catch {
+        }
         return failedResults(messages, err);
       }
     }
@@ -204,7 +258,12 @@ function groupByTopic(messages, compression) {
     arr.push({
       key: m.key,
       value: m.value,
-      headers: m.headers
+      headers: m.headers,
+      // Per-message partition override. When set, kafkajs routes the record
+      // to this exact partition; when undefined, the configured partitioner
+      // chooses. We keep the key here too because compacted topics need it
+      // even when partition is pinned.
+      ...m.partition !== void 0 ? { partition: m.partition } : {}
     });
     byTopic.set(m.topic, arr);
   }
@@ -214,6 +273,35 @@ function groupByTopic(messages, compression) {
     ...compression && compression !== "none" ? { compression } : {}
   }));
 }
+function resolveCreatePartitioner(partitioners, choice, transactional) {
+  if (!partitioners) return void 0;
+  const effective = choice ?? (transactional ? "default" : "java-compatible");
+  switch (effective) {
+    case "java-compatible":
+      return partitioners.JavaCompatiblePartitioner;
+    case "legacy":
+      return partitioners.LegacyPartitioner;
+    case "default":
+      return partitioners.DefaultPartitioner;
+  }
+}
+var warnedKafkajsKeys = /* @__PURE__ */ new Set();
+function warnUnsupportedKafkajsOptions(opts) {
+  for (const key of UNSUPPORTED_BY_KAFKAJS) {
+    if (opts[key] === void 0) continue;
+    if (warnedKafkajsKeys.has(key)) continue;
+    warnedKafkajsKeys.add(key);
+    const message = `'${key}' is not configurable on the kafkajs driver and was ignored. Switch to the confluent driver (driver: "confluent") for fine-grained tuning, or remove the option to silence this warning.`;
+    if (opts.logger) {
+      opts.logger.warn(`[@eventferry/kafka] ${message}`, { option: key });
+    } else {
+      console.warn(`[@eventferry/kafka] ${message}`);
+    }
+  }
+}
+function _resetKafkajsWarnDedup() {
+  warnedKafkajsKeys.clear();
+}
 async function importKafkaJs() {
   try {
     return await import("kafkajs");
@@ -322,6 +410,71 @@ var NAME_TO_KIND = /* @__PURE__ */ new Map([
   ["ERR_THROTTLING_QUOTA_EXCEEDED", "quota"]
 ]);
 
+// src/confluent-config.ts
+function buildConfluentClientConfig(opts) {
+  const kafkaJS = {
+    clientId: opts.clientId ?? "eventferry",
+    brokers: opts.brokers
+  };
+  const librdkafka = {};
+  if (opts.lingerMs !== void 0) librdkafka["linger.ms"] = opts.lingerMs;
+  if (opts.batchSize !== void 0) librdkafka["batch.size"] = opts.batchSize;
+  if (opts.maxInFlightRequests !== void 0) {
+    librdkafka["max.in.flight.requests.per.connection"] = opts.maxInFlightRequests;
+  }
+  if (opts.requestTimeoutMs !== void 0) {
+    librdkafka["request.timeout.ms"] = opts.requestTimeoutMs;
+  }
+  if (opts.deliveryTimeoutMs !== void 0) {
+    librdkafka["delivery.timeout.ms"] = opts.deliveryTimeoutMs;
+  }
+  if (opts.maxRequestSize !== void 0) {
+    librdkafka["message.max.bytes"] = opts.maxRequestSize;
+  }
+  if (opts.transactionTimeoutMs !== void 0) {
+    librdkafka["transaction.timeout.ms"] = opts.transactionTimeoutMs;
+  }
+  const tlsRequested = opts.ssl === true || isTlsConfig(opts.ssl);
+  const saslRequested = !!opts.sasl;
+  if (saslRequested && tlsRequested) {
+    librdkafka["security.protocol"] = "sasl_ssl";
+  } else if (tlsRequested) {
+    librdkafka["security.protocol"] = "ssl";
+  } else if (saslRequested) {
+    librdkafka["security.protocol"] = "sasl_plaintext";
+  }
+  if (isTlsConfig(opts.ssl)) {
+    const tls = opts.ssl;
+    if (tls.ca !== void 0) {
+      librdkafka["ssl.ca.pem"] = stringifyPem(tls.ca);
+    }
+    if (tls.cert !== void 0) {
+      librdkafka["ssl.certificate.pem"] = stringifyPem(tls.cert);
+    }
+    if (tls.key !== void 0) {
+      librdkafka["ssl.key.pem"] = stringifyPem(tls.key);
+    }
+    if (tls.passphrase !== void 0) {
+      librdkafka["ssl.key.password"] = tls.passphrase;
+    }
+  } else if (opts.ssl === true) {
+    kafkaJS["ssl"] = true;
+  }
+  if (opts.sasl) {
+    kafkaJS["sasl"] = opts.sasl;
+  }
+  return { kafkaJS, librdkafka };
+}
+function isTlsConfig(v) {
+  return typeof v === "object" && v !== null;
+}
+function stringifyPem(input) {
+  if (Array.isArray(input)) {
+    return input.map((x) => typeof x === "string" ? x : x.toString("utf8")).join("\n");
+  }
+  return typeof input === "string" ? input : input.toString("utf8");
+}
+
 // src/confluent-driver.ts
 var ConfluentDriver = class {
   transactional;
@@ -346,18 +499,16 @@ var ConfluentDriver = class {
    */
   async createProducer() {
     const mod = await importConfluent();
+    const { kafkaJS, librdkafka } = buildConfluentClientConfig(this.opts);
     const kafka = new mod.KafkaJS.Kafka({
-      kafkaJS: {
-        clientId: this.opts.clientId ?? "eventferry",
-        brokers: this.opts.brokers,
-        ssl: this.opts.ssl,
-        sasl: this.opts.sasl
-      }
+      kafkaJS,
+      ...librdkafka
     });
+    const resolvedTxId = this.transactional ? await resolveTransactionalId(this.opts.transactionalId) : void 0;
     return kafka.producer({
       kafkaJS: {
         idempotent: this.opts.idempotent ?? true,
-        ...this.transactional ? { transactionalId: this.opts.transactionalId } : {}
+        ...resolvedTxId ? { transactionalId: resolvedTxId } : {}
       }
     });
   }
@@ -388,6 +539,11 @@ var ConfluentDriver = class {
         return messages.map((m) => ({ recordId: m.recordId, ok: true }));
       } catch (err) {
         await txn.abort().catch(() => void 0);
+        const error = err instanceof Error ? err : new Error(String(err));
+        try {
+          this.opts.onTransactionAbort?.(error);
+        } catch {
+        }
         return failedResults2(messages, err);
       }
     }
@@ -413,7 +569,14 @@ function groupByTopic2(messages) {
   const byTopic = /* @__PURE__ */ new Map();
   for (const m of messages) {
     const arr = byTopic.get(m.topic) ?? [];
-    arr.push({ key: m.key, value: m.value, headers: m.headers });
+    arr.push({
+      key: m.key,
+      value: m.value,
+      headers: m.headers,
+      // Per-message partition override. librdkafka honors an explicit
+      // partition value; undefined leaves the default partitioner in charge.
+      ...m.partition !== void 0 ? { partition: m.partition } : {}
+    });
     byTopic.set(m.topic, arr);
   }
   return [...byTopic.entries()].map(([topic, msgs]) => ({
@@ -431,20 +594,108 @@ async function importConfluent() {
   }
 }
 
+// src/hooks.ts
+async function safeHook(logger, hookName, invoke) {
+  try {
+    const r = invoke();
+    if (r && typeof r.then === "function") {
+      await r;
+    }
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    logger?.warn(`[@eventferry/kafka] hook ${hookName} threw; ignored`, {
+      error: error.message
+    });
+  }
+}
+
+// src/tracing.ts
+var NoopKafkaTracer = class {
+  startPublishSpan() {
+    return NOOP_SPAN;
+  }
+};
+var NOOP_SPAN = {
+  setAttribute() {
+  },
+  setAttributes() {
+  },
+  setStatus() {
+  },
+  recordException() {
+  },
+  end() {
+  }
+};
+
 // src/publisher.ts
 var KafkaPublisher = class {
   driver;
+  logger;
+  hooks;
+  tracer;
   constructor(opts) {
-    this.driver = opts.customDriver ?? selectDriver(opts);
+    this.logger = opts.logger;
+    this.hooks = opts.hooks ?? {};
+    this.tracer = opts.tracer ?? new NoopKafkaTracer();
+    const onTransactionAbort = this.hooks.onTransactionAbort ? (error) => {
+      void safeHook(
+        this.logger,
+        "onTransactionAbort",
+        () => this.hooks.onTransactionAbort?.(error)
+      );
+    } : void 0;
+    this.driver = opts.customDriver ?? selectDriver({ ...opts, onTransactionAbort });
   }
-  connect() {
-    return this.driver.connect();
+  async connect() {
+    await this.driver.connect();
+    await safeHook(this.logger, "onConnect", () => this.hooks.onConnect?.());
   }
-  disconnect() {
-    return this.driver.disconnect();
+  async disconnect() {
+    await this.driver.disconnect();
+    await safeHook(
+      this.logger,
+      "onDisconnect",
+      () => this.hooks.onDisconnect?.()
+    );
   }
-  publish(messages) {
-    return this.driver.sendBatch(messages);
+  async publish(messages) {
+    if (messages.length === 0) return [];
+    const span = this.startBatchSpan(messages);
+    let results;
+    try {
+      results = await this.driver.sendBatch(messages);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      span.setStatus({ code: "error", message: error.message });
+      span.recordException(error);
+      span.end();
+      await safeHook(this.logger, "onError", () => this.hooks.onError?.(error));
+      throw err;
+    }
+    const byId = new Map(messages.map((m) => [m.recordId, m]));
+    let allOk = true;
+    for (const r of results) {
+      const msg = byId.get(r.recordId);
+      if (!msg) continue;
+      await safeHook(
+        this.logger,
+        "onPublish",
+        () => this.hooks.onPublish?.(r, msg)
+      );
+      if (!r.ok) {
+        allOk = false;
+        const err = r.error ?? new Error("publish failed");
+        await safeHook(
+          this.logger,
+          "onError",
+          () => this.hooks.onError?.(err, msg)
+        );
+      }
+    }
+    span.setStatus(allOk ? { code: "ok" } : { code: "error" });
+    span.end();
+    return results;
   }
   /**
    * Send a single dead-lettered message. The message already carries the
@@ -469,6 +720,23 @@ var KafkaPublisher = class {
   get transactional() {
     return this.driver.transactional;
   }
+  /**
+   * Start a span for the batch following the OTel messaging conventions.
+   *
+   * Multi-topic batches: per the OTel spec, the span name uses the
+   * destination — we pick the FIRST topic in the batch and document the
+   * limitation. Callers that publish heterogeneous batches and care about
+   * per-topic spans should split their batches upstream.
+   */
+  startBatchSpan(messages) {
+    const topic = messages[0]?.topic ?? "unknown";
+    return this.tracer.startPublishSpan(`${topic} publish`, {
+      "messaging.system": "kafka",
+      "messaging.operation.type": "publish",
+      "messaging.destination.name": topic,
+      "messaging.batch.message_count": messages.length
+    });
+  }
 };
 function selectDriver(opts) {
   const kind = opts.driver ?? "kafkajs";
@@ -486,7 +754,11 @@ function selectDriver(opts) {
   ConfluentDriver,
   KafkaJsDriver,
   KafkaPublisher,
+  NoopKafkaTracer,
+  _resetKafkajsWarnDedup,
+  buildConfluentClientConfig,
   classifyConfluentError,
-  classifyKafkajsError
+  classifyKafkajsError,
+  safeHook
 });
 //# sourceMappingURL=index.cjs.map