@platformatic/kafka 1.0.0 → 1.2.0

package/dist/clients/consumer/messages-stream.js

@@ -1,16 +1,21 @@
 import { Readable } from 'node:stream';
 import { ListOffsetTimestamps } from "../../apis/enumerations.js";
+import { consumerReceivesChannel, createDiagnosticContext, notifyCreation } from "../../diagnostic.js";
 import { UserError } from "../../errors.js";
 import { kInspect, kPrometheus } from "../base/base.js";
 import { createPromisifiedCallback, kCallbackPromise, noopCallback } from "../callbacks.js";
 import { ensureMetric } from "../metrics.js";
+import { defaultConsumerOptions } from "./options.js";
 import { MessagesStreamFallbackModes, MessagesStreamModes } from "./types.js";
 // Don't move this function as being in the same file will enable V8 to remove.
 // For futher info, ask Matteo.
-/* c8 ignore next 3 */
+/* c8 ignore next 3 - Fallback deserializer, nothing to really test */
 export function noopDeserializer(data) {
     return data;
 }
+export function defaultCorruptedMessageHandler() {
+    return true;
+}
 export class MessagesStream extends Readable {
     #consumer;
     #mode;
@@ -30,16 +35,17 @@ export class MessagesStream extends Readable {
     #shouldClose;
     #closeCallbacks;
     #metricsConsumedMessages;
+    #corruptedMessageHandler;
     constructor(consumer, options) {
-        const { autocommit, mode, fallbackMode, offsets, deserializers, ..._options } = options;
+        const { autocommit, mode, fallbackMode, offsets, deserializers, onCorruptedMessage, ...otherOptions } = options;
         if (offsets && mode !== MessagesStreamModes.MANUAL) {
             throw new UserError('Cannot specify offsets when the stream mode is not MANUAL.');
         }
         if (!offsets && mode === MessagesStreamModes.MANUAL) {
             throw new UserError('Must specify offsets when the stream mode is MANUAL.');
         }
-        /* c8 ignore next 14 */
-        super({ objectMode: true, highWaterMark: options.highWaterMark ?? 1024 });
+        /* c8 ignore next - Unless is initialized directly, highWaterMark is always defined */
+        super({ objectMode: true, highWaterMark: options.highWaterMark ?? defaultConsumerOptions.highWaterMark });
         this.#consumer = consumer;
         this.#mode = mode ?? MessagesStreamModes.LATEST;
         this.#fallbackMode = fallbackMode ?? MessagesStreamFallbackModes.LATEST;
@@ -54,6 +60,7 @@ export class MessagesStream extends Readable {
         this.#autocommitInflight = false;
         this.#shouldClose = false;
         this.#closeCallbacks = [];
+        this.#corruptedMessageHandler = onCorruptedMessage ?? defaultCorruptedMessageHandler;
         // Restore offsets
         this.#offsetsToFetch = new Map();
         if (offsets) {
@@ -62,9 +69,8 @@ export class MessagesStream extends Readable {
             }
         }
         // Clone the rest of the options so the user can never mutate them
-        this.#options = structuredClone(_options);
+        this.#options = structuredClone(otherOptions);
         // Start the autocommit interval
-        /* c8 ignore next */
         if (typeof autocommit === 'number' && autocommit > 0) {
             this.#autocommitInterval = setInterval(this.#autocommit.bind(this), autocommit);
         }
@@ -76,7 +82,7 @@ export class MessagesStream extends Readable {
         // having some.
         this.#consumer.on('consumer:group:join', () => {
             this.#refreshOffsets((error) => {
-                /* c8 ignore next 4 */
+                /* c8 ignore next 4 - Hard to test */
                 if (error) {
                     this.destroy(error);
                     return;
@@ -87,6 +93,7 @@ export class MessagesStream extends Readable {
         if (consumer[kPrometheus]) {
             this.#metricsConsumedMessages = ensureMetric(consumer[kPrometheus], 'Counter', 'kafka_consumed_messages', 'Number of consumed Kafka messages');
         }
+        notifyCreation('messages-stream', this);
     }
     close(callback) {
         if (!callback) {
@@ -111,7 +118,7 @@ export class MessagesStream extends Readable {
             this.removeAllListeners('readable');
             this.resume();
         }
-        /* c8 ignore next 3 */
+        /* c8 ignore next 3 - Hard to test */
         this.once('error', (error) => {
             callback(error);
         });
@@ -131,23 +138,23 @@ export class MessagesStream extends Readable {
         });
         return callback[kCallbackPromise];
     }
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
     addListener(event, listener) {
         return super.addListener(event, listener);
     }
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
     on(event, listener) {
         return super.on(event, listener);
     }
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
     once(event, listener) {
         return super.once(event, listener);
     }
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
     prependListener(event, listener) {
         return super.prependListener(event, listener);
     }
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 - Only forwards to Node.js implementation - Inserted here to please Typescript */
     prependOnceListener(event, listener) {
         return super.prependOnceListener(event, listener);
     }
@@ -167,7 +174,7 @@ export class MessagesStream extends Readable {
         this.#fetch();
     }
     #fetch() {
-        /* c8 ignore next 4 */
+        /* c8 ignore next 4 - Hard to test */
         if (this.#shouldClose || this.closed || this.destroyed) {
             this.push(null);
             return;
@@ -175,7 +182,7 @@ export class MessagesStream extends Readable {
         this.#consumer.metadata({ topics: this.#consumer.topics.current }, (error, metadata) => {
             if (error) {
                 // The stream has been closed, ignore any error
-                /* c8 ignore next 4 */
+                /* c8 ignore next 4 - Hard to test */
                 if (this.#shouldClose) {
                     this.push(null);
                     return;
@@ -183,7 +190,7 @@ export class MessagesStream extends Readable {
                 this.destroy(error);
                 return;
             }
-            /* c8 ignore next 4 */
+            /* c8 ignore next 4 - Hard to test */
             if (this.#shouldClose || this.closed || this.destroyed) {
                 this.push(null);
                 return;
@@ -191,6 +198,7 @@ export class MessagesStream extends Readable {
             const requests = new Map();
             const topicIds = new Map();
             // Group topic-partitions by the destination broker
+            const requestedOffsets = new Map();
             for (const topic of this.#topics) {
                 const assignment = this.#assignmentsForTopic(topic);
                 // This consumer has no assignment for the topic, continue
@@ -210,13 +218,14 @@ export class MessagesStream extends Readable {
                     }
                     const topicId = metadata.topics.get(topic).id;
                     topicIds.set(topicId, topic);
+                    const fetchOffset = this.#offsetsToFetch.get(`${topic}:${partition}`);
+                    requestedOffsets.set(`${topic}:${partition}`, fetchOffset);
                     leaderRequests.push({
                         topicId,
                         partitions: [
                             {
                                 partition,
-                                /* c8 ignore next */
-                                fetchOffset: this.#offsetsToFetch.get(`${topic}:${partition}`) ?? 0n,
+                                fetchOffset,
                                 partitionMaxBytes: this.#options.maxBytes,
                                 currentLeaderEpoch: -1,
                                 lastFetchedEpoch: -1
@@ -231,7 +240,7 @@ export class MessagesStream extends Readable {
                     this.#inflightNodes.delete(leader);
                     if (error) {
                         // The stream has been closed, ignore the error
-                        /* c8 ignore next 4 */
+                        /* c8 ignore next 4 - Hard to test */
                         if (this.#shouldClose) {
                             this.push(null);
                             return;
@@ -247,29 +256,44 @@ export class MessagesStream extends Readable {
                         }
                         return;
                     }
-                    this.#pushRecords(metadata, topicIds, response);
+                    this.#pushRecords(metadata, topicIds, response, requestedOffsets);
                 });
             }
         });
     }
-    #pushRecords(metadata, topicIds, response) {
+    #pushRecords(metadata, topicIds, response, requestedOffsets) {
         const autocommit = this.#autocommitEnabled;
         let canPush = true;
         const keyDeserializer = this.#keyDeserializer;
         const valueDeserializer = this.#valueDeserializer;
         const headerKeyDeserializer = this.#headerKeyDeserializer;
         const headerValueDeserializer = this.#headerValueDeserializer;
+        let diagnosticContext;
         // Parse results
-        try {
-            for (const topicResponse of response.responses) {
-                const topic = topicIds.get(topicResponse.topicId);
-                for (const { records, partitionIndex: partition } of topicResponse.partitions) {
-                    if (!records) {
+        for (const topicResponse of response.responses) {
+            const topic = topicIds.get(topicResponse.topicId);
+            for (const { records, partitionIndex: partition } of topicResponse.partitions) {
+                if (!records) {
+                    continue;
+                }
+                const firstTimestamp = records.firstTimestamp;
+                const firstOffset = records.firstOffset;
+                const leaderEpoch = metadata.topics.get(topic).partitions[partition].leaderEpoch;
+                for (const record of records.records) {
+                    const offset = records.firstOffset + BigInt(record.offsetDelta);
+                    if (offset < requestedOffsets.get(`${topic}:${partition}`)) {
+                        // Thi is a duplicate message, ignore it
                         continue;
                     }
-                    const firstTimestamp = records.firstTimestamp;
-                    const leaderEpoch = metadata.topics.get(topic).partitions[partition].leaderEpoch;
-                    for (const record of records.records) {
+                    diagnosticContext = createDiagnosticContext({
+                        client: this.#consumer,
+                        stream: this,
+                        operation: 'receive',
+                        raw: record
+                    });
+                    consumerReceivesChannel.start.publish(diagnosticContext);
+                    const commit = autocommit ? noopCallback : this.#commit.bind(this, topic, partition, offset, leaderEpoch);
+                    try {
                         const headers = new Map();
                         for (const [headerKey, headerValue] of record.headers) {
                             headers.set(headerKeyDeserializer(headerKey), headerValueDeserializer(headerValue));
@@ -277,33 +301,43 @@ export class MessagesStream extends Readable {
                         const key = keyDeserializer(record.key, headers);
                         const value = valueDeserializer(record.value, headers);
                         this.#metricsConsumedMessages?.inc();
-                        canPush = this.push({
+                        const message = {
                             key,
                             value,
                             headers,
                             topic,
                             partition,
                             timestamp: firstTimestamp + record.timestampDelta,
-                            offset: records.firstOffset + BigInt(record.offsetDelta),
-                            commit: autocommit
-                                ? noopCallback
-                                : this.#commit.bind(this, topic, partition, records.firstOffset + BigInt(record.offsetDelta), leaderEpoch)
-                        });
+                            offset,
+                            commit
+                        };
+                        diagnosticContext.result = message;
+                        consumerReceivesChannel.asyncStart.publish(diagnosticContext);
+                        canPush = this.push(message);
+                        consumerReceivesChannel.asyncEnd.publish(diagnosticContext);
+                    }
+                    catch (error) {
+                        const shouldDestroy = this.#corruptedMessageHandler(record, topic, partition, firstTimestamp, firstOffset, commit);
+                        if (shouldDestroy) {
+                            diagnosticContext.error = error;
+                            consumerReceivesChannel.error.publish(diagnosticContext);
+                            this.destroy(new UserError('Failed to deserialize a message.', { cause: error }));
+                            return;
+                        }
                     }
-                    // Track the last read offset
-                    const lastOffset = records.firstOffset + BigInt(records.lastOffsetDelta);
-                    this.#offsetsToFetch.set(`${topic}:${partition}`, lastOffset + 1n);
-                    // Autocommit if needed
-                    if (autocommit) {
-                        this.#offsetsToCommit.set(`${topic}:${partition}`, { topic, partition, offset: lastOffset, leaderEpoch });
+                    finally {
+                        consumerReceivesChannel.end.publish(diagnosticContext);
                     }
                 }
+                // Track the last read offset
+                const lastOffset = records.firstOffset + BigInt(records.lastOffsetDelta);
+                this.#offsetsToFetch.set(`${topic}:${partition}`, lastOffset + 1n);
+                // Autocommit if needed
+                if (autocommit) {
+                    this.#offsetsToCommit.set(`${topic}:${partition}`, { topic, partition, offset: lastOffset, leaderEpoch });
+                }
             }
         }
-        catch (error) {
-            this.destroy(new UserError('Failed to deserialize a message.', { cause: error }));
-            return;
-        }
         if (this.#autocommitEnabled && !this.#autocommitInterval) {
             this.#autocommit();
         }
@@ -339,6 +373,7 @@ export class MessagesStream extends Readable {
         });
     }
     #refreshOffsets(callback) {
+        /* c8 ignore next 4 - Hard to test */
         if (this.#topics.length === 0) {
             callback(null);
             return;
@@ -412,8 +447,7 @@ export class MessagesStream extends Readable {
         }
         this.#closeCallbacks = [];
     }
-    // This is a private API used to debug during development
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 - This is a private API used to debug during development */
     [kInspect](...args) {
         this.#consumer[kInspect](...args);
     }

package/dist/clients/consumer/options.d.ts

@@ -293,6 +293,9 @@ export declare const consumeOptionsSchema: {
                 additionalProperties: boolean;
             };
         };
+        onCorruptedMessage: {
+            function: boolean;
+        };
     };
     required: string[];
     additionalProperties: boolean;

package/dist/clients/consumer/options.js

@@ -79,6 +79,7 @@ export const consumeOptionsSchema = {
                 additionalProperties: false
             }
         },
+        onCorruptedMessage: { function: true },
         ...groupOptionsProperties,
         ...consumeOptionsProperties
     },

package/dist/clients/consumer/types.d.ts

@@ -1,5 +1,6 @@
-import { type FetchRequestTopic } from '../../apis/consumer/fetch.ts';
+import { type FetchRequestTopic } from '../../apis/consumer/fetch-v17.ts';
 import { type FetchIsolationLevel } from '../../apis/enumerations.ts';
+import { type KafkaRecord, type Message } from '../../protocol/records.ts';
 import { type BaseOptions, type TopicWithPartitionAndOffset } from '../base/types.ts';
 import { type Deserializers } from '../serde.ts';
 export interface GroupProtocolSubscription {
@@ -16,6 +17,7 @@ export interface ExtendedGroupProtocolSubscription extends Omit<GroupProtocolSub
     memberId: string;
 }
 export type Offsets = Map<string, bigint[]>;
+export type CorruptedMessageHandler = (record: KafkaRecord, topic: string, partition: number, firstTimestamp: bigint, firstOffset: bigint, commit: Message['commit']) => boolean;
 export declare const MessagesStreamModes: {
     readonly LATEST: "latest";
     readonly EARLIEST: "earliest";
@@ -23,12 +25,14 @@ export declare const MessagesStreamModes: {
     readonly MANUAL: "manual";
 };
 export type MessagesStreamMode = keyof typeof MessagesStreamModes;
+export type MessagesStreamModeValue = (typeof MessagesStreamModes)[keyof typeof MessagesStreamModes];
 export declare const MessagesStreamFallbackModes: {
     readonly LATEST: "latest";
     readonly EARLIEST: "earliest";
     readonly FAIL: "fail";
 };
 export type MessagesStreamFallbackMode = keyof typeof MessagesStreamFallbackModes;
+export type MessagesStreamFallbackModeValue = (typeof MessagesStreamFallbackModes)[keyof typeof MessagesStreamFallbackModes];
 export interface GroupOptions {
     sessionTimeout?: number;
     rebalanceTimeout?: number;
@@ -46,9 +50,10 @@ export interface ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> {
 }
 export interface StreamOptions {
     topics: string[];
-    mode?: string;
-    fallbackMode?: string;
+    mode?: MessagesStreamModeValue;
+    fallbackMode?: MessagesStreamFallbackModeValue;
     offsets?: TopicWithPartitionAndOffset[];
+    onCorruptedMessage?: CorruptedMessageHandler;
 }
 export type ConsumeOptions<Key, Value, HeaderKey, HeaderValue> = StreamOptions & ConsumeBaseOptions<Key, Value, HeaderKey, HeaderValue> & GroupOptions;
 export type ConsumerOptions<Key, Value, HeaderKey, HeaderValue> = BaseOptions & {

package/dist/clients/producer/producer.js

@@ -1,10 +1,9 @@
 import { ProduceAcks } from "../../apis/enumerations.js";
-import { api as initProducerIdV5 } from "../../apis/producer/init-producer-id.js";
-import { api as produceV11 } from "../../apis/producer/produce.js";
+import { createDiagnosticContext, producerInitIdempotentChannel, producerSendsChannel } from "../../diagnostic.js";
 import { UserError } from "../../errors.js";
 import { murmur2 } from "../../protocol/murmur2.js";
 import { NumericMap } from "../../utils.js";
-import { Base, kBootstrapBrokers, kCheckNotClosed, kClearMetadata, kClosed, kConnections, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kPrometheus, kValidateOptions } from "../base/base.js";
+import { Base, kAfterCreate, kBootstrapBrokers, kCheckNotClosed, kClearMetadata, kClosed, kConnections, kGetApi, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kPrometheus, kValidateOptions } from "../base/base.js";
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../callbacks.js";
 import { ensureMetric } from "../metrics.js";
 import { produceOptionsValidator, producerOptionsValidator, sendOptionsValidator } from "./options.js";
@@ -30,6 +29,9 @@ export class Producer extends Base {
             options.acks = ProduceAcks.ALL;
             options.retries = Number.MAX_SAFE_INTEGER;
         }
+        else {
+            options.idempotent = false;
+        }
         options.repeatOnStaleMetadata ??= true;
         super(options);
         this.#partitionsRoundRobin = new NumericMap();
@@ -43,6 +45,7 @@ export class Producer extends Base {
             ensureMetric(this[kPrometheus], 'Gauge', 'kafka_producers', 'Number of active Kafka producers').inc();
             this.#metricsProducedMessages = ensureMetric(this[kPrometheus], 'Counter', 'kafka_produced_messages', 'Number of produced Kafka messages');
         }
+        this[kAfterCreate]('producer');
     }
     get producerId() {
         return this.#producerInfo?.producerId;
@@ -84,18 +87,43 @@ export class Producer extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        return this[kPerformDeduplicated]('initProducerId', deduplicateCallback => {
+        producerInitIdempotentChannel.traceCallback(this.#initIdempotentProducer, 1, createDiagnosticContext({ client: this, operation: 'initIdempotentProducer', options }), this, options, callback);
+        return callback[kCallbackPromise];
+    }
+    send(options, callback) {
+        if (!callback) {
+            callback = createPromisifiedCallback();
+        }
+        if (this[kCheckNotClosed](callback)) {
+            return callback[kCallbackPromise];
+        }
+        const validationError = this[kValidateOptions](options, sendOptionsValidator, '/options', false);
+        if (validationError) {
+            callback(validationError, undefined);
+            return callback[kCallbackPromise];
+        }
+        producerSendsChannel.traceCallback(this.#send, 1, createDiagnosticContext({ client: this, operation: 'send', options }), this, options, callback);
+        return callback[kCallbackPromise];
+    }
+    #initIdempotentProducer(options, callback) {
+        this[kPerformDeduplicated]('initProducerId', deduplicateCallback => {
             this[kPerformWithRetry]('initProducerId', retryCallback => {
                 this[kConnections].getFirstAvailable(this[kBootstrapBrokers], (error, connection) => {
                     if (error) {
-                        callback(error, undefined);
+                        retryCallback(error, undefined);
                         return;
                     }
-                    initProducerIdV5(connection, null, this[kOptions].timeout, options.producerId ?? this[kOptions].producerId ?? 0n, options.producerEpoch ?? this[kOptions].producerEpoch ?? 0, retryCallback);
+                    this[kGetApi]('InitProducerId', (error, api) => {
+                        if (error) {
+                            retryCallback(error, undefined);
+                            return;
+                        }
+                        api(connection, null, this[kOptions].timeout, options.producerId ?? this[kOptions].producerId ?? 0n, options.producerEpoch ?? this[kOptions].producerEpoch ?? 0, retryCallback);
+                    });
                 });
             }, (error, response) => {
                 if (error) {
-                    callback(error, undefined);
+                    deduplicateCallback(error, undefined);
                     return;
                 }
                 this.#producerInfo = { producerId: response.producerId, producerEpoch: response.producerEpoch };
@@ -103,21 +131,9 @@ export class Producer extends Base {
             }, 0);
         }, callback);
     }
-    send(options, callback) {
-        if (!callback) {
-            callback = createPromisifiedCallback();
-        }
-        if (this[kCheckNotClosed](callback)) {
-            return callback[kCallbackPromise];
-        }
-        const validationError = this[kValidateOptions](options, sendOptionsValidator, '/options', false);
-        if (validationError) {
-            callback(validationError, undefined);
-            return callback[kCallbackPromise];
-        }
-        options.idempotent ??= this[kOptions].idempotent ?? false;
-        /* c8 ignore next */
-        options.repeatOnStaleMetadata ??= this[kOptions].repeatOnStaleMetadata ?? true;
+    #send(options, callback) {
+        options.idempotent ??= this[kOptions].idempotent;
+        options.repeatOnStaleMetadata ??= this[kOptions].repeatOnStaleMetadata;
         options.partitioner ??= this[kOptions].partitioner;
         const { idempotent, partitioner } = options;
         if (idempotent) {
@@ -135,17 +151,17 @@ export class Producer extends Base {
                         callback(error, undefined);
                         return;
                     }
-                    this.send(options, callback);
+                    this.#send(options, callback);
                 });
-                return callback[kCallbackPromise];
+                return;
             }
             if (typeof options.producerId !== 'undefined' || typeof options.producerEpoch !== 'undefined') {
                 callback(new UserError('Cannot specify producerId or producerEpoch when using idempotent producer.'), undefined);
-                return callback[kCallbackPromise];
+                return;
             }
             if (options.acks !== ProduceAcks.ALL) {
                 callback(new UserError('Idempotent producer requires acks to be ALL (-1).'), undefined);
-                return callback[kCallbackPromise];
+                return;
             }
         }
         const produceOptions = {
@@ -199,7 +215,6 @@ export class Producer extends Base {
             });
         }
         this.#performSend(Array.from(topics), messages, options, produceOptions, callback);
-        return callback[kCallbackPromise];
     }
     #performSend(topics, messages, sendOptions, produceOptions, callback) {
         // Get the metadata with the topic/partitions informations
@@ -282,7 +297,13 @@ export class Producer extends Base {
                         retryCallback(error, undefined);
                         return;
                     }
-                    produceV11(connection, acks, timeout, messages, produceOptions, retryCallback);
+                    this[kGetApi]('Produce', (error, api) => {
+                        if (error) {
+                            retryCallback(error, undefined);
+                            return;
+                        }
+                        api(connection, acks, timeout, messages, produceOptions, retryCallback);
+                    });
                 });
             }, (error, results) => {
                 if (error) {

package/dist/diagnostic.d.ts

@@ -0,0 +1,47 @@
+import { type TracingChannel } from 'node:diagnostics_channel';
+import { type Base } from './clients/base/base.ts';
+import { type ConnectionPool } from './network/connection-pool.ts';
+import { type Connection } from './network/connection.ts';
+export type ClientType = 'base' | 'producer' | 'consumer' | 'admin';
+export interface CreationEvent<InstanceType> {
+    type: ClientType | 'connection' | 'connectionPool';
+    instance: InstanceType;
+}
+export type ConnectionDiagnosticEvent<Attributes = Record<string, unknown>> = {
+    connection: Connection;
+} & Attributes;
+export type ConnectionPoolDiagnosticEvent<Attributes = Record<string, unknown>> = {
+    connectionPool: ConnectionPool;
+} & Attributes;
+export type ClientDiagnosticEvent<InstanceType extends Base = Base, Attributes = Record<string, unknown>> = {
+    client: InstanceType;
+} & Attributes;
+export type TracingChannelWithName<EventType extends object> = TracingChannel<string, EventType> & {
+    name: string;
+};
+export type DiagnosticContext<BaseContext> = BaseContext & {
+    operationId: bigint;
+    result?: unknown;
+    error?: unknown;
+};
+export declare const channelsNamespace: "plt:kafka";
+export declare function createDiagnosticContext<BaseContext>(context: BaseContext): DiagnosticContext<BaseContext>;
+export declare function notifyCreation<InstanceType>(type: ClientType | 'connection' | 'connection-pool' | 'messages-stream', instance: InstanceType): void;
+export declare function createTracingChannel<DiagnosticEvent extends object>(name: string): TracingChannelWithName<DiagnosticEvent>;
+export declare const instancesChannel: import("diagnostics_channel").Channel<unknown, unknown>;
+export declare const connectionsConnectsChannel: TracingChannelWithName<ConnectionDiagnosticEvent<Record<string, unknown>>>;
+export declare const connectionsApiChannel: TracingChannelWithName<ConnectionDiagnosticEvent<Record<string, unknown>>>;
+export declare const connectionsPoolGetsChannel: TracingChannelWithName<ConnectionPoolDiagnosticEvent<Record<string, unknown>>>;
+export declare const baseApisChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const baseMetadataChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const adminTopicsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const adminGroupsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const producerInitIdempotentChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const producerSendsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerGroupChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerHeartbeatChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerReceivesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerFetchesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerConsumesChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerCommitsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;
+export declare const consumerOffsetsChannel: TracingChannelWithName<ClientDiagnosticEvent<Base<import("./index.ts").BaseOptions>, Record<string, unknown>>>;

package/dist/diagnostic.js

@@ -0,0 +1,38 @@
+import { channel, tracingChannel } from 'node:diagnostics_channel';
+export const channelsNamespace = 'plt:kafka';
+let operationId = 0n;
+export function createDiagnosticContext(context) {
+    return { operationId: operationId++, ...context };
+}
+export function notifyCreation(type, instance) {
+    instancesChannel.publish({ type, instance });
+}
+export function createTracingChannel(name) {
+    name = `${channelsNamespace}:${name}`;
+    const channel = tracingChannel(name);
+    channel.name = name;
+    return channel;
+}
+// Generic channel for objects creation
+export const instancesChannel = channel(`${channelsNamespace}:instances`);
+// Connection related channels
+export const connectionsConnectsChannel = createTracingChannel('connections:connects');
+export const connectionsApiChannel = createTracingChannel('connections:api');
+export const connectionsPoolGetsChannel = createTracingChannel('connections:pool:get');
+// Base channels
+export const baseApisChannel = createTracingChannel('base:apis');
+export const baseMetadataChannel = createTracingChannel('base:metadata');
+// Admin channels
+export const adminTopicsChannel = createTracingChannel('admin:topics');
+export const adminGroupsChannel = createTracingChannel('admin:groups');
+// Producer channels
+export const producerInitIdempotentChannel = createTracingChannel('producer:initIdempotent');
+export const producerSendsChannel = createTracingChannel('producer:sends');
+// Consumer channels
+export const consumerGroupChannel = createTracingChannel('consumer:group');
+export const consumerHeartbeatChannel = createTracingChannel('consumer:heartbeat');
+export const consumerReceivesChannel = createTracingChannel('consumer:receives');
+export const consumerFetchesChannel = createTracingChannel('consumer:fetches');
+export const consumerConsumesChannel = createTracingChannel('consumer:consumes');
+export const consumerCommitsChannel = createTracingChannel('consumer:commits');
+export const consumerOffsetsChannel = createTracingChannel('consumer:offsets');

package/dist/errors.d.ts

@@ -1,7 +1,7 @@
 declare const kGenericError: unique symbol;
 declare const kMultipleErrors: unique symbol;
 export declare const ERROR_PREFIX = "PLT_KFK_";
-export declare const errorCodes: readonly ["PLT_KFK_AUTHENTICATION", "PLT_KFK_MULTIPLE", "PLT_KFK_NETWORK", "PLT_KFK_PROTOCOL", "PLT_KFK_RESPONSE", "PLT_KFK_TIMEOUT", "PLT_KFK_UNEXPECTED_CORRELATION_ID", "PLT_KFK_UNFINISHED_WRITE_BUFFER", "PLT_KFK_UNSUPPORTED_COMPRESSION", "PLT_KFK_UNSUPPORTED", "PLT_KFK_USER"];
+export declare const errorCodes: readonly ["PLT_KFK_AUTHENTICATION", "PLT_KFK_MULTIPLE", "PLT_KFK_NETWORK", "PLT_KFK_PROTOCOL", "PLT_KFK_RESPONSE", "PLT_KFK_TIMEOUT", "PLT_KFK_UNEXPECTED_CORRELATION_ID", "PLT_KFK_UNFINISHED_WRITE_BUFFER", "PLT_KFK_UNSUPPORTED_API", "PLT_KFK_UNSUPPORTED_COMPRESSION", "PLT_KFK_UNSUPPORTED", "PLT_KFK_USER"];
 export type ErrorCode = (typeof errorCodes)[number];
 export type ErrorProperties = {
     cause?: Error;
@@ -53,6 +53,10 @@ export declare class UnfinishedWriteBufferError extends GenericError {
     static code: ErrorCode;
     constructor(message: string, properties?: ErrorProperties);
 }
+export declare class UnsupportedApiError extends GenericError {
+    static code: ErrorCode;
+    constructor(message: string, properties?: ErrorProperties);
+}
 export declare class UnsupportedCompressionError extends GenericError {
     static code: ErrorCode;
     constructor(message: string, properties?: ErrorProperties);