@message-queue-toolkit/kafka/dist/AbstractKafkaService.js

Kafka adapter for message-queue-toolkit

import { types } from 'node:util';
import { resolveGlobalErrorLogObject, stringValueSerializer, } from '@lokalise/node-core';
import { resolveHandlerSpy, } from '@message-queue-toolkit/core';
export class AbstractKafkaService {
    errorReporter;
    logger;
    messageMetricsManager;
    options;
    _handlerSpy;
    constructor(dependencies, options) {
        this.logger = dependencies.logger;
        this.errorReporter = dependencies.errorReporter;
        this.messageMetricsManager = dependencies.messageMetricsManager;
        this.options = { ...options, messageIdField: options.messageIdField ?? 'id' };
        this._handlerSpy = resolveHandlerSpy(options);
    }
    get handlerSpy() {
        if (this._handlerSpy)
            return this._handlerSpy;
        throw new Error('HandlerSpy was not instantiated, please pass `handlerSpy` parameter during creation.');
    }
    resolveMessageType(message) {
        if (!this.options.messageTypeField)
            return undefined;
        // @ts-expect-error
        return message[this.options.messageTypeField];
    }
    resolveMessageId(message) {
        // @ts-expect-error
        return message[this.options.messageIdField];
    }
    resolveHeaderRequestIdField() {
        return this.options.headerRequestIdField ?? 'x-request-id';
    }
    handleMessageProcessed(params) {
        const { message, processingResult } = params;
        const messageId = this.resolveMessageId(message.value);
        const messageType = this.resolveMessageType(message.value);
        this._handlerSpy?.addProcessedMessage({ message: message.value, processingResult }, messageId);
        if (this.options.logMessages) {
            this.logger.debug({
                message: stringValueSerializer(message.value),
                topic: message.topic,
                processingResult,
                messageId,
                messageType,
            }, `Finished processing message ${messageId}`);
        }
        if (this.messageMetricsManager) {
            this.messageMetricsManager.registerProcessedMessage({
                message: message.value,
                processingResult,
                queueName: message.topic,
                messageId: messageId ?? 'unknown',
                messageType: messageType ?? 'unknown',
                messageTimestamp: message.timestamp ? Number(message.timestamp) : undefined,
                messageProcessingStartTimestamp: params.messageProcessingStartTimestamp,
                messageProcessingEndTimestamp: Date.now(),
            });
        }
    }
    handlerError(error, context = {}) {
        this.logger.error({ ...resolveGlobalErrorLogObject(error), ...context });
        if (types.isNativeError(error))
            this.errorReporter.report({ error, context });
    }
}
//# sourceMappingURL=AbstractKafkaService.js.map