kafka-ts 0.0.1-beta.3 → 0.0.1-beta.4

package/src/cluster.ts

@@ -3,7 +3,8 @@ import { TLSSocketOptions } from 'tls';
 import { API } from './api';
 import { Broker, SASLProvider } from './broker';
 import { SendRequest } from './connection';
-import { ConnectionError, KafkaTSError } from './utils/error';
+import { KafkaTSError } from './utils/error';
+import { log } from './utils/logger';
 
 type ClusterOptions = {
     clientId: string | null;
@@ -13,73 +14,77 @@ type ClusterOptions = {
 };
 
 export class Cluster {
-    private seedBroker: Broker;
-    private brokerById: Record<number, Broker> = {};
+    private seedBroker = new Broker({ clientId: null, sasl: null, ssl: null, options: { port: 9092 } });
+    private brokers: { nodeId: number; broker: Broker }[] = [];
+    private brokerMetadata: Record<number, Awaited<ReturnType<(typeof API.METADATA)['response']>>['brokers'][number]> =
+        {};
 
-    constructor(private options: ClusterOptions) {
-        this.seedBroker = new Broker({
-            clientId: this.options.clientId,
-            sasl: this.options.sasl,
-            ssl: this.options.ssl,
-            options: this.options.bootstrapServers[0],
-        });
-    }
+    constructor(private options: ClusterOptions) {}
 
     public async connect() {
-        await this.connectSeedBroker();
+        this.seedBroker = await this.findSeedBroker();
+
         const metadata = await this.sendRequest(API.METADATA, {
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
             topics: [],
         });
-
-        this.brokerById = Object.fromEntries(
-            metadata.brokers.map(({ nodeId, ...options }) => [
-                nodeId,
-                new Broker({
-                    clientId: this.options.clientId,
-                    sasl: this.options.sasl,
-                    ssl: this.options.ssl,
-                    options,
-                }),
-            ]),
-        );
-        return this;
+        this.brokerMetadata = Object.fromEntries(metadata.brokers.map((options) => [options.nodeId, options]));
     }
 
     public async disconnect() {
-        await Promise.all([
-            this.seedBroker.disconnect(),
-            ...Object.values(this.brokerById).map((broker) => broker.disconnect()),
-        ]);
+        await Promise.all(this.brokers.map((x) => x.broker.disconnect()));
     }
 
+    public setSeedBroker = async (nodeId: number) => {
+        await this.releaseBroker(this.seedBroker);
+        this.seedBroker = await this.acquireBroker(nodeId);
+    };
+
     public sendRequest: SendRequest = (...args) => this.seedBroker.sendRequest(...args);
 
     public sendRequestToNode =
         (nodeId: number): SendRequest =>
         async (...args) => {
-            const broker = this.brokerById[nodeId];
+            let broker = this.brokers.find((x) => x.nodeId === nodeId)?.broker;
             if (!broker) {
-                throw new ConnectionError(`Broker ${nodeId} is not available`);
+                broker = await this.acquireBroker(nodeId);
             }
-            await broker.ensureConnected();
             return broker.sendRequest(...args);
         };
 
-    private async connectSeedBroker() {
+    public async acquireBroker(nodeId: number) {
+        const broker = new Broker({
+            clientId: this.options.clientId,
+            sasl: this.options.sasl,
+            ssl: this.options.ssl,
+            options: this.brokerMetadata[nodeId],
+        });
+        this.brokers.push({ nodeId, broker });
+        await broker.connect();
+        return broker;
+    }
+
+    public async releaseBroker(broker: Broker) {
+        await broker.disconnect();
+        this.brokers = this.brokers.filter((x) => x.broker !== broker);
+    };
+
+    private async findSeedBroker() {
         const randomizedBrokers = this.options.bootstrapServers.toSorted(() => Math.random() - 0.5);
         for (const options of randomizedBrokers) {
             try {
-                this.seedBroker = await new Broker({
+                const broker = await new Broker({
                     clientId: this.options.clientId,
                     sasl: this.options.sasl,
                     ssl: this.options.ssl,
                     options,
-                }).connect();
-                return;
+                });
+                await broker.connect();
+                this.brokers.push({ nodeId: -1, broker });
+                return broker;
             } catch (error) {
-                console.warn(`Failed to connect to seed broker ${options.host}:${options.port}`, error);
+                log.warn(`Failed to connect to seed broker ${options.host}:${options.port}`, error);
             }
         }
         throw new KafkaTSError('No seed brokers found');

package/src/codecs/gzip.ts

@@ -0,0 +1,9 @@
+import { gzip, unzip } from 'zlib';
+import { Codec } from './types';
+
+export const GZIP: Codec = {
+    compress: async (data) =>
+        new Promise<Buffer>((resolve, reject) => gzip(data, (err, result) => (err ? reject(err) : resolve(result)))),
+    decompress: async (data) =>
+        new Promise<Buffer>((resolve, reject) => unzip(data, (err, result) => (err ? reject(err) : resolve(result)))),
+};

package/src/codecs/index.ts

@@ -0,0 +1,16 @@
+import { GZIP } from './gzip';
+import { NONE } from './none';
+import { Codec } from './types';
+
+const codecs: Record<number, Codec> = {
+    0: NONE,
+    1: GZIP,
+};
+
+export const findCodec = (type: number) => {
+    const codec = codecs[type];
+    if (!codec) {
+        throw new Error(`Unsupported codec: ${type}`);
+    }
+    return codec;
+};

package/src/codecs/none.ts

@@ -0,0 +1,6 @@
+import { Codec } from './types';
+
+export const NONE: Codec = {
+    compress: (data: Buffer) => Promise.resolve(data),
+    decompress: (data: Buffer) => Promise.resolve(data),
+};

package/src/codecs/types.ts

@@ -0,0 +1,4 @@
+export type Codec = {
+    compress: (data: Buffer) => Promise<Buffer>;
+    decompress: (data: Buffer) => Promise<Buffer>;
+};

package/src/connection.ts

@@ -59,6 +59,7 @@ export class Connection {
         });
     }
 
+    @trace()
     public disconnect() {
         this.socket.removeAllListeners();
         return new Promise<void>((resolve) => {
@@ -69,7 +70,7 @@ export class Connection {
         });
     }
 
-    @trace((api, body) => ({ apiName: getApiName(api), body }))
+    @trace((api, body) => ({ message: getApiName(api), body }))
     public async sendRequest<Request, Response>(api: Api<Request, Response>, body: Request): Promise<Response> {
         const correlationId = this.nextCorrelationId();
 
@@ -90,7 +91,7 @@ export class Connection {
                 reject(error);
             }
         });
-        const response = api.response(responseDecoder);
+        const response = await api.response(responseDecoder);
 
         assert(
             responseDecoder.getOffset() - 4 === responseSize,

package/src/consumer/consumer-group.ts

@@ -30,6 +30,8 @@ export class ConsumerGroup {
 
     public async join() {
         await this.findCoordinator();
+        await this.options.cluster.setSeedBroker(this.coordinatorId);
+
         await this.joinGroup();
         await this.syncGroup();
         await this.offsetFetch();
@@ -70,7 +72,7 @@ export class ConsumerGroup {
     private async joinGroup(): Promise<void> {
         const { cluster, groupId, groupInstanceId, sessionTimeoutMs, rebalanceTimeoutMs, topics } = this.options;
         try {
-            const response = await cluster.sendRequestToNode(this.coordinatorId)(API.JOIN_GROUP, {
+            const response = await cluster.sendRequest(API.JOIN_GROUP, {
                 groupId,
                 groupInstanceId,
                 memberId: this.memberId,
@@ -113,7 +115,7 @@ export class ConsumerGroup {
             assignments = Object.entries(memberAssignments).map(([memberId, assignment]) => ({ memberId, assignment }));
         }
 
-        const response = await cluster.sendRequestToNode(this.coordinatorId)(API.SYNC_GROUP, {
+        const response = await cluster.sendRequest(API.SYNC_GROUP, {
             groupId,
             groupInstanceId,
             memberId: this.memberId,
@@ -144,7 +146,7 @@ export class ConsumerGroup {
         };
         if (!request.groups.length) return;
 
-        const response = await cluster.sendRequestToNode(this.coordinatorId)(API.OFFSET_FETCH, request);
+        const response = await cluster.sendRequest(API.OFFSET_FETCH, request);
         response.groups.forEach((group) => {
             group.topics.forEach((topic) => {
                 topic.partitions
@@ -177,13 +179,13 @@ export class ConsumerGroup {
         if (!request.topics.length) {
             return;
         }
-        await cluster.sendRequestToNode(this.coordinatorId)(API.OFFSET_COMMIT, request);
+        await cluster.sendRequest(API.OFFSET_COMMIT, request);
         offsetManager.flush();
     }
 
     public async heartbeat() {
         const { cluster, groupId, groupInstanceId } = this.options;
-        await cluster.sendRequestToNode(this.coordinatorId)(API.HEARTBEAT, {
+        await cluster.sendRequest(API.HEARTBEAT, {
             groupId,
             groupInstanceId,
             memberId: this.memberId,
@@ -195,7 +197,7 @@ export class ConsumerGroup {
         const { cluster, groupId, groupInstanceId } = this.options;
         this.stopHeartbeater();
         try {
-            await cluster.sendRequestToNode(this.coordinatorId)(API.LEAVE_GROUP, {
+            await cluster.sendRequest(API.LEAVE_GROUP, {
                 groupId,
                 members: [{ memberId: this.memberId, groupInstanceId, reason: null }],
             });

package/src/consumer/consumer.ts

@@ -2,16 +2,19 @@ import { API, API_ERROR } from '../api';
 import { IsolationLevel } from '../api/fetch';
 import { Assignment } from '../api/sync-group';
 import { Cluster } from '../cluster';
-import { distributeAssignmentsToNodes } from '../distributors/assignments-to-replicas';
+import { distributeMessagesToTopicPartitionLeaders } from '../distributors/messages-to-topic-partition-leaders';
 import { Message } from '../types';
 import { delay } from '../utils/delay';
 import { ConnectionError, KafkaTSApiError } from '../utils/error';
-import { defaultRetrier, Retrier } from '../utils/retrier';
+import { log } from '../utils/logger';
+import { createTracer } from '../utils/tracer';
 import { ConsumerGroup } from './consumer-group';
 import { ConsumerMetadata } from './consumer-metadata';
-import { FetchManager, BatchGranularity } from './fetch-manager';
+import { BatchGranularity, FetchManager } from './fetch-manager';
 import { OffsetManager } from './offset-manager';
 
+const trace = createTracer('Consumer');
+
 export type ConsumerOptions = {
     topics: string[];
     groupId?: string | null;
@@ -26,7 +29,6 @@ export type ConsumerOptions = {
     partitionMaxBytes?: number;
     allowTopicAutoCreation?: boolean;
     fromBeginning?: boolean;
-    retrier?: Retrier;
     batchGranularity?: BatchGranularity;
     concurrency?: number;
 } & ({ onBatch: (messages: Required<Message>[]) => unknown } | { onMessage: (message: Required<Message>) => unknown });
@@ -57,7 +59,6 @@ export class Consumer {
             isolationLevel: options.isolationLevel ?? IsolationLevel.READ_UNCOMMITTED,
             allowTopicAutoCreation: options.allowTopicAutoCreation ?? false,
             fromBeginning: options.fromBeginning ?? false,
-            retrier: options.retrier ?? defaultRetrier,
             batchGranularity: options.batchGranularity ?? 'partition',
             concurrency: options.concurrency ?? 1,
         };
@@ -94,16 +95,17 @@ export class Consumer {
             await this.offsetManager.fetchOffsets({ fromBeginning });
             await this.consumerGroup?.join();
         } catch (error) {
-            console.error(error);
-            console.debug(`Restarting consumer in 1 second...`);
+            log.error('Failed to start consumer', error);
+            log.debug(`Restarting consumer in 1 second...`);
             await delay(1000);
 
             if (this.stopHook) return (this.stopHook as () => void)();
             return this.close(true).then(() => this.start());
         }
-        setImmediate(() => this.startFetchManager());
+        this.startFetchManager();
     }
 
+    @trace()
     public async close(force = false): Promise<void> {
         if (!force) {
             await new Promise<void>(async (resolve) => {
@@ -111,22 +113,31 @@ export class Consumer {
                 await this.fetchManager?.stop();
             });
         }
-        await this.consumerGroup
-            ?.leaveGroup()
-            .catch((error) => console.warn(`Failed to leave group: ${error.message}`));
-        await this.cluster.disconnect().catch((error) => console.warn(`Failed to disconnect: ${error.message}`));
+        await this.consumerGroup?.leaveGroup().catch((error) => log.warn(`Failed to leave group: ${error.message}`));
+        await this.cluster.disconnect().catch((error) => log.warn(`Failed to disconnect: ${error.message}`));
     }
 
     private startFetchManager = async () => {
         const { batchGranularity, concurrency } = this.options;
 
         while (!this.stopHook) {
+            // TODO: If leader is not available, find another read replica
             const nodeAssignments = Object.entries(
-                distributeAssignmentsToNodes(
-                    this.metadata.getAssignment(),
-                    this.metadata.getTopicPartitionReplicaIds(),
+                distributeMessagesToTopicPartitionLeaders(
+                    Object.entries(this.metadata.getAssignment()).flatMap(([topic, partitions]) =>
+                        partitions.map((partition) => ({ topic, partition })),
+                    ),
+                    this.metadata.getTopicPartitionLeaderIds(),
+                ),
+            ).map(([nodeId, assignment]) => ({
+                nodeId: parseInt(nodeId),
+                assignment: Object.fromEntries(
+                    Object.entries(assignment).map(([topic, partitions]) => [
+                        topic,
+                        Object.keys(partitions).map(Number),
+                    ]),
                 ),
-            ).map(([nodeId, assignment]) => ({ nodeId: parseInt(nodeId), assignment }));
+            }));
 
             const numPartitions = Object.values(this.metadata.getAssignment()).flat().length;
             const numProcessors = Math.min(concurrency, numPartitions);
@@ -145,7 +156,7 @@ export class Consumer {
                 await this.fetchManager.start();
 
                 if (!nodeAssignments.length) {
-                    console.debug('No partitions assigned. Waiting for reassignment...');
+                    log.debug('No partitions assigned. Waiting for reassignment...');
                     await delay(this.options.maxWaitMs);
                     await this.consumerGroup?.handleLastHeartbeat();
                 }
@@ -153,11 +164,11 @@ export class Consumer {
                 await this.fetchManager.stop();
 
                 if ((error as KafkaTSApiError).errorCode === API_ERROR.REBALANCE_IN_PROGRESS) {
-                    console.debug('Rebalance in progress...');
+                    log.debug('Rebalance in progress...');
                     continue;
                 }
                 if ((error as KafkaTSApiError).errorCode === API_ERROR.FENCED_INSTANCE_ID) {
-                    console.debug('New consumer with the same groupInstanceId joined. Exiting the consumer...');
+                    log.debug('New consumer with the same groupInstanceId joined. Exiting the consumer...');
                     this.close();
                     break;
                 }
@@ -165,11 +176,11 @@ export class Consumer {
                     error instanceof ConnectionError ||
                     (error instanceof KafkaTSApiError && error.errorCode === API_ERROR.NOT_COORDINATOR)
                 ) {
-                    console.debug(`${error.message}. Restarting consumer...`);
+                    log.debug(`${error.message}. Restarting consumer...`);
                     this.close().then(() => this.start());
                     break;
                 }
-                console.error(error);
+                log.error((error as Error).message, error);
                 this.close();
                 break;
             }
@@ -177,12 +188,12 @@ export class Consumer {
         this.stopHook?.();
     };
 
+    @trace()
     private async process(messages: Required<Message>[]) {
         const { options } = this;
-        const { retrier } = options;
 
         if ('onBatch' in options) {
-            await retrier(() => options.onBatch(messages));
+            await options.onBatch(messages);
 
             messages.forEach(({ topic, partition, offset }) =>
                 this.offsetManager.resolve(topic, partition, offset + 1n),
@@ -190,7 +201,7 @@ export class Consumer {
         } else if ('onMessage' in options) {
             try {
                 for (const message of messages) {
-                    await retrier(() => options.onMessage(message));
+                    await options.onMessage(message);
 
                     const { topic, partition, offset } = message;
                     this.offsetManager.resolve(topic, partition, offset + 1n);

package/src/consumer/fetch-manager.ts

@@ -14,7 +14,7 @@ const trace = createTracer('FetchManager');
 export type BatchGranularity = 'partition' | 'topic' | 'broker';
 
 type FetchManagerOptions = {
-    fetch: (nodeId: number, assignment: Assignment) => Promise<ReturnType<(typeof API.FETCH)['response']>>;
+    fetch: (nodeId: number, assignment: Assignment) => Promise<Awaited<ReturnType<(typeof API.FETCH)['response']>>>;
     process: (batch: Batch) => Promise<void>;
     metadata: Metadata;
     consumerGroup?: ConsumerGroup;
@@ -86,6 +86,7 @@ export class FetchManager extends EventEmitter<{ data: []; checkpoint: [number];
 
         const batch = this.queue.shift();
         if (!batch) {
+            // wait until new data is available or fetch manager is requested to stop
             await new Promise<void>((resolve) => {
                 const onData = () => {
                     this.removeListener('stop', onStop);
@@ -109,35 +110,40 @@ export class FetchManager extends EventEmitter<{ data: []; checkpoint: [number];
         return batch as Exclude<Entry, Checkpoint>;
     }
 
-    private async onResponse(fetcherId: number, response: ReturnType<(typeof API.FETCH)['response']>) {
+    private async onResponse(fetcherId: number, response: Awaited<ReturnType<(typeof API.FETCH)['response']>>) {
         const { metadata, batchGranularity } = this.options;
 
         const batches = fetchResponseToBatches(response, batchGranularity, metadata);
-        if (batches.length) {
+        if (!batches.length) {
+            return;
+        }
+
+        // wait until all broker batches have been processed or fetch manager is requested to stop
+        await new Promise<void>((resolve) => {
+            const onCheckpoint = (id: number) => {
+                if (id === fetcherId) {
+                    this.removeListener('checkpoint', onCheckpoint);
+                    this.removeListener('stop', onStop);
+                    resolve();
+                }
+            };
+            const onStop = () => {
+                this.removeListener('checkpoint', onCheckpoint);
+                resolve();
+            };
+            this.on('checkpoint', onCheckpoint);
+            this.once('stop', onStop);
+
             this.queue.push(...batches);
             this.queue.push({ kind: 'checkpoint', fetcherId });
 
             this.emit('data');
-            await new Promise<void>((resolve) => {
-                const onCheckpoint = (id: number) => {
-                    if (id === fetcherId) {
-                        this.removeListener('stop', onStop);
-                        resolve();
-                    }
-                };
-                const onStop = () => {
-                    this.removeListener('checkpoint', onCheckpoint);
-                    resolve();
-                };
-                this.once('checkpoint', onCheckpoint);
-                this.once('stop', onStop);
-            });
-        }
+        });
     }
 }
 
 const fetchResponseToBatches = (
-    batch: ReturnType<typeof API.FETCH.response>,
+    batch: Awaited<ReturnType<typeof API.FETCH.response>>,
     batchGranularity: BatchGranularity,
     metadata: Metadata,
 ): Batch[] => {

package/src/consumer/fetcher.ts

@@ -10,8 +10,8 @@ type FetcherOptions = {
     nodeId: number;
     assignment: Assignment;
     consumerGroup?: ConsumerGroup;
-    fetch: (nodeId: number, assignment: Assignment) => Promise<ReturnType<(typeof API.FETCH)['response']>>;
-    onResponse: (fetcherId: number, response: ReturnType<(typeof API.FETCH)['response']>) => Promise<void>;
+    fetch: (nodeId: number, assignment: Assignment) => Promise<Awaited<ReturnType<(typeof API.FETCH)['response']>>>;
+    onResponse: (fetcherId: number, response: Awaited<ReturnType<(typeof API.FETCH)['response']>>) => Promise<void>;
 };
 
 export class Fetcher extends EventEmitter<{ stop: []; stopped: []; data: []; drain: [] }> {
@@ -26,10 +26,10 @@ export class Fetcher extends EventEmitter<{ stop: []; stopped: []; data: []; dra
 
     public async loop() {
         const { nodeId, assignment, consumerGroup, fetch, onResponse } = this.options;
-
+        
         this.isRunning = true;
         this.once('stop', () => (this.isRunning = false));
-
+        
         try {
             while (this.isRunning) {
                 const response = await fetch(nodeId, assignment);

package/src/consumer/processor.ts

@@ -25,7 +25,9 @@ export class Processor extends EventEmitter<{ stop: []; stopped: [] }> {
         try {
             while (this.isRunning) {
                 const batch = await poll();
-                await process(batch);
+                if (batch.length) {
+                    await process(batch);
+                }
             }
         } finally {
             this.isRunning = false;

package/src/index.ts

@@ -5,3 +5,5 @@ export * from './client';
 export * from './distributors/partitioner';
 export * from './types';
 export * from './utils/error';
+export * from './utils/logger';
+

package/src/producer/producer.ts

@@ -34,7 +34,7 @@ export class Producer {
         this.partition = this.options.partitioner({ metadata: this.metadata });
     }
 
-    public async send(messages: Message[]) {
+    public async send(messages: Message[], { acks = -1 }: { acks?: -1 | 1 } = {}) {
         await this.ensureConnected();
 
         const { allowTopicAutoCreation } = this.options;
@@ -44,7 +44,7 @@ export class Producer {
         await this.metadata.fetchMetadataIfNecessary({ topics, allowTopicAutoCreation });
 
         const nodeTopicPartitionMessages = distributeMessagesToTopicPartitionLeaders(
-            messages.map(message => ({ ...message, partition: this.partition(message) })),
+            messages.map((message) => ({ ...message, partition: this.partition(message) })),
             this.metadata.getTopicPartitionLeaderIds(),
         );
 
@@ -52,7 +52,7 @@ export class Producer {
             Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
                 await this.cluster.sendRequestToNode(parseInt(nodeId))(API.PRODUCE, {
                     transactionalId: null,
-                    acks: 1,
+                    acks,
                     timeoutMs: 5000,
                     topicData: Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
                         name: topic,

package/src/utils/api.ts

@@ -5,7 +5,7 @@ export type Api<Request, Response> = {
     apiKey: number;
     apiVersion: number;
     request: (encoder: Encoder, body: Request) => Encoder;
-    response: (buffer: Decoder) => Response;
+    response: (buffer: Decoder) => Promise<Response> | Response;
 };
 
 export const createApi = <Request, Response>(api: Api<Request, Response>) => api;

package/src/utils/decoder.ts

@@ -7,6 +7,10 @@ export class Decoder {
         return this.offset;
     }
 
+    public getBuffer() {
+        return this.buffer;
+    }
+
     public getBufferLength() {
         return this.buffer.length;
     }
@@ -132,6 +136,12 @@ export class Decoder {
         return results;
     }
 
+    public readVarIntArray<T>(callback: (opts: Decoder) => T): T[] {
+        const length = this.readVarInt();
+        const results = Array.from({ length }).map(() => callback(this));
+        return results;
+    }
+
     public readRecords<T>(callback: (opts: Decoder) => T): T[] {
         const length = this.readInt32();
 
@@ -143,9 +153,9 @@ export class Decoder {
         });
     }
 
-    public read(length: number) {
-        const value = this.buffer.subarray(this.offset, this.offset + length);
-        this.offset += length;
+    public read(length?: number) {
+        const value = this.buffer.subarray(this.offset, length !== undefined ? this.offset + length : undefined);
+        this.offset += Buffer.byteLength(value);
         return value;
     }
 

package/src/utils/logger.ts

@@ -0,0 +1,37 @@
+export interface Logger {
+    debug: (message: string, metadata?: unknown) => void;
+    info: (message: string, metadata?: unknown) => void;
+    warn: (message: string, metadata?: unknown) => void;
+    error: (message: string, metadata?: unknown) => void;
+}
+
+export const jsonSerializer = (_: unknown, v: unknown) => {
+    if (v instanceof Error) {
+        return { name: v.name, message: v.message, stack: v.stack, cause: v.cause };
+    }
+    if (typeof v === 'bigint') {
+        return v.toString();
+    }
+    return v;
+};
+
+class JsonLogger implements Logger {
+    debug(message: string, metadata?: unknown) {
+        console.debug(JSON.stringify({ message, metadata }, jsonSerializer));
+    }
+    info(message: string, metadata?: unknown) {
+        console.info(JSON.stringify({ message, metadata }, jsonSerializer));
+    }
+    warn(message: string, metadata?: unknown) {
+        console.warn(JSON.stringify({ message, metadata }, jsonSerializer));
+    }
+    error(message: string, metadata?: unknown) {
+        console.error(JSON.stringify({ message, metadata }, jsonSerializer));
+    }
+}
+
+export let log: Logger = new JsonLogger();
+
+export const setLogger = (newLogger: Logger) => {
+    log = newLogger;
+};