@ti-engine/core 1.1.4 → 1.1.8

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # ti-engine changelog
 
+This document will contain the list of changes made to the framework. The format is based on the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
+
+## Version 1.1.8
+* feat(auditing): change export of the singleton class in an `instance` variable for consistency and clarity
+* feat(message dispatcher): change export of the singleton class in an `instance` variable for consistency and clarity
+* feat(cache): change export of the singleton class in an `instance` variable for consistency and clarity
+* feat(service executor): implement service registration retry policy
+
+## Version 1.1.7
+* feat(start instance): add support for the detection of `SIGBREAK` events and graceful shutdown on Windows
+* feat(service instance)!: prevent the initialization of multiple `ServiceInstance` within the same process
+* feat(message tracer)!: covert to singleton instance and add initialization method
+* feat(message dispatcher): initialize the message tracer on start before message exchange is enabled
+* fix(message tracer): optimize `recordTraceEntry` to not call set JSON command on every request
+* fix(gcloud integration): fix the bool conversion of the `TI_GCLOUD_ENABLED` ENV variable
+* fix(redis integration): update links to official commands documentation
+
+## Version 1.1.6
+* feat(start instance): add fail-fast mode as default behavior on promise unhandled rejections
+* feat(start instance): implement functionality to derive safe default service domain name when none is provided in the configuration
+* feat(config): add support for new ENV variable `TI_FAIL_FAST_ON_UNHANDLED_OFF` that controls the fail-fast mode
+* feat(service instance): ensure instance ID naming standard is followed when creating new instances and no ID is provided in the configuration
+* feat(redis integration): marked command `hmset` as deprecated (according to official documentation)
+* feat(redis integration)!: change redis client default behavior: set to automatically resend all pending commands on connection recovery with no limit on the retry attempts. This behavior cannot be changed. Arguments `autoRetryUnfulfilled` and `maxRetries` have been removed from the constructor
+* feat(redis integration)!: add options to configure redis connection retry policy. This can be controlled with two new arguments in the constructor `retryMaxIntervalMs` and `retryMaxAttempts`.
+* feat(redis integration)!: improve and extend the behavior of pub/sub implementation functionality. The `subscribeCommand` method can now only subscribe once to the same channel. The client instance will keep a map of all channels it has subscribed to. To unsubscribe, use the `unsubscribeCommand` method
+* feat(redis integration): add a `shutDown` method to gracefully close a redis connection. This is now used on instance shut down sequence as well as in the default message sender and receiver implementations
+* fix(start instance): fix the logging of reason for unhandled rejections and multiple resolves
+* fix(service instance): use the static service domain name to initialize the health check instead of the ENV variable
+* fix(redis integration): add detection of ReJSON2 in the verification of JSON support in the redis server
+* build(npm): update npm dependencies to their latest versions
+* docs: add section about ENV variables to the `README.md` file
+
+## Version 1.1.5
+
+* fix(service instance): add overrides of the `reportHealthy` method in `ServiceConsumer` and `ServiceProvider` classes
+* fix(tester): implement `reportHealthy` method
+* docs(license): add a `LICENSE` file
+* docs(license): change all licensing information in source files to GNU 3.0
+* docs: improve the information in `README.md` file
+
 ## Version 1.1.4
 
 * feat(service instance): expose method `reportHealthy` and mark it as virtual to allow for overrides with custom health status reporting logic

package/README.md

@@ -12,12 +12,12 @@ The framework is created based on a decade of professional experience with the u
 
 This is what you gain by using **ti-engine** in your project:
 
-* Simplicity - begin productive work within minutes and get to codding you business logic
-* Flexibility - go as complex as you need to in your implementation
-* Reliability - message exchange between the services is constantly tracked across the entire ecosystem
-* Security - messages are encrypted in transit and cannot be modified by external agents
-* Scalability - serve mullions of requests by multiplying stateless service instances (hardware limitations still apply)
-* Containerization - go with containers from the very start as the framework is designed to work in such an environment
+* Simplicity: begin productive work within minutes and get to codding you business logic
+* Flexibility: go as complex as you need to in your implementation
+* Reliability: message exchange between the services is constantly tracked across the entire ecosystem
+* Security: messages are encrypted in transit and cannot be modified by external agents
+* Scalability: serve mullions of requests by multiplying stateless service instances (hardware limitations still apply)
+* Containerization: go with containers from the very start as the framework is designed to work in such an environment
 
 These are just some benefits **ti-engine** offers. Get to know it better to find out more ways in which it can help you improve productivity.
 
@@ -25,12 +25,12 @@ These are just some benefits **ti-engine** offers. Get to know it better to find
 
 Being a messaging system, the **ti-engine** relies on a message broker for the actual exchange of messages between microservice instances. The default implementation of the framework uses [Redis](https://redis.io/) cache, however, you could create your own implementation using something like [Rabbit MQ](https://www.rabbitmq.com/). See the [Advanced topics](#advanced-topics) section of this documentation for guides on how to do this. For now let's focus on the default setup.
 
-In order to run the basic ti-engine framework you will need a couple of things:
+In order to run the basic ti-engine framework, you will need a couple of things:
 
 * A local [node.js installation](https://nodejs.org/en/download/) with a minimum version of **14.17.0**
 * A local or remote [Redis cache installation](https://redis.io/download) with a minimum version of **5.0.14**
 
-If you are working under Windows 10+ OS and you need to install Redis, take a look at this [guide](https://redis.com/blog/redis-on-windows-10/). You could also use [Redis Cloud](https://app.redislabs.com/) for development purposes as it offers free basic account. You can configure your connection to remote Redis server using the following ENV variables:
+If you are working under Windows 10+ OS and you need to install Redis, take a look at this [guide](https://redis.com/blog/redis-on-windows-10/). You could also use [Redis Cloud](https://app.redislabs.com/) for development purposes as it offers free basic account. You can configure your connection to a remote Redis server using the following ENV variables:
 
 * `TI_MEMORY_CACHE_AUTH_KEY` can be used to provide the Redis password if there is any at all.
 * `TI_MEMORY_CACHE_REDIS_DB` can be used to specify the Redis DB you want to use. Make sure to set the correct number as for example Redis Cloud only uses DB `0`.
@@ -75,7 +75,7 @@ Now let's analyse that output. For the sake of completeness, the `[timestamp]` a
 At the start of the output log you can see a NOTICE that tells you a couple of important things:
 
 * The instance name - in this case `tester-service`. In the terminology of the framework, this is also known as a _service domain name_.
-* The _instance identificator_. It is an uuid string with a `ti-` prefix, that is generated by the framework at process start. It can and will be used to trace the messages during their movement through the microservice ecosystem. But more on that later.
+* The _instance identifier_. It is an uuid string with a `ti-` prefix, that is generated by the framework at process start. It can and will be used to trace the messages during their movement through the microservice ecosystem. But more on that later.
 
 Following that come a couple of INFO lines that inform you about the microservice interface state. The framework starts with the process of registration of _business services_ within the service domain of the microservice `tester-service` and successfully adds 2 such services. The necessary information for this is read from a JSON config file included in the package. We'll get into more details on what this all means in the section [Creating a microservice](#creating-a-microservice).
 
@@ -158,7 +158,7 @@ This tier comprises the actual implementation of your application. Its structure
 * It needs to take care of any type of stateful behavior like user sessions or transactions
 * It needs to act as the primary interface between users and your application thus handling access management and user interactions
 
-Depending on the type of software you are building, tier 3 can be an API Gateway, a Web application, backend for a Mobile application, or anything like that.
+Depending on the type of software you are building, tier 3 can be an API Gateway, a Web application, backend for a Mobile application or anything like that.
 
 ## Creating a microservice
 
@@ -226,9 +226,10 @@ You can find the full list of available ENV variables and what they do below in
 
 #### Application specific files
 
-Now let's look inside the `bin` folder. The two files there are the ones specified in the `.env` file. The `tester-service.js` contains the implementation of the `ServiceProvider` class. It has just three methods that contain its behavior:
+Now let's look inside the `bin` folder. The two files there are the ones specified in the `.env` file. The `tester-service.js` contains the implementation of the `ServiceProvider` class. It has just a few methods that contain its behavior:
 
 * Method `onStart` overrides the base one from the parent class and is invoked automatically by the framework once initialization of the microservice is complete. In this case the method invokes the execution of the test sequence just once and then the microservice remains dormant but active.
+* Method `reportHealthy` overrides but essentially just calls the same base method. Its only purpose here is to draw your attention to its existence and the possibility to implement your own health status reporting functionality if you want.
 * Method `verifyAccess` also overrides the base method and shows a very basic example of how to implement user access verification on business service level. Each time a service in the `ti-tester-service` is called, the framework will trigger this method and will only allow processing if there is a non-undefined value inside the `authToken` variable.
 * Method `#executeTests` is a custom private method that contains the test sequence itself. It is called by the `onStart` method just once per microservice start. Inside you can see two examples of calling a business service—in both cases the tester microservice is calling itself. In more practical situation, however, these calls would be directed towards other service domains.
 
@@ -337,6 +338,30 @@ And with this step we are done. The new microservice is now operational. You can
 
 ## Using the framework
 
+### Environment variables
+
+These are the system-level ENV variables that can be used to configure the framework. Use a .env file or corresponding containerization features to set the variables you need. Not all of these are mandatory or even required for every microservice you create. Consult the documentation for more details.
+
+TI_AUDITING_LOG_MIN_LEVEL
+: Type: Optional
+: Specifies the minimum log level that should be sent to the log output stream. The framework will filter out all log entries with level below this value. The default value is `200` (corresponding to INFO).
+
+TI_FAIL_FAST_ON_UNHANDLED_OFF
+: Type: Optional
+: Specifies whether the framework fail-fast on unhandled promise behavior should be turned off. Set this to `true` to disable the default behavior. The default value is `false`.
+
+TI_INSTANCE_CLASS
+: Type: Required
+: Specifies the relative path to the implementation of the `ServiceInstance` framework class—in this case a `ServiceProvider`. As stated above, the path is relative to the working directory of the `node` process. This variable is mandatory for every microservice you create with the **ti-engine**. If it is not provided the microservice won't be able to start at all, and you will get an exception.
+
+TI_INSTANCE_CONFIG
+: Type: Optional
+: Specifies the relative path to the configuration data for the microservice. Technically, you can omit this variable and the microservice will still start successfully with an empty configuration. There are very few cases, however, where this would be applicable.
+
+TI_INSTANCE_NAME
+: Type: Required
+: Specifies the _service domain_ name provided for the microservice. It has to be _unique_ in the context of the microservice ecosystem. If not provided, the framework will attempt to extract this information from the name of the implementation file. That is not a recommended approach though as it might cause hard to identify errors later.
+
 ### Framework settings
 
 Here you can find all settings used by **ti-engine** together with information on what they do. They are defined inside the `config` module and the full list can be accessed through the public `setting` enum. To get the current value of a setting, you can use the public method `getSetting` from the same module. Some settings can be overridden by providing ENV variables as specified below at node application start up.
@@ -397,7 +422,17 @@ MEMORY_CACHE_REDIS_HOST
 MEMORY_CACHE_REDIS_PORT
 : JSON path `memoryCache.redisPort`, type `number`, default `6379`
 : ENV variable `TI_MEMORY_CACHE_REDIS_PORT`
-: This setting holds the Redis server port.
+: This setting holds the Redis server port. By default, Redis uses `6379` however many implementations might use a custom port that needs to be specified in the connection settings.
+
+MEMORY_CACHE_RETRY_MAX_ATTEMPTS
+: JSON path `memoryCache.retryMaxAttempts`, type `number`, default `undefined`
+: ENV variable `TI_MEMORY_CACHE_RETRY_MAX_ATTEMPTS`
+: This setting holds the maximum number of attempts to (re)connect to the Redis server. By default there is no limit.
+
+MEMORY_CACHE_RETRY_MAX_INTERVAL
+: JSON path `memoryCache.retryMaxInterval`, type `number`, default `1000`
+: ENV variable `TI_MEMORY_CACHE_RETRY_MAX_INTERVAL`
+: This setting holds the maximum interval in milliseconds between retries when the Redis server is not available.
 
 MEMORY_CACHE_USER
 : JSON path `memoryCache.user`, type `string`, default `default`

package/bin/start-instance.js

@@ -1,25 +1,42 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2025 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 "use strict";
 
-const _ = require( "lodash" );
 const path = require( "path" );
 
-// load any ENV variables defined in a .env file - before including any framework files:
+// Load any ENV variables defined in a .env file - before including any framework files:
 require( "dotenv" ).config( { path: path.join( process.cwd(), ".env" ) } );
 
 const tools = require( "#tools" );
 const logger = require( "#logger" );
 
-// configure the current instance variables before requiring any platform modules and store the necessary ones in memory cache:
+// Configure the current instance variables before requiring any platform modules and store the necessary ones in memory cache:
 process.env.TI_INSTANCE_ID = "ti-" + tools.getUUID();
 process.env.TI_INSTANCE_CLASS = process.env.TI_INSTANCE_CLASS || "";
-process.env.TI_INSTANCE_NAME = process.env.TI_INSTANCE_NAME || _.last( _.split( process.env.TI_INSTANCE_CLASS, "/" ) );
 
-// configure the process error handlers:
+// Derive a safe default service domain name if not explicitly provided:
+// - Normalize path separators
+// - Strip directory and file extension
+const defaultNameFromClass = ( () => {
+    try {
+        const normalized = ( process.env.TI_INSTANCE_CLASS || "" ).replace( /\\/g, "/" );
+        const base = path.posix.basename( normalized );
+        const name = path.parse( base ).name;
+        return name || "";
+    } catch {
+        return "";
+    }
+} )();
+
+process.env.TI_INSTANCE_NAME = process.env.TI_INSTANCE_NAME || defaultNameFromClass;
+
+// Configure the process error handlers:
 
 /**
  * Will be used to gracefully shut down the instance.
@@ -34,35 +51,45 @@ process.env.TI_INSTANCE_NAME = process.env.TI_INSTANCE_NAME || _.last( _.split(
 let shutDownInstance = ( exitCode ) => {
 };
 
-// this event will handle the process termination (Ctrl + C):
+// This event will handle the process termination (Ctrl + C):
 process.on( "SIGINT", () => {
     logger.log( `SIGINT event detected in main instance process.`, logger.logSeverity.NOTICE );
     shutDownInstance( 0 );
 } );
 
-// this event will handle the process termination (CMD close):
+// This event will handle the process termination via terminal hangup (CMD close) - not delivered on all platforms:
 process.on( "SIGHUP", () => {
     logger.log( `SIGHUP event detected in main instance process.`, logger.logSeverity.NOTICE );
     shutDownInstance( 0 );
 } );
 
-// this event will handle the process termination:
+// This event will handle the process termination:
 process.on( "SIGTERM", () => {
     logger.log( `SIGTERM event detected in main instance process.`, logger.logSeverity.NOTICE );
     shutDownInstance( 0 );
 } );
 
-process.on( "unhandledRejection", ( reason, promise ) => {
+// Handle Windows console break (Ctrl + Break):
+process.on( "SIGBREAK", () => {
+    logger.log( `SIGBREAK event detected in main instance process.`, logger.logSeverity.NOTICE );
+    shutDownInstance( 0 );
+} );
+
+process.on( "unhandledRejection", ( reason ) => {
+    // Check if the fail-fast behavior has been forcefully disabled:
+    const failFastDisabled = tools.toBool( process.env.TI_FAIL_FAST_ON_UNHANDLED_OFF || "" );
     logger.log( `Unhandled promise rejection identified! Make sure this isn't a software bug.`, logger.logSeverity.WARNING, {
-        reason: reason,
-        promise: tools.stringifyJSON( promise )
+        reason: tools.errorToJSON && reason instanceof Error ? tools.errorToJSON( reason ) : reason
     } );
+    if ( failFastDisabled !== true ) {
+        setImmediate( () => process.exit( 1 ) );
+    }
 } );
 
 process.on( "multipleResolves", ( type, promise, reason ) => {
     logger.log( `Multiple promise resolves detected! Make sure this isn't a software bug.`, logger.logSeverity.WARNING, {
-        reason: reason,
-        promise: tools.stringifyJSON( promise )
+        type,
+        reason: tools.errorToJSON && reason instanceof Error ? tools.errorToJSON( reason ) : reason
     } );
 } );
 
@@ -71,7 +98,7 @@ process.on( "uncaughtException", ( error ) => {
     setImmediate( () => process.exit( 1 ) );
 } );
 
-// start the instance:
+// Start the instance:
 try {
     logger.log( `Starting new instance of type '${ process.env.TI_INSTANCE_NAME }' with instance ID '${ process.env.TI_INSTANCE_ID }'.`, logger.logSeverity.NOTICE );
 
@@ -107,4 +134,4 @@ try {
 } catch ( error ) {
     logger.log( `Error detected in the instance startup script!`, logger.logSeverity.ALERT, error );
     setImmediate( () => process.exit( 1 ) );
-}
+}

package/components/auditing.js

@@ -1,7 +1,10 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2025 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 const _ = require( "lodash" );
 const tools = require( "#tools" );
@@ -17,7 +20,7 @@ const gcloud = require( "#gcloud-integration" );
  * @property {string} reporter
  * @property {string} message The actual log message.
  * @property {number} timestamp The timestamp of the log entry in UTC time.
- * @property {Object} data Additional JSON data to accompany the message.
+ * @property {Object} data Additional JSON data to go with the message.
  */
 
 /**
@@ -160,4 +163,4 @@ class Auditing {
 }
 
 const instance = new Auditing();
-module.exports = Object.freeze( instance );
+module.exports.instance = Object.freeze( instance );

package/components/connection-observer.js

@@ -1,7 +1,10 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 const exceptions = require( "#exceptions" );
 

package/components/exchange/default/default-message-exchange.js

@@ -1,7 +1,10 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 const MessageExchange = require( "#message-exchange" );
 const config = require( "#config" );
@@ -33,8 +36,8 @@ class DefaultMessageExchange extends MessageExchange {
      * NOTE: This will create and prepare all necessary message handlers and then enable them simultaneously.
      *
      * @method
-     * @param {boolean} configureInbound If set to 'true' it tells the message exchange to setup inbound messaging.
-     * @param {boolean} configureOutbound If set to 'true' it tells the message exchange to setup outbound messaging.
+     * @param {boolean} configureInbound If set to 'true' it tells the message exchange to set up inbound messaging.
+     * @param {boolean} configureOutbound If set to 'true' it tells the message exchange to set up outbound messaging.
      * @returns {Promise}
      * @override
      * @public

package/components/exchange/default/default-message-receiver.js

@@ -1,7 +1,10 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 const MessageReceiver = require( "#message-receiver" );
 const memoryCache = require( "#message-memory-cache" );
@@ -46,7 +49,7 @@ class DefaultMessageReceiver extends MessageReceiver {
     }
 
     /**
-     * Used to shutdown and disable the communication behavior of the handler.
+     * Used to shut down and disable the communication behavior of the handler.
      *
      * @method
      * @returns {Promise}
@@ -56,8 +59,12 @@ class DefaultMessageReceiver extends MessageReceiver {
     disable() {
         return new Promise( ( resolve, reject ) => {
             this.isAvailable = false;
-            this.#memoryCache = null;
-            resolve();
+            this.#memoryCache.shutDown().then( () => {
+                this.#memoryCache = null;
+                resolve();
+            } ).catch( ( error ) => {
+                reject( exceptions.raise( error ) );
+            } );
         } );
     }
 

package/components/exchange/default/default-message-sender.js

@@ -1,7 +1,10 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 const MessageSender = require( "#message-sender" );
 const _ = require( "lodash" );
@@ -71,7 +74,7 @@ class DefaultMessageSender extends MessageSender {
     }
 
     /**
-     * Used to shutdown and disable the communication behavior of the handler.
+     * Used to shut down and disable the communication behavior of the handler.
      *
      * @method
      * @returns {Promise}
@@ -81,8 +84,12 @@ class DefaultMessageSender extends MessageSender {
     disable() {
         return new Promise( ( resolve, reject ) => {
             this.isAvailable = false;
-            this.#memoryCache = null;
-            resolve();
+            this.#memoryCache.shutDown().then( () => {
+                this.#memoryCache = null;
+                resolve();
+            } ).catch( ( error ) => {
+                reject( exceptions.raise( error ) );
+            } );
         } );
     }
 }

package/components/exchange/message-dispatcher.js

@@ -1,7 +1,10 @@
 /*
- * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
- * SPDX-License-Identifier: ICU
- */
+ * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
+ * Copyright © 2021-2025 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
 
 const tools = require( "#tools" );
 const exceptions = require( "#exceptions" );
@@ -40,15 +43,19 @@ class MessageDispatcher {
      *
      * @method
      * @param {MessageExchange} messageExchange The message exchange instance to be used by the dispatcher.
-     * @param {boolean} configureInbound If set to 'true' it tells the message exchange to setup inbound messaging.
-     * @param {boolean} configureOutbound If set to 'true' it tells the message exchange to setup outbound messaging.
+     * @param {boolean} configureInbound If set to 'true' it tells the message exchange to set up inbound messaging.
+     * @param {boolean} configureOutbound If set to 'true' it tells the message exchange to set up outbound messaging.
      * @returns {Promise}
      * @public
      */
     initialize( messageExchange, configureInbound, configureOutbound ) {
         return new Promise( ( resolve, reject ) => {
             this.#messageExchange = messageExchange;
-            this.#messageExchange.enableMessaging( configureInbound, configureOutbound ).then( () => {
+
+            // Initialize the message tracer before enabling the message exchange:
+            messageTracer.instance.initialize().then( () => {
+                this.#messageExchange.enableMessaging( configureInbound, configureOutbound );
+            } ).then( () => {
                 resolve();
             } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );
@@ -92,13 +99,13 @@ class MessageDispatcher {
                 logger.log( `Retrying to send message response with chain ID: ${ message.chainID }. This is attempt ${ attempt }...`, logger.logSeverity.NOTICE );
             } );
 
-            messageTracer.recordTraceEntry( message, messageTracer.messageType.MESSAGE_REQUEST, messageTracer.dispatchEvent.SENT, messageTracer.messageState.PENDING );
+            messageTracer.instance.recordTraceEntry( message, messageTracer.messageType.MESSAGE_REQUEST, messageTracer.dispatchEvent.SENT, messageTracer.messageState.PENDING );
 
             retry.execute( this.#messageExchange, this.#messageExchange.sendMessageRequest, [ message ] ).then( () => {
-                messageTracer.recordTraceEntry( message, messageTracer.messageType.MESSAGE_REQUEST, messageTracer.dispatchEvent.DELIVERED, messageTracer.messageState.PENDING );
+                messageTracer.instance.recordTraceEntry( message, messageTracer.messageType.MESSAGE_REQUEST, messageTracer.dispatchEvent.DELIVERED, messageTracer.messageState.PENDING );
                 resolve( message.messageID );
             } ).catch( ( error ) => {
-                messageTracer.recordTraceEntry( message, messageTracer.messageType.MESSAGE_REQUEST, messageTracer.dispatchEvent.FAILED, messageTracer.messageState.PENDING );
+                messageTracer.instance.recordTraceEntry( message, messageTracer.messageType.MESSAGE_REQUEST, messageTracer.dispatchEvent.FAILED, messageTracer.messageState.PENDING );
                 reject( exceptions.raise( error ) );
             } );
         } );
@@ -122,13 +129,13 @@ class MessageDispatcher {
                 logger.log( `Retrying to send message response with chain ID: ${ message.chainID }. This is attempt ${ attempt }...`, logger.logSeverity.NOTICE );
             } );
 
-            messageTracer.recordTraceEntry( message, messageTracer.messageType.MESSAGE_RESPONSE, messageTracer.dispatchEvent.SENT, messageTracer.messageState.PROCESSED );
+            messageTracer.instance.recordTraceEntry( message, messageTracer.messageType.MESSAGE_RESPONSE, messageTracer.dispatchEvent.SENT, messageTracer.messageState.PROCESSED );
 
             retry.execute( this.#messageExchange, this.#messageExchange.sendMessageResponse, [ message ] ).then( () => {
-                messageTracer.recordTraceEntry( message, messageTracer.messageType.MESSAGE_RESPONSE, messageTracer.dispatchEvent.DELIVERED, messageTracer.messageState.PROCESSED );
+                messageTracer.instance.recordTraceEntry( message, messageTracer.messageType.MESSAGE_RESPONSE, messageTracer.dispatchEvent.DELIVERED, messageTracer.messageState.PROCESSED );
                 resolve();
             } ).catch( ( error ) => {
-                messageTracer.recordTraceEntry( message, messageTracer.messageType.MESSAGE_RESPONSE, messageTracer.dispatchEvent.FAILED, messageTracer.messageState.PROCESSED );
+                messageTracer.instance.recordTraceEntry( message, messageTracer.messageType.MESSAGE_RESPONSE, messageTracer.dispatchEvent.FAILED, messageTracer.messageState.PROCESSED );
                 reject( exceptions.raise( error ) );
             } );
         } );
@@ -159,4 +166,4 @@ class MessageDispatcher {
 }
 
 const instance = new MessageDispatcher();
-module.exports = Object.freeze( instance );
+module.exports.instance = Object.freeze( instance );