@nsshunt/stsappframework 3.0.176 → 3.0.178

package/src/influxdb/influxDBManagerService.ts

@@ -142,6 +142,10 @@ export class InfluxDBManagerService extends InfluxDBManagerBase
         super(options, queryApi);
     }
 
+    #LogErrorMessage(message: any) {
+        this.options.logger.error(message);
+    }
+
     override get modelType(): string {
         return 'service'
     }
@@ -184,7 +188,7 @@ data
 
             return this.queryApi.collectRows(query)
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}#GetSTSCountGeneric: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}#GetSTSCountGeneric: Error: [${error}]`));
         }
     }
 
@@ -200,7 +204,7 @@ data
             |> difference()`;
             return this.queryApi.collectRows(query)
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}#GetSTSHistoGeneric: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}#GetSTSHistoGeneric: Error: [${error}]`));
         }
     }
 
@@ -231,7 +235,7 @@ data
             
             return this.queryApi.collectRows(query)
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}#GetSTSQuantileGeneric: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}#GetSTSQuantileGeneric: Error: [${error}]`));
         }
     }
 
@@ -246,7 +250,7 @@ data
                 this.#GetSTSHistoGenericService(SERVICE_STATS_GLOBAL, '')],
             [ ])
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}GetInfluxDBResultsRoot: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}GetInfluxDBResultsRoot: Error: [${error}]`));
         }
         return { 
             subscriptionKey,
@@ -264,7 +268,7 @@ data
                 this.#GetSTSHistoGenericService(SERVICE_STATS_BY_SERVICE, '')],
             ['serviceId'])
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}GetInfluxDBResultsService: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}GetInfluxDBResultsService: Error: [${error}]`));
         }
         return { 
             subscriptionKey,
@@ -284,7 +288,7 @@ data
                 this.#GetSTSHistoGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE, `and r["serviceId"] == "${serviceId}"`)],
             ['serviceId', 'serviceInstanceId'])
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}GetInfluxDBResultsServiceInstances: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}GetInfluxDBResultsServiceInstances: Error: [${error}]`));
         }
         return { 
             subscriptionKey,
@@ -304,7 +308,7 @@ data
                 this.#GetSTSHistoGenericService(SERVICE_STATS_BY_SERVICE_INSTANCE_PROCESS, `and r["serviceInstanceId"] == "${serviceInstanceId}"`)],
             ['serviceId', 'serviceInstanceId', 'serviceInstanceProcessId'])
         } catch (error) {
-            console.error(chalk.red(`${_logPrefix}GetInfluxDBResultsServiceInstance: Error: [${error}]`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}GetInfluxDBResultsServiceInstance: Error: [${error}]`));
         }
         return { 
             subscriptionKey,
@@ -370,12 +374,12 @@ data
 
                 return true;
             } catch (error: any) {
-                console.error(chalk.red(`${_logPrefix}OutputInfluxDB: Could not write data point: [${error}]`));
-                console.error(chalk.red(`${JSON.stringify(instrumentPayload.context)}`));
+                this.#LogErrorMessage(chalk.red(`${_logPrefix}OutputInfluxDB: Could not write data point: [${error}]`));
+                this.#LogErrorMessage(chalk.red(`${JSON.stringify(instrumentPayload.context)}`));
                 return false;
             }
         } else {
-            console.error(chalk.red(`${_logPrefix}OutputInfluxDBService: Could not write data point as writeClient is null`));
+            this.#LogErrorMessage(chalk.red(`${_logPrefix}OutputInfluxDBService: Could not write data point as writeClient is null`));
             return false;
         }
     }

package/src/instrumentationsubscriber.ts

@@ -1,7 +1,4 @@
-import debugModule from 'debug'
-const debug = debugModule(`proc:${process.pid}`);
-
-import { IKafkaConsumer, logFunction } from './commonTypes'
+import { IKafkaConsumer } from './commonTypes'
 import { ISubscriptionPayload, ISubscriptionKey, SubscriptionTopic, IKafkaData } from '@nsshunt/stssocketio-client'
 
 import { KafkaManager, IKafkaManagerConfig } from './kafka/kafkamanager'
@@ -9,7 +6,7 @@ import { InfluxDBManager } from './influxdb/influxDBManager'
 import { v4 as uuidv4 } from 'uuid';
 
 import { $Options } from '@nsshunt/stsconfig'
-import { STSOptionsBase } from '@nsshunt/stsutils';
+import { STSOptionsBase, ISTSLogger } from '@nsshunt/stsutils';
 
 import chalk from 'chalk';
 
@@ -32,7 +29,7 @@ declare type ISubscriptions = Record<string, ISubscription>;
 
 export interface IInstrumentationSubscriberOptions {
     SubscriptionInterval: number
-    logger?: logFunction
+    logger: ISTSLogger
 }
 
 /**
@@ -43,17 +40,12 @@ export class InstrumentationSubscriber extends STSOptionsBase {
     #influxDBManager: InfluxDBManager;
     #timeout: NodeJS.Timer | null = null;
     #km: KafkaManager;
-    #logger: logFunction | null = null;
     #stop: boolean = true;
 
     constructor(options: IInstrumentationSubscriberOptions) {
         super(options);
 
-        if (options.logger) {
-            this.#logger = options.logger;
-        }
-
-        this.#influxDBManager = new InfluxDBManager();
+        this.#influxDBManager = new InfluxDBManager(this.options?.logger);
 
         const kmc: IKafkaManagerConfig = {
             clientId: `${goptions.kafka_clientId}_${uuidv4()}`,
@@ -63,7 +55,8 @@ export class InstrumentationSubscriber extends STSOptionsBase {
             connectionTimeout: goptions.kafka_connection_timeout,
             logLevel: goptions.kafka_log_level,
             useSSL: goptions.kafka_use_ssl,
-            requestTimeout: goptions.kafka_request_timeout
+            requestTimeout: goptions.kafka_request_timeout,
+            logger: this.options?.logger
         }
         if (goptions.kafka_use_ssl) {
             kmc.ssl = {
@@ -77,12 +70,8 @@ export class InstrumentationSubscriber extends STSOptionsBase {
     }
 
     // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-    #Log(msg: any): void {
-        if (this.#logger) {
-            this.#logger(msg);
-        } else {
-            debug(msg);
-        }
+    #LogDebugMessage(message: any) {
+        this.options?.logger.debug(message);
     }
 
     async #UnSubscribeKafka(subscription: ISubscription): Promise<void> {
@@ -90,19 +79,19 @@ export class InstrumentationSubscriber extends STSOptionsBase {
             const kafka = subscription.kafka;
             if (kafka) {
                 // Un-Subscribe from this kafka topic
-                this.#Log(chalk.yellow(`InstrumentationSubscriber:#UnSubscribeKafka(): Unsubscribe from Kafka topc: [${kafka.kafkaTopic}] Starting`));
+                this.#LogDebugMessage(chalk.yellow(`InstrumentationSubscriber:#UnSubscribeKafka(): Unsubscribe from Kafka topc: [${kafka.kafkaTopic}] Starting`));
                 
                 await kafka.kafkaConsumer?.Stop((error) => {
-                    this.#Log(chalk.red(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Stop Error: [${error}]`));
+                    this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Stop Error: [${error}]`));
                 });
 
                 await kafka.kafkaConsumer?.Disconnect((error) => {
-                    this.#Log(chalk.red(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Disconnect Error: [${error}]`));
+                    this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Disconnect Error: [${error}]`));
                 });
                 
-                this.#Log(chalk.yellow(`InstrumentationSubscriber:#UnSubscribeKafka(): Unsubscribe from Kafka topc: [${kafka.kafkaTopic}] Completed.`));
+                this.#LogDebugMessage(chalk.yellow(`InstrumentationSubscriber:#UnSubscribeKafka(): Unsubscribe from Kafka topc: [${kafka.kafkaTopic}] Completed.`));
             } else {
-                this.#Log(chalk.magenta(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka details do not exist for this topc: [${JSON.stringify(subscription.subscriptionKey)}].`));
+                this.#LogDebugMessage(chalk.magenta(`InstrumentationSubscriber:#UnSubscribeKafka(): Kafka details do not exist for this topc: [${JSON.stringify(subscription.subscriptionKey)}].`));
             }
         };
         return unsubscribeKafka();
@@ -121,20 +110,20 @@ export class InstrumentationSubscriber extends STSOptionsBase {
                     kafkaConsumer: this.#km.CreateConsumer(kafkaGroupId),
                     kafkaFromBeginning: goptions.kafka_consume_from_beginning
                 };
-                this.#Log(chalk.yellow(`InstrumentationSubscriber:#SubscribeKafka(): Subscribe to Kafka topc: [${subscription.kafka.kafkaTopic}] Starting`));
+                this.#LogDebugMessage(chalk.yellow(`InstrumentationSubscriber:#SubscribeKafka(): Subscribe to Kafka topc: [${subscription.kafka.kafkaTopic}] Starting`));
 
                 const kafka = subscription.kafka;
 
                 let connectError = false;
                 await kafka.kafkaConsumer.Connect((error) => {
-                    this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Connect: Error: [${error}]`));
+                    this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Connect: Error: [${error}]`));
                     connectError = true;
                 });
 
                 if (!connectError) {
                     let subscribeError = false;
                     await kafka.kafkaConsumer.Subscribe([kafka.kafkaTopic], subscription.kafka.kafkaFromBeginning, (error) => {
-                        this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Subscribe: Error: [${error}]`));
+                        this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.Subscribe: Error: [${error}]`));
                         subscribeError = true;
                     });
 
@@ -156,26 +145,26 @@ export class InstrumentationSubscriber extends STSOptionsBase {
                                             } as IKafkaData
                                         });
                                     } else {
-                                        this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Invalid message format from Kafka data, topic: [${topic}] and key: [${key}] do not match`));
+                                        this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Invalid message format from Kafka data, topic: [${topic}] and key: [${key}] do not match`));
                                     }
                                 } else {
-                                    this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Invalid message format from Kafka data, topic: [${topic}], key: [${key}], value: [${value}]`));
+                                    this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Invalid message format from Kafka data, topic: [${topic}], key: [${key}], value: [${value}]`));
                                 }
                             } catch (error) {
-                                this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Error: [${error}]`));
+                                this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Error: [${error}]`));
                             }
                         }, (error) => {
-                            this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.StartConsumingMessages: Error: [${error}]`));
+                            this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], kafkaConsumer.StartConsumingMessages: Error: [${error}]`));
                         });
-                        this.#Log(chalk.yellow(`InstrumentationSubscriber:#SubscribeKafka(): Subscribe to Kafka topc: [${kafka.kafkaTopic}] Completed`));
+                        this.#LogDebugMessage(chalk.yellow(`InstrumentationSubscriber:#SubscribeKafka(): Subscribe to Kafka topc: [${kafka.kafkaTopic}] Completed`));
                     } else {
-                        this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], Could not subscribe to topic, StartConsumingMessages aborted.`));
+                        this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], Could not subscribe to topic, StartConsumingMessages aborted.`));
                     }
                 } else {
-                    this.#Log(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], Could not connect to topic, subscribe aborted.`));
+                    this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#SubscribeKafka(): Kafka topic: [${kafka.kafkaTopic}], Could not connect to topic, subscribe aborted.`));
                 }
             } else {
-                this.#Log(chalk.magenta(`InstrumentationSubscriber:#SubscribeKafka(): Could not subscribe to Kafka topc, missing combinedKey for topic: [${JSON.stringify(subscription.subscriptionKey)}]`));
+                this.#LogDebugMessage(chalk.magenta(`InstrumentationSubscriber:#SubscribeKafka(): Could not subscribe to Kafka topc, missing combinedKey for topic: [${JSON.stringify(subscription.subscriptionKey)}]`));
             }
         }
         return kafkaSubscribe();
@@ -250,7 +239,7 @@ export class InstrumentationSubscriber extends STSOptionsBase {
                 }
             }
         } catch (error) {
-            this.#Log(chalk.red(`InstrumentationSubscriber:#ExecuteSubscriptions(): Error: [${error}], [${JSON.stringify(retVal)}]`));
+            this.#LogDebugMessage(chalk.red(`InstrumentationSubscriber:#ExecuteSubscriptions(): Error: [${error}], [${JSON.stringify(retVal)}]`));
         }
     }
 
@@ -271,7 +260,7 @@ export class InstrumentationSubscriber extends STSOptionsBase {
                     if (newTimeout < 500) { 
                         newTimeout = 500;
                     }
-                    this.#Log(chalk.grey(`InstrumentationSubscriber.#SetupTimeout(): ExecuteSubscriptions time: [${diff}], next timeout: [${newTimeout}]`));
+                    this.#LogDebugMessage(chalk.grey(`InstrumentationSubscriber.#SetupTimeout(): ExecuteSubscriptions time: [${diff}], next timeout: [${newTimeout}]`));
                     this.#SetupTimeout(newTimeout);
                 }
             }, timeout);
@@ -285,7 +274,7 @@ export class InstrumentationSubscriber extends STSOptionsBase {
         }
         if (this.#subscriptions[subscriptionKey.id]) {
             // Subscription already exists - ignoring
-            this.#Log(chalk.magenta(`InstrumentationSubscriber.Subscribe(): Subscription already exists: [${subscriptionKey.id}] - ignoring.`));
+            this.#LogDebugMessage(chalk.magenta(`InstrumentationSubscriber.Subscribe(): Subscription already exists: [${subscriptionKey.id}] - ignoring.`));
         } else {
             this.#subscriptions[subscriptionKey.id] = {
                 subscriptionKey,
@@ -294,7 +283,7 @@ export class InstrumentationSubscriber extends STSOptionsBase {
             if (subscriptionKey.topic.localeCompare(SubscriptionTopic.LogProcessing) === 0) {
                 this.#SubscribeKafka(this.#subscriptions[subscriptionKey.id]);
             }
-            this.#Log(chalk.grey(`InstrumentationSubscriber.Subscribe(): subscriptionKey.id: [${subscriptionKey.id}] successfully subscribed.`));
+            this.#LogDebugMessage(chalk.grey(`InstrumentationSubscriber.Subscribe(): subscriptionKey.id: [${subscriptionKey.id}] successfully subscribed.`));
 
             if (!this.#timeout) {
                 (async () => {
@@ -312,7 +301,7 @@ export class InstrumentationSubscriber extends STSOptionsBase {
 
     UnSubscribe(subscriptionKey: ISubscriptionKey) {
         if (!this.#subscriptions[subscriptionKey.id]) {
-            this.#Log(chalk.magenta(`UnSubscribe(): Warning, subscriptionKey.id: [${subscriptionKey.id}] does not exist within subscription records`));
+            this.#LogDebugMessage(chalk.magenta(`UnSubscribe(): Warning, subscriptionKey.id: [${subscriptionKey.id}] does not exist within subscription records`));
         } else {
             if (subscriptionKey.topic.localeCompare(SubscriptionTopic.LogProcessing) === 0) {
                 this.#UnSubscribeKafka(this.#subscriptions[subscriptionKey.id]);

package/src/kafka/IMKafkaManager.ts

@@ -6,7 +6,7 @@ import { KAFKA_PREFIX } from '@nsshunt/stssocketio-client'
 import { KafkaManager, IKafkaManagerConfig } from './kafkamanager'
 import { KafkaProducer } from './kafkaproducer'
 
-import { JSONObject } from '@nsshunt/stsutils'
+import { ISTSLogger, JSONObject } from '@nsshunt/stsutils'
 import { v4 as uuidv4 } from 'uuid';
 
 import chalk from 'chalk';
@@ -17,17 +17,22 @@ const goptions = $Options()
 import debugModule from 'debug'
 const debug = debugModule(`proc:${process.pid}`);
 
+export interface IMKafkaManagerOptions {
+    logger: ISTSLogger
+}
+
 // Manage the publication of InstrumentPayload to Kafka
 export class IMKafkaManager {
+    #options: IMKafkaManagerOptions;
     #shuttingDown: boolean = false;
     #producer: KafkaProducer | null = null;
 
     #km: KafkaManager;
     #topics: JSONObject = { }
 
-    constructor()
+    constructor(options: IMKafkaManagerOptions)
     {
-        //super(options);
+        this.#options = options;
 
         const kmc: IKafkaManagerConfig = {
             clientId: `${goptions.kafka_clientId}_${uuidv4()}`,
@@ -37,7 +42,8 @@ export class IMKafkaManager {
             connectionTimeout: goptions.kafka_connection_timeout,
             logLevel: goptions.kafka_log_level,
             useSSL: goptions.kafka_use_ssl,
-            requestTimeout: goptions.kafka_request_timeout
+            requestTimeout: goptions.kafka_request_timeout,
+            logger: options.logger
         }
         if (goptions.kafka_use_ssl) {
             kmc.ssl = {
@@ -51,8 +57,12 @@ export class IMKafkaManager {
         this.#km = new KafkaManager(kmc);
     }
 
+    #LogErrorMessage(message: any) {
+        this.#options.logger.error(message);
+    }
+
     #RaiseError = (msg: string, errorCb: (error: any) => void) => {
-        console.error(chalk.red(msg));
+        this.#LogErrorMessage(chalk.red(msg));
         errorCb(msg);
     }
 
@@ -119,7 +129,7 @@ export class IMKafkaManager {
             // Don't wait for these to return ...
             if (this.#producer) {
                 this.#producer.SendMessages(topic, messages as any, (error) => {
-                    console.error(chalk.red(`${process.pid}:IMKafkaManager:OutputLogsToKafkaTopic(): Kafka topic: [${topic}], Error during producer.SendMessages: [${error}]`));
+                    this.#LogErrorMessage(chalk.red(`${process.pid}:IMKafkaManager:OutputLogsToKafkaTopic(): Kafka topic: [${topic}], Error during producer.SendMessages: [${error}]`));
                 });
             }
         } catch (error) {

package/src/kafka/kafkaconsumer.ts

@@ -3,6 +3,14 @@ import { Kafka, Consumer, IHeaders } from 'kafkajs'
 import { IKafkaConsumer } from './../commonTypes'
 
 import chalk from 'chalk';
+import { ISTSLogger } from '@nsshunt/stsutils';
+
+export interface IKafkaConsumerOptions {
+    kafka: Kafka
+    id: string
+    groupId: string
+    logger: ISTSLogger
+}
 
 export class KafkaConsumer implements IKafkaConsumer {
     #id: string
@@ -10,22 +18,28 @@ export class KafkaConsumer implements IKafkaConsumer {
     #consumer: Consumer;
     #kafka: Kafka;
     #connected: boolean = false;
+    #options: IKafkaConsumerOptions;
 
-    constructor(kafka: Kafka, id: string, groupId: string) {
-        this.#id = id;
-        this.#groupId = groupId;
-        this.#kafka = kafka;
+    constructor(options: IKafkaConsumerOptions) {
+        this.#options = options;
+        this.#id = this.#options.id;
+        this.#groupId = this.#options.groupId;
+        this.#kafka = this.#options.kafka;
         this.#consumer = this.#kafka.consumer({ 
             groupId: this.#groupId,
             retry: {
                 restartOnFailure: async (error: Error): Promise<boolean> => {
-                    console.error(chalk.magenta(`${process.pid}:KafkaConsumer:constructor:restartOnFailure(): Error: [${error}]`))
+                    this.#LogErrorMessage(chalk.magenta(`${process.pid}:KafkaConsumer:constructor:restartOnFailure(): Error: [${error}]`))
                     return true;
                 }
             }
         })
     }
 
+    #LogErrorMessage(message: any) {
+        this.#options.logger.error(message);
+    }
+
     get consumer() {
         return this.#consumer;
     }
@@ -36,7 +50,7 @@ export class KafkaConsumer implements IKafkaConsumer {
 
     #RaiseError = (msg: string, errorCb: (error: any) => void) => {
         const errorMessage = `${process.pid}:KafkaConsumer:${msg}`;
-        console.error(chalk.red(errorMessage));
+        this.#LogErrorMessage(chalk.red(errorMessage));
         errorCb(errorMessage);
     }
 

package/src/kafka/kafkamanager.ts

@@ -51,7 +51,7 @@ services:
       - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://192.168.14.92:9092
 
 */
-import { STSOptionsBase } from '@nsshunt/stsutils'
+import { ISTSLogger, STSOptionsBase } from '@nsshunt/stsutils'
 
 import { Kafka, KafkaConfig, logLevel } from 'kafkajs'
 
@@ -84,6 +84,7 @@ export interface IKafkaManagerConfig {
       keyfile: string
       certfileFile: string
     }
+    logger: ISTSLogger
 }
 
 // https://kafka.js.org/docs/configuration
@@ -153,8 +154,12 @@ export class KafkaManager extends STSOptionsBase {
         this.#kafka = new Kafka(kc);
     }
 
+    #LogErrorMessage(message: any) {
+        this.options?.logger.error(message);
+    }
+
     #RaiseError = (msg: string, errorCb: (error: any) => void) => {
-        console.error(chalk.red(msg));
+        this.#LogErrorMessage(chalk.red(msg));
         errorCb(msg);
     }
 
@@ -163,11 +168,18 @@ export class KafkaManager extends STSOptionsBase {
     }
 
     CreateProducer(): KafkaProducer {
-        return new KafkaProducer(this.#kafka, uuidv4());
+        return new KafkaProducer({
+            kafka: this.#kafka,
+            id: uuidv4(),
+            logger: this.options?.logger});
     }
 
     CreateConsumer(groupId: string) {
-        return new KafkaConsumer(this.#kafka, uuidv4(), groupId);
+        return new KafkaConsumer({
+            kafka: this.#kafka, 
+            id: uuidv4(), 
+            groupId,
+            logger: this.options?.logger});
     }
 
     CreateTopic = async (topic: string, partitions: number, errorCb: (error: any) => void): Promise<boolean> => {

package/src/kafka/kafkaproducer.ts

@@ -2,21 +2,34 @@
 import { Kafka, Producer, RecordMetadata } from 'kafkajs'
 
 import chalk from 'chalk';
+import { ISTSLogger } from '@nsshunt/stsutils';
+
+export interface IKafkaProducerOptions {
+    kafka: Kafka
+    id: string
+    logger: ISTSLogger
+}
 
 export class KafkaProducer {
+    #options: IKafkaProducerOptions;
     #id: string
     #producer: Producer;
     #kafka: Kafka;
     #connected: boolean = false;
 
-    constructor(kafka: Kafka, id: string) {
-        this.#id = id;
-        this.#kafka = kafka;
+    constructor(options: IKafkaProducerOptions) {
+        this.#options = options;
+        this.#id = this.#options.id;
+        this.#kafka = this.#options.kafka;
         this.#producer = this.#kafka.producer()
     }
 
+    #LogErrorMessage(message: any) {
+        this.#options.logger.error(message);
+    }
+
     #RaiseError = (msg: string, errorCb: (error: any) => void) => {
-        console.error(chalk.red(msg));
+        this.#LogErrorMessage(chalk.red(msg));
         errorCb(msg);
     }
 
@@ -58,7 +71,7 @@ export class KafkaProducer {
                     messages: [ message ]
                 })
             } catch (error) {
-                console.error(chalk.red(`${process.pid}:KafkaProducer:SendMessage(): Error: [${error}]`));
+                this.#LogErrorMessage(chalk.red(`${process.pid}:KafkaProducer:SendMessage(): Error: [${error}]`));
                 return [ ];
             }
         } else {
@@ -77,7 +90,7 @@ export class KafkaProducer {
                     messages
                 })   
             } catch (error) {
-                console.error(chalk.red(`${process.pid}:KafkaProducer:SendMessages(): Error: [${error}]`));
+                this.#LogErrorMessage(chalk.red(`${process.pid}:KafkaProducer:SendMessages(): Error: [${error}]`));
                 return [ ];
             }
         } else {