@hahnpro/flow-sdk 2026.1.1 → 2026.1.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @hahnpro/flow-sdk
 
+## 2026.1.0
+
+### Major Changes
+
+- Fixed a loop in publishing Nats events: error occurred when publishNatsEvent throws an error
+
 ## 2025.10.0
 
 ### Major Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/flow-sdk",
-  "version": "2026.1.1",
+  "version": "2026.1.2",
   "description": "SDK for building Flow Modules",
   "license": "MIT",
   "author": {
@@ -17,14 +17,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@hahnpro/hpc-api": "2026.1.1",
+    "@hahnpro/hpc-api": "2026.1.2",
     "@nats-io/jetstream": "3.3.0",
     "@nats-io/nats-core": "3.3.0",
     "@nats-io/transport-node": "3.3.0",
     "class-transformer": "0.5.1",
     "class-validator": "0.14.3",
     "cloudevents": "10.0.0",
-    "lodash": "4.17.21",
+    "lodash": "4.17.23",
     "object-sizeof": "2.6.5",
     "python-shell": "5.0.0",
     "reflect-metadata": "0.2.2",
@@ -33,17 +33,17 @@
   },
   "devDependencies": {
     "@types/jest": "30.0.0",
-    "@types/lodash": "4.17.21",
-    "@types/node": "24.10.4",
+    "@types/lodash": "4.17.23",
+    "@types/node": "24.10.9",
     "class-validator-jsonschema": "5.1.0",
     "jest": "30.2.0",
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "axios": "1.13.2",
+    "axios": "1.13.4",
     "class-transformer": "0.5.1",
     "class-validator": "0.14.3",
-    "lodash": "4.17.21"
+    "lodash": "4.17.23"
   },
   "engines": {
     "node": ">=v24"

package/src/lib/FlowApplication.d.ts

@@ -35,13 +35,16 @@ export declare class FlowApplication {
     private readonly apiClient?;
     private readonly contextManager;
     private natsMessageIterator;
+    private lastErrorBecauseFlowLogCouldNotBeSend;
     constructor(modules: ClassType<any>[], flow: Flow, config?: FlowAppConfig);
     constructor(modules: ClassType<any>[], flow: Flow, baseLogger?: Logger, natsConnection?: NatsConnection, skipApi?: boolean, explicitInit?: boolean);
     get api(): API;
     get natsConnection(): NatsConnection;
     getContextManager(): ContextManager;
     getProperties(): Record<string, any>;
+    private logErrorAndExit;
     private consumeNatsMessagesOfConsumer;
+    private setupNatsConsumerForFlowDeployment;
     init(): Promise<void>;
     private publishLifecycleEvent;
     private setQueueMetrics;
@@ -53,10 +56,9 @@ export declare class FlowApplication {
     /**
      * Publish a flow event to NATS
      * If the event size exceeds the limit it will be truncated
-     *
-     * TODO warum darf hier nicht false zurückgegeben werden? -> erzeugt loop
      */
-    publishNatsEventFlowlogs: (event: FlowEvent) => Promise<boolean>;
+    publishFlowEventsAsFlowLogsOverNats: (event: FlowEvent) => Promise<void>;
+    private tryToSendLastErrorOnPublishingNatsEvents;
     /**
      * Calls onDestroy lifecycle method on all flow elements,
      * closes NATS connection after allowing logs to be processed and published

package/src/lib/FlowApplication.js

@@ -13,6 +13,7 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const ContextManager_1 = require("./ContextManager");
 const flow_interface_1 = require("./flow.interface");
+const FlowEvent_1 = require("./FlowEvent");
 const FlowLogger_1 = require("./FlowLogger");
 const nats_1 = require("./nats");
 const utils_1 = require("./utils");
@@ -29,6 +30,7 @@ class FlowApplication {
         this.outputStreamMap = new Map();
         this.outputQueueMetrics = new Map();
         this.performanceMap = new Map();
+        this.lastErrorBecauseFlowLogCouldNotBeSend = null;
         this.publishLifecycleEvent = async (element, flowEventId, eventType, data = {}) => {
             try {
                 const { flowId, deploymentId, id: elementId, functionFqn, inputStreamId } = element.getMetadata();
@@ -42,10 +44,10 @@ class FlowApplication {
                         ...data,
                     },
                 };
-                await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent, `${nats_1.natsFlowsPrefixFlowDeployment}.flowlifecycle.${deploymentId}`);
+                await (0, nats_1.publishNatsEvent)(this._natsConnection, natsEvent, `${nats_1.natsFlowsPrefixFlowDeployment}.flowlifecycle.${deploymentId}`);
             }
             catch (err) {
-                this.logger.error(err);
+                this.logger.error(err, { doNotPublishAsNatsEvent: true });
             }
         };
         this.setQueueMetrics = (id) => {
@@ -75,7 +77,7 @@ class FlowApplication {
         this.emit = (event) => {
             if (event) {
                 try {
-                    this.publishNatsEventFlowlogs(event);
+                    this.publishFlowEventsAsFlowLogsOverNats(event);
                     if (this.outputStreamMap.has(event.getStreamId())) {
                         this.getOutputStream(event.getStreamId()).next(event);
                     }
@@ -92,7 +94,7 @@ class FlowApplication {
                     this.getOutputStream(completeEvent.getStreamId()).next(completeEvent);
                 }
                 if (partialEvent) {
-                    this.publishNatsEventFlowlogs(partialEvent);
+                    this.publishFlowEventsAsFlowLogsOverNats(partialEvent);
                 }
             }
             catch (err) {
@@ -137,7 +139,9 @@ class FlowApplication {
                             status: 'updated',
                         },
                     };
-                    await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
+                    await (0, nats_1.publishNatsEvent)(this._natsConnection, natsEvent).catch((err) => {
+                        this.logger.error(`Could not publish health update after flow deployment update: ${err.message}`);
+                    });
                 }
                 catch (err) {
                     this.logger.error(err);
@@ -150,7 +154,9 @@ class FlowApplication {
                             status: 'updating failed',
                         },
                     };
-                    await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
+                    await (0, nats_1.publishNatsEvent)(this._natsConnection, natsEvent).catch((err) => {
+                        this.logger.error(`Could not publish health update after flow deployment update failed: ${err.message}`);
+                    });
                 }
             }
             else if (cloudEvent.subject.endsWith('.message')) {
@@ -169,30 +175,61 @@ class FlowApplication {
         /**
          * Publish a flow event to NATS
          * If the event size exceeds the limit it will be truncated
-         *
-         * TODO warum darf hier nicht false zurückgegeben werden? -> erzeugt loop
          */
-        this.publishNatsEventFlowlogs = async (event) => {
-            if (!this._natsConnection || this._natsConnection.isClosed()) {
-                return true;
+        this.publishFlowEventsAsFlowLogsOverNats = async (event) => {
+            const errorMessageTextWithoutReason = `Cannot publish flow event to NATS as flow logs, because `;
+            if (!this.context?.deploymentId) {
+                this.logger.error(`${errorMessageTextWithoutReason} the deploymentId is undefined!`, { doNotPublishAsNatsEvent: true });
+                return;
+            }
+            if (!this._natsConnection) {
+                this.logger.error(`${errorMessageTextWithoutReason} the NATS connection is undefined!`, { doNotPublishAsNatsEvent: true });
+                return;
+            }
+            if (this._natsConnection.isClosed()) {
+                this.logger.error(`${errorMessageTextWithoutReason} the NATS connection was already closed!`, { doNotPublishAsNatsEvent: true });
+                return;
+            }
+            if (!this._natsConnection?.info?.jetstream) {
+                this.logger.error(`${errorMessageTextWithoutReason} Jetstream is not enabled!`, { doNotPublishAsNatsEvent: true });
+                return;
             }
+            // try to format and create the event
+            let natsEvent;
             try {
                 const formatedEvent = event.format();
                 if ((0, object_sizeof_1.default)(formatedEvent) > MAX_EVENT_SIZE_BYTES) {
                     formatedEvent.data = (0, utils_1.truncate)(formatedEvent.data);
                 }
-                const natsEvent = {
+                natsEvent = {
                     source: `hpc/flow-application`,
                     type: `${nats_1.natsFlowsPrefixFlowDeployment}.flowlogs`,
                     subject: `${this.context.deploymentId}`,
                     data: formatedEvent,
                 };
-                await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
-                return true;
             }
-            catch (err) {
-                this.logger.error(err);
-                return false;
+            catch (error) {
+                this.logger.error(error);
+                return;
+            }
+            // Try to publish the event
+            try {
+                await this.tryToSendLastErrorOnPublishingNatsEvents();
+                await (0, nats_1.publishNatsEvent)(this._natsConnection, natsEvent);
+            }
+            catch (error) {
+                // Setting doNotPublishAsNatsEvent to true to avoid
+                // - infinite logging loop and to stop sending
+                // - events if NATS is not available
+                this.logger.error(error, { doNotPublishAsNatsEvent: true });
+                const message = `${error.message ?? String(error)}`;
+                if (!this.lastErrorBecauseFlowLogCouldNotBeSend) {
+                    this.lastErrorBecauseFlowLogCouldNotBeSend = { error: message, count: 1 };
+                }
+                else {
+                    this.lastErrorBecauseFlowLogCouldNotBeSend.error = message;
+                    this.lastErrorBecauseFlowLogCouldNotBeSend.count++;
+                }
             }
         };
         if (baseLoggerOrConfig && !baseLoggerOrConfig.log) {
@@ -212,7 +249,7 @@ class FlowApplication {
             explicitInit = explicitInit || false;
             this._api = mockApi || null;
         }
-        this.logger = new FlowLogger_1.FlowLogger({ id: 'none', functionFqn: 'FlowApplication', ...flow?.context }, this.baseLogger || undefined, this.publishNatsEventFlowlogs);
+        this.logger = new FlowLogger_1.FlowLogger({ id: 'none', functionFqn: 'FlowApplication', ...flow?.context }, this.baseLogger || undefined, this.publishFlowEventsAsFlowLogsOverNats);
         this.contextManager = new ContextManager_1.ContextManager(this.logger, this.flow?.properties);
         process.once('uncaughtException', (err) => {
             this.logger.error('Uncaught exception!');
@@ -243,6 +280,10 @@ class FlowApplication {
     getProperties() {
         return this.contextManager.getProperties();
     }
+    async logErrorAndExit(err) {
+        this.logger.error(new Error(err));
+        await this.destroy(1);
+    }
     async consumeNatsMessagesOfConsumer(consumer, consumeOptions) {
         if (this.natsMessageIterator) {
             await this.natsMessageIterator.close();
@@ -270,76 +311,102 @@ class FlowApplication {
             }
         }
     }
+    async setupNatsConsumerForFlowDeployment() {
+        if (!this._natsConnection || this._natsConnection.isClosed() || !this.context?.deploymentId) {
+            return;
+        }
+        if (!this._natsConnection?.info?.jetstream) {
+            if (process.env.NODE_ENV !== 'test') {
+                await this.logErrorAndExit('NATS JetStream is not enabled on the connected NATS server(s). Terminating FlowApplication...');
+                return;
+            }
+            else {
+                // Do not set up consumers in tests because no mock exits
+                // TODO mock nats jetstream
+                return;
+            }
+        }
+        const natsSubject = `${nats_1.natsFlowsPrefixFlowDeployment}.${this.context.deploymentId}.*`;
+        const consumerOptions = {
+            ...nats_1.defaultConsumerConfig,
+            name: `flow-deployment-${this.context.deploymentId}`,
+            filter_subject: natsSubject,
+            inactive_threshold: 10 * 60 * 1000000000, //  10 mins
+            deliver_policy: jetstream_1.DeliverPolicy.New,
+        };
+        let consumer;
+        try {
+            consumer = await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
+        }
+        catch (e) {
+            this.logger.error(`Could not set up the nats consumer 'flow-deployment-${this.context.deploymentId}' for this flow deployment.`);
+            throw e;
+        }
+        // NO AWAIT, listen for messages of the consumer asynchronously
+        this.consumeNatsMessagesOfConsumer(consumer, { expires: 10 * 1000000000 /* 10 seconds */ }).catch((error) => {
+            this.logger.error(`Could not consume messages for the nats consumer 'flow-deployment-${this.context.deploymentId}' for deployment messages on the nats subject ${natsSubject}.`);
+            this.logErrorAndExit(error.message ?? String(error));
+        });
+        (0, nats_1.natsEventListener)(this._natsConnection, this.logger, async () => {
+            try {
+                const recreatedConsumer = await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
+                this.consumeNatsMessagesOfConsumer(recreatedConsumer, { expires: 10 * 1000000000 /* 10 seconds */ }).catch((error) => {
+                    this.logger.error(`Could not consume messages for the nats consumer 'flow-deployment-${this.context.deploymentId}' for deployment messages on the nats subject ${natsSubject}.`);
+                    this.logErrorAndExit(error.message ?? String(error));
+                });
+            }
+            catch (error) {
+                this.logger.error('Could not re-create consumers after NATS reconnect');
+                this.logErrorAndExit(error.message ?? String(error));
+            }
+        }).catch((error) => {
+            this.logger.error(`Could not set up NATS status listener`);
+            this.logErrorAndExit(error.message ?? String(error));
+        });
+    }
     async init() {
         if (this.initialized) {
             return;
         }
         this.context = { ...this.flow.context };
         this.contextManager.overwriteAllProperties(this.flow.properties ?? {});
-        try {
-            if (!this.skipApi && !(this._api instanceof hpc_api_1.MockAPI)) {
+        if (!this.skipApi && !(this._api instanceof hpc_api_1.MockAPI)) {
+            try {
                 const { owner } = this.context;
                 // only create real API if it should not be skipped and is not already a mock
                 this._api = new hpc_api_1.API(this.apiClient, { activeOrg: owner?.id }, { queueOptions: { concurrency: 1, timeout: 70000, throwOnTimeout: true } });
             }
+            catch (err) {
+                this.logger.error(err?.message || err);
+            }
         }
-        catch (err) {
-            this.logger.error(err?.message || err);
-        }
-        const logErrorAndExit = async (err) => {
-            this.logger.error(new Error(err));
-            await this.destroy(1);
-        };
         if (!this._natsConnection && this.natsConnectionConfig) {
             try {
                 this._natsConnection = await (0, nats_1.createNatsConnection)(this.natsConnectionConfig);
             }
             catch (err) {
-                await logErrorAndExit(`Could not connect to the NATS-Servers: ${err}`);
+                await this.logErrorAndExit(`Could not connect to the NATS-Servers: ${err}`);
+                return;
             }
         }
-        if (this._natsConnection && !this._natsConnection.isClosed() && this.context?.deploymentId !== undefined) {
-            try {
-                const consumerOptions = {
-                    ...nats_1.defaultConsumerConfig,
-                    name: `flow-deployment-${this.context.deploymentId}`,
-                    filter_subject: `${nats_1.natsFlowsPrefixFlowDeployment}.${this.context.deploymentId}.*`,
-                    inactive_threshold: 10 * 60 * 1000000000, //  10 mins
-                    deliver_policy: jetstream_1.DeliverPolicy.New,
-                };
-                const consumer = await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
-                // Recreate consumers on reconnects: NO AWAIT, listen asynchronously
-                const handleNatsStatus = async () => {
-                    try {
-                        this.logger.debug('ConsumerService: Reconnected to Nats and re-creating non-durable consumers');
-                        await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
-                        this.consumeNatsMessagesOfConsumer(consumer, { expires: 10 * 1000000000 /* 10 seconds */ });
-                    }
-                    catch (e) {
-                        this.logger.error('NATS Status-AsyncIterator is not available, cannot listen. Due to error:');
-                        this.logger.error(e);
-                        (0, nats_1.natsEventListener)(this._natsConnection, this.logger, handleNatsStatus);
-                    }
-                };
-                (0, nats_1.natsEventListener)(this._natsConnection, this.logger, handleNatsStatus);
-                // NO AWAIT, listen for messages of the consumer asynchronously
-                this.consumeNatsMessagesOfConsumer(consumer, { expires: 10 * 1000000000 /* 10 seconds */ });
-            }
-            catch (e) {
-                await logErrorAndExit(`Could not set up consumer for deployment messages exchanges: ${e}`);
-            }
+        try {
+            await this.setupNatsConsumerForFlowDeployment();
+        }
+        catch (error) {
+            await this.logErrorAndExit(error.message ?? String(error));
+            return;
         }
         for (const module of this.modules) {
             const moduleName = Reflect.getMetadata('module:name', module);
             const moduleDeclarations = Reflect.getMetadata('module:declarations', module);
             if (!moduleName || !moduleDeclarations || !Array.isArray(moduleDeclarations)) {
-                await logErrorAndExit(`FlowModule (${module.name}) metadata is missing or invalid`);
+                await this.logErrorAndExit(`FlowModule (${module.name}) metadata is missing or invalid`);
                 return;
             }
             for (const declaration of moduleDeclarations) {
                 const functionFqn = Reflect.getMetadata('element:functionFqn', declaration);
                 if (!functionFqn) {
-                    await logErrorAndExit(`FlowFunction (${declaration.name}) metadata is missing or invalid`);
+                    await this.logErrorAndExit(`FlowFunction (${declaration.name}) metadata is missing or invalid`);
                     return;
                 }
                 this.declarations[`${moduleName}.${functionFqn}`] = declaration;
@@ -355,7 +422,7 @@ class FlowApplication {
                 this.elements[id].setPropertiesWithPlaceholders((0, lodash_1.cloneDeep)(properties));
             }
             catch (err) {
-                await logErrorAndExit(`Could not create FlowElement for ${module}.${functionFqn}`);
+                await this.logErrorAndExit(`Could not create FlowElement for ${module}.${functionFqn}`);
                 return;
             }
         }
@@ -368,12 +435,12 @@ class FlowApplication {
             const targetStreamId = `${target}.${targetStream}`;
             const element = this.elements[target];
             if (!element || !element.constructor) {
-                await logErrorAndExit(`${target} has not been initialized`);
+                await this.logErrorAndExit(`${target} has not been initialized`);
                 return;
             }
             const streamHandler = Reflect.getMetadata(`stream:${targetStream}`, element.constructor);
             if (!streamHandler || !element[streamHandler]) {
-                await logErrorAndExit(`${target} does not implement a handler for ${targetStream}`);
+                await this.logErrorAndExit(`${target} does not implement a handler for ${targetStream}`);
                 return;
             }
             const streamOptions = Reflect.getMetadata(`stream:options:${targetStream}`, element.constructor) || {};
@@ -417,12 +484,37 @@ class FlowApplication {
         this.initialized = true;
         this.logger.log('Flow Deployment is running');
     }
+    async tryToSendLastErrorOnPublishingNatsEvents() {
+        if (!this.lastErrorBecauseFlowLogCouldNotBeSend) {
+            return;
+        }
+        try {
+            await (0, nats_1.publishNatsEvent)(this._natsConnection, {
+                source: `hpc/flow-application`,
+                type: `${nats_1.natsFlowsPrefixFlowDeployment}.flowlogs`,
+                subject: `${this.context.deploymentId}`,
+                data: new FlowEvent_1.FlowEvent({ id: 'none', name: 'functionFqn', ...this.context }, {
+                    message: `${this.lastErrorBecauseFlowLogCouldNotBeSend.count} Nats events could not be sent. Last occurred error: ${this.lastErrorBecauseFlowLogCouldNotBeSend.error}`,
+                }, 'flow.log.error'),
+            });
+            this.lastErrorBecauseFlowLogCouldNotBeSend = null;
+        }
+        catch (error) {
+            const message = `${error.message ?? String(error)}`;
+            this.logger.error(`Retry: Could not publish NATS event containing reason while sending nats events failed previously, due to ${error.message ?? String(error)}`, {
+                doNotPublishAsNatsEvent: true,
+            });
+            this.lastErrorBecauseFlowLogCouldNotBeSend.error = message;
+            this.lastErrorBecauseFlowLogCouldNotBeSend.count++;
+        }
+    }
     /**
      * Calls onDestroy lifecycle method on all flow elements,
      * closes NATS connection after allowing logs to be processed and published
      * then exits process
      */
     async destroy(exitCode = 0) {
+        this.logger.debug(`Destroying Flow Application with exitCode ${exitCode}...`);
         try {
             try {
                 for (const element of Object.values(this.elements)) {
@@ -443,6 +535,13 @@ class FlowApplication {
                     this.logger.error(`Error completing output stream ${id}: ${err.message}`);
                 }
             }
+            // Publish any unpublished NATS flow events as flow logs
+            await this.tryToSendLastErrorOnPublishingNatsEvents();
+            if (this.lastErrorBecauseFlowLogCouldNotBeSend) {
+                this.logger.error(`${this.lastErrorBecauseFlowLogCouldNotBeSend.count} Nats events cloud not be sent. Last occurred error: ${this.lastErrorBecauseFlowLogCouldNotBeSend.error}`, {
+                    doNotPublishAsNatsEvent: true,
+                });
+            }
             // Nats: Delete consumer for flow deployment, stop message listening and close connection
             try {
                 await this.natsMessageIterator?.close();
@@ -453,16 +552,20 @@ class FlowApplication {
                         jsm.consumers
                             .delete(nats_1.FLOWS_STREAM_NAME, `flow-deployment-${this.context?.deploymentId}`)
                             .then(() => {
-                            this.logger.debug(`Deleted consumer for flow deployment ${this.context?.deploymentId}`);
+                            this.logger.debug(`Deleted consumer for flow deployment ${this.context?.deploymentId}`, {
+                                doNotPublishAsNatsEvent: true,
+                            });
                         })
                             .catch((err) => {
-                            this.logger.error(`Could not delete consumer for flow deployment ${this.context?.deploymentId}: ${err.message}`);
+                            this.logger.error(`Could not delete consumer for flow deployment ${this.context?.deploymentId}: ${err.message}`, {
+                                doNotPublishAsNatsEvent: true,
+                            });
                         });
                     });
                 }
             }
             catch (err) {
-                this.logger.error(err);
+                this.logger.error(err, { doNotPublishAsNatsEvent: true });
             }
             // remove process listeners
             process.removeAllListeners('SIGTERM');
@@ -470,8 +573,7 @@ class FlowApplication {
             process.removeAllListeners('unhandledRejection');
         }
         catch (err) {
-            /* eslint-disable-next-line no-console */
-            console.error(err);
+            this.logger.error(err, { doNotPublishAsNatsEvent: true });
         }
         finally {
             if (process.env.NODE_ENV !== 'test') {

package/src/lib/FlowElement.js

@@ -33,7 +33,7 @@ class FlowElement {
         this.app = app;
         this.api = this.app?.api;
         this.metadata = { ...metadata, functionFqn: this.functionFqn };
-        this.logger = new FlowLogger_1.FlowLogger(this.metadata, logger || undefined, this.app?.publishNatsEventFlowlogs);
+        this.logger = new FlowLogger_1.FlowLogger(this.metadata, logger || undefined, this.app?.publishFlowEventsAsFlowLogsOverNats);
         if (properties) {
             this.setProperties(properties);
         }

package/src/lib/FlowLogger.d.ts

@@ -8,13 +8,8 @@ export interface Logger {
     verbose(message: any, metadata?: any): void;
 }
 export declare const defaultLogger: Logger;
-export declare enum STACK_TRACE {
-    FULL = "full",
-    ONLY_LOG_CALL = "only-log-call"
-}
 export interface LoggerOptions {
-    truncate: boolean;
-    stackTrace?: STACK_TRACE;
+    doNotPublishAsNatsEvent?: boolean;
 }
 export declare class FlowLogger implements Logger {
     private readonly metadata;
@@ -36,7 +31,6 @@ export declare class FlowLogger implements Logger {
      *
      * @param {any} message - The message to be logged. Can be a string, an object with a `message` property, or any other type.
      * @param {string} level - The log level (e.g., 'error', 'debug', 'warn', 'verbose').
-     * @param {LoggerOptions} options - Additional options for logging, such as whether to include a stack trace.
      * @returns {FlowLog} - An object containing the parsed log message and optional stack trace.
      */
     private parseMessageToFlowLog;

package/src/lib/FlowLogger.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowLogger = exports.STACK_TRACE = exports.defaultLogger = void 0;
+exports.FlowLogger = exports.defaultLogger = void 0;
 const FlowEvent_1 = require("./FlowEvent");
 /* eslint-disable no-console */
 exports.defaultLogger = {
@@ -10,14 +10,8 @@ exports.defaultLogger = {
     warn: (msg, metadata) => console.warn(msg),
     verbose: (msg, metadata) => console.log(msg, metadata),
 };
-/* eslint-enable no-console */
-var STACK_TRACE;
-(function (STACK_TRACE) {
-    STACK_TRACE["FULL"] = "full";
-    STACK_TRACE["ONLY_LOG_CALL"] = "only-log-call";
-})(STACK_TRACE || (exports.STACK_TRACE = STACK_TRACE = {}));
 class FlowLogger {
-    static getStackTrace(stacktrace = STACK_TRACE.FULL) {
+    static getStackTrace() {
         // get stacktrace without extra dependencies
         let stack;
         try {
@@ -27,17 +21,10 @@ class FlowLogger {
             stack = error.stack || '';
         }
         // cleanup stacktrace and remove calls within this file
-        stack = stack
+        return stack
             .split('\n')
             .map((line) => line.trim())
-            .filter((value) => value.includes('at ') && !value.includes('Logger'));
-        if (stacktrace === STACK_TRACE.ONLY_LOG_CALL && stack.length > 0) {
-            stack = stack[0];
-        }
-        else {
-            stack = stack.splice(1).join('\n');
-        }
-        return stack;
+            .filter((value) => value.startsWith('at FlowLogger.FlowApplication') || value.startsWith('at FlowApplication'));
     }
     constructor(metadata, logger = exports.defaultLogger, publishEvent) {
         this.metadata = metadata;
@@ -58,10 +45,9 @@ class FlowLogger {
      *
      * @param {any} message - The message to be logged. Can be a string, an object with a `message` property, or any other type.
      * @param {string} level - The log level (e.g., 'error', 'debug', 'warn', 'verbose').
-     * @param {LoggerOptions} options - Additional options for logging, such as whether to include a stack trace.
      * @returns {FlowLog} - An object containing the parsed log message and optional stack trace.
      */
-    parseMessageToFlowLog(message, level, options) {
+    parseMessageToFlowLog(message, level) {
         let flowLogMessage;
         if (!message) {
             flowLogMessage = 'No message provided!';
@@ -81,18 +67,18 @@ class FlowLogger {
             }
         }
         const flowLog = { message: flowLogMessage };
-        if (['error', 'debug', 'warn', 'verbose'].includes(level) || options?.stackTrace) {
-            flowLog.stackTrace = FlowLogger.getStackTrace(options?.stackTrace ?? STACK_TRACE.ONLY_LOG_CALL);
+        if (['error', 'debug', 'warn', 'verbose'].includes(level)) {
+            flowLog.stackTrace = FlowLogger.getStackTrace();
         }
         return flowLog;
     }
     publish(message, level, options) {
-        const flowLogData = this.parseMessageToFlowLog(message, level, options);
-        if (this.publishEvent) {
-            const event = new FlowEvent_1.FlowEvent(this.metadata, flowLogData, `flow.log.${level}`);
+        const flowLog = this.parseMessageToFlowLog(message, level);
+        if (this.publishEvent && options?.doNotPublishAsNatsEvent !== true) {
+            const event = new FlowEvent_1.FlowEvent(this.metadata, flowLog, `flow.log.${level}`);
             this.publishEvent(event);
         }
-        const messageWithStackTrace = flowLogData.stackTrace ? `${flowLogData.message}\n${flowLogData.stackTrace}` : flowLogData.message;
+        const messageWithStackTrace = flowLog.stackTrace ? `${flowLog.message}\n${flowLog.stackTrace}` : flowLog.message;
         switch (level) {
             case 'debug':
                 return this.logger.debug(messageWithStackTrace, { ...this.metadata, ...options });

package/src/lib/nats.d.ts

@@ -7,6 +7,6 @@ export declare const natsFlowsPrefixFlowDeployment = "fs.flowdeployment";
 export declare const defaultConsumerConfig: ConsumerConfig;
 export declare const FLOWS_STREAM_NAME = "flows";
 export declare function getOrCreateConsumer(logger: Logger, natsConnection: NatsConnection, streamName: string, consumerName: string, options: Partial<ConsumerConfig>): Promise<Consumer>;
-export declare function natsEventListener(nc: NatsConnection, logger: Logger, reconnectHandler: () => void): Promise<void>;
-export declare function publishNatsEvent<T>(logger: Logger, nc: NatsConnection, event: NatsEvent<T>, subject?: string): Promise<PubAck>;
+export declare function natsEventListener(nc: NatsConnection, logger: Logger, reconnectHandler: () => Promise<void>): Promise<void>;
+export declare function publishNatsEvent<T>(nc: NatsConnection, event: NatsEvent<T>, subject?: string): Promise<PubAck>;
 export declare function createNatsConnection(config: ConnectionOptions): Promise<NatsConnection>;

package/src/lib/nats.js

@@ -62,14 +62,13 @@ async function natsEventListener(nc, logger, reconnectHandler) {
     for await (const status of statusAsyncIterator) {
         // Handle reconnect: event is triggered when the NATS client reconnected to the server
         if (status.type === 'reconnect') {
-            reconnectHandler();
+            await reconnectHandler();
         }
     }
 }
-async function publishNatsEvent(logger, nc, event, subject) {
+async function publishNatsEvent(nc, event, subject) {
     if (!nc || nc.isClosed()) {
-        logger.error('NATS connection is not available, cannot publish event');
-        return null;
+        throw new Error('NATS connection is not available, cannot publish event');
     }
     const cloudEvent = new cloudevents_1.CloudEvent({ datacontenttype: 'application/json', ...event });
     cloudEvent.validate();
@@ -80,8 +79,7 @@ async function publishNatsEvent(logger, nc, event, subject) {
         });
     }
     else {
-        logger.error(`Could not publish nats event, because jetstream is unavailable / undefined`);
-        return null;
+        throw new Error('NATS jetstream is not available, cannot publish event');
     }
 }
 async function createNatsConnection(config) {

package/src/lib/utils.d.ts

@@ -1,6 +1,5 @@
 import { FlowLogger } from './FlowLogger';
 export declare function fillTemplate(value: any, ...templateVariables: any): any;
-export declare function getCircularReplacer(): (key: any, value: any) => any;
 export declare function toArray(value?: string | string[]): string[];
 export declare function delay(ms: number): Promise<void>;
 /**

package/src/lib/utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fillTemplate = fillTemplate;
-exports.getCircularReplacer = getCircularReplacer;
 exports.toArray = toArray;
 exports.delay = delay;
 exports.delayWithAbort = delayWithAbort;
@@ -47,18 +46,6 @@ function fillTemplate(value, ...templateVariables) {
         return value;
     }
 }
-function getCircularReplacer() {
-    const seen = new WeakSet();
-    return (key, value) => {
-        if (typeof value === 'object' && value !== null) {
-            if (seen.has(value)) {
-                return;
-            }
-            seen.add(value);
-        }
-        return value;
-    };
-}
 function toArray(value = []) {
     return Array.isArray(value) ? value : value.split(',').map((v) => v.trim());
 }