@ti-engine/core 1.1.5 → 1.1.9

package/components/exchange/message-tracer.js

@@ -1,6 +1,6 @@
 /*
  * 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>
+ * 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/>.
@@ -82,103 +82,149 @@ let messageStateEnum = tools.enum( {
 module.exports.messageState = messageStateEnum;
 
 /**
- * Used to create a log entry from the trace entry.
+ * Used for recording message trace entries.
  *
- * @method
- * @param {TiTraceEntry} traceEntry The trace entry to log.
- * @param {TiLogSeverity} severity The log entry severity.
- * @private
+ * @class MessageTracer
+ * @singleton
+ * @public
  */
-let createLogEntry = ( traceEntry, severity ) => {
-    logger.log( formatLogEntry( traceEntry ), severity, traceEntry );
-};
+class MessageTracer {
 
-/**
- * Used to format trace entry into log-suitable string.
- *
- * @method
- * @param {TiTraceEntry} traceEntry
- * @return {string} Prepared trace info.
- * @private
- */
-let formatLogEntry = ( traceEntry ) => {
-    return `Message(${ traceEntry.chainID || traceEntry.messageID }) Trace: '${ traceEntry.messageType } ${ traceEntry.dispatchEvent } ${ traceEntry.messageState }' From: '${ traceEntry.fromAddress }' To: '${ traceEntry.toAddress }'`;
-};
+    static #instance = null;
 
-/**
- * Used to obscure sensitive data in the message, remove the payload, and return a snapshot.
- *
- * @method
- * @param {Message} message
- * @returns {Message}
- * @private
- */
-let obscureSensitiveData = ( message ) => {
-    /** @type Message */
-    let messageSnapshot = tools.parseJSON( _.replace( tools.stringifyJSON( message ), /("\w*?pin\w*?"|"\w*?pass\w*?"|"\w*?otp\w*?"):"(.*?)"/gmi, "\"SENSITIVE_PROPERTY\":\"OBSCURED_BY_SYSTEM\"" ) );
-    delete messageSnapshot.payload;
-    return messageSnapshot;
-};
-
-/**
- * Used to create a trace entry for the provided {@link Message} and parameters.
- * <br/>
- * NOTE: By default all trace events are stored in the memory cache for further processing and analysis. The
- * location is configured in the MESSAGE_EXCHANGE_TRACE_REPOSITORY setting.
- * <br/>
- * NOTE: Trace events are logged with severity level NOTICE or ERROR for failed dispatches. They still might be
- * filtered out if the minimum log level setting is set too high.
- *
- * @method
- * @param {Message} message The message to trace.
- * @param {TiMessageType} messageType The type of the message.
- * @param {TiDispatchEvent} dispatchEvent The event in the dispatch system that triggered the trace entry.
- * @param {TiMessageState} messageState The state of the processing of the message.
- * @public
- */
-module.exports.recordTraceEntry = ( message, messageType, dispatchEvent, messageState ) => {
-    // depending on whether the message comes as request or response, the from and to addresses will be opposite:
-    let source = message.source.route + "." + message.source.instanceID;
-    let destination = message.destination.route + ( ( message.destination.instanceID != null ) ? "." + message.destination.instanceID : "" );
-    let messageSnapshot = obscureSensitiveData( message );
-    delete messageSnapshot.chainID;
-    delete messageSnapshot.messageID;
-    let currentDate = new Date();
-
-    /** @type TiTraceEntry */
-    let traceEntry = {
-        chainID: message.chainID,
-        dispatchEvent: tools.getEnumName( dispatchEventEnum, dispatchEvent ),
-        fromAddress: ( messageType === messageTypeEnum.MESSAGE_REQUEST ) ? source : destination,
-        messageID: message.messageID,
-        messageSnapshot: messageSnapshot,
-        messageState: tools.getEnumName( messageStateEnum, messageState ),
-        messageType: tools.getEnumName( messageTypeEnum, messageType ),
-        toAddress: ( messageType === messageTypeEnum.MESSAGE_REQUEST ) ? destination : source,
-        traceTimestamp: currentDate.getTime(),
-        traceID: tools.getUUID()
-    };
-
-    // only write the trace in the general log if this is enabled:
-    if ( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_LOG_ENABLED ) === true ) {
-        createLogEntry( traceEntry, ( dispatchEvent === dispatchEventEnum.FAILED ) ? logger.logSeverity.ERROR : logger.logSeverity.NOTICE );
+    /**
+     * @constructor
+     * @return {MessageTracer}
+     */
+    constructor() {
+        if ( !MessageTracer.#instance ) {
+            MessageTracer.#instance = this;
+        }
+        return MessageTracer.#instance;
     }
 
-    // add the trace entry to the repository in the memory cache:
-    cache.setJSON( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceRoot, "$", 1 ).then( () => {
-        return cache.arrayAppendJSON( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceEntry, "$.trace" );
-    } ).then( () => {
-        // this will refresh the expiration time for the trace repository on each new record:
-        let expiration = config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_EXPIRATION_TIME );
-        return ( expiration > 0 ) ? cache.expireValue( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), expiration ) : expiration;
-    } ).catch( ( error ) => {
-        if ( error.code === exceptions.exceptionCode.E_GEN_FEATURE_UNSUPPORTED ) {
-            cache.addToSet( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceEntry ).catch( ( error ) => {
-                logger.log( `Failed to add message trace entry to the trace repository. While this will not prevent the application from running, it might still be a sign of a more serious problem!`, logger.logSeverity.WARNING, error );
+    /* Public interface */
+
+    /**
+     * Used to initialize the message tracer.
+     *
+     * @method
+     * @returns {Promise}
+     * @public
+     */
+    initialize() {
+        return new Promise( ( resolve, reject ) => {
+            cache.instance.setJSON( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceRoot, "$", 1 ).then( () => {
+                resolve();
+            } ).catch( ( error ) => {
+                reject( exceptions.raise( error ) );
             } );
-        } else {
-            logger.log( `Failed to add message trace entry to the trace repository. While this will not prevent the application from running, it might still be a sign of a more serious problem!`, logger.logSeverity.WARNING, error );
+        } );
+    }
+
+    /**
+     * Used to create a trace entry for the provided {@link Message} and parameters.
+     * <br/>
+     * NOTE: By default all trace events are stored in the memory cache for further processing and analysis. The
+     * location is configured in the MESSAGE_EXCHANGE_TRACE_REPOSITORY setting.
+     * <br/>
+     * NOTE: Trace events are logged with severity level NOTICE or ERROR for failed dispatches. They still might be
+     * filtered out if the minimum log level setting is set too high.
+     *
+     * @method
+     * @param {Message} message The message to trace.
+     * @param {TiMessageType} messageType The type of the message.
+     * @param {TiDispatchEvent} dispatchEvent The event in the dispatch system that triggered the trace entry.
+     * @param {TiMessageState} messageState The state of the message processing.
+     * @public
+     */
+    recordTraceEntry( message, messageType, dispatchEvent, messageState ) {
+        // Depending on whether the message comes as request or response, the from and to addresses will be opposite:
+        let source = message.source.route + "." + message.source.instanceID;
+        let destination = message.destination.route + ( ( message.destination.instanceID != null ) ? "." + message.destination.instanceID : "" );
+        let messageSnapshot = MessageTracer.#obscureSensitiveData( message );
+        delete messageSnapshot.chainID;
+        delete messageSnapshot.messageID;
+        let currentDate = new Date();
+
+        /** @type TiTraceEntry */
+        let traceEntry = {
+            chainID: message.chainID,
+            dispatchEvent: tools.getEnumName( dispatchEventEnum, dispatchEvent ),
+            fromAddress: ( messageType === messageTypeEnum.MESSAGE_REQUEST ) ? source : destination,
+            messageID: message.messageID,
+            messageSnapshot: messageSnapshot,
+            messageState: tools.getEnumName( messageStateEnum, messageState ),
+            messageType: tools.getEnumName( messageTypeEnum, messageType ),
+            toAddress: ( messageType === messageTypeEnum.MESSAGE_REQUEST ) ? destination : source,
+            traceTimestamp: currentDate.getTime(),
+            traceID: tools.getUUID()
+        };
+
+        // Only write the trace in the general log if this is enabled:
+        if ( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_LOG_ENABLED ) === true ) {
+            MessageTracer.#createLogEntry( traceEntry, ( dispatchEvent === dispatchEventEnum.FAILED ) ? logger.logSeverity.ERROR : logger.logSeverity.NOTICE );
         }
-    } );
 
-};
+        // Add the trace entry to the repository in the memory cache:
+        cache.instance.arrayAppendJSON( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceEntry, "$.trace" ).then( () => {
+            // This will refresh the expiration time for the trace repository on each new record:
+            let expiration = config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_EXPIRATION_TIME );
+            return ( expiration > 0 ) ? cache.instance.expireValue( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), expiration ) : expiration;
+        } ).catch( ( error ) => {
+            // If JSON is unsupported in Redis server, then try to store the trace entry in a Set:
+            if ( error.code === exceptions.exceptionCode.E_GEN_FEATURE_UNSUPPORTED ) {
+                cache.instance.addToSet( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceEntry ).catch( ( error ) => {
+                    logger.log( `Failed to add message trace entry to the trace repository. While this will not prevent the application from running, it might still be a sign of a more serious problem!`, logger.logSeverity.WARNING, error );
+                } );
+            } else {
+                logger.log( `Failed to add message trace entry to the trace repository. While this will not prevent the application from running, it might still be a sign of a more serious problem!`, logger.logSeverity.WARNING, error );
+            }
+        } );
+    }
+
+    /* Private interface */
+
+    /**
+     * Used to create a log entry from the trace entry.
+     *
+     * @method
+     * @param {TiTraceEntry} traceEntry The trace entry to log.
+     * @param {TiLogSeverity} severity The log entry severity.
+     * @private
+     */
+    static #createLogEntry( traceEntry, severity ) {
+        logger.log( MessageTracer.#formatLogEntry( traceEntry ), severity, traceEntry );
+    }
+
+    /**
+     * Used to format trace entry into log-suitable string.
+     *
+     * @method
+     * @param {TiTraceEntry} traceEntry
+     * @return {string} Prepared trace info.
+     * @private
+     */
+    static #formatLogEntry( traceEntry ) {
+        return `Message(${ traceEntry.chainID || traceEntry.messageID }) Trace: '${ traceEntry.messageType } ${ traceEntry.dispatchEvent } ${ traceEntry.messageState }' From: '${ traceEntry.fromAddress }' To: '${ traceEntry.toAddress }'`;
+    }
+
+    /**
+     * Used to obscure sensitive data in the message, remove the payload, and return a snapshot.
+     *
+     * @method
+     * @param {Message} message
+     * @returns {Message}
+     * @private
+     */
+    static #obscureSensitiveData( message ) {
+        /** @type Message */
+        let messageSnapshot = tools.parseJSON( _.replace( tools.stringifyJSON( message ), /("\w*?pin\w*?"|"\w*?pass\w*?"|"\w*?otp\w*?"):"(.*?)"/gmi, "\"SENSITIVE_PROPERTY\":\"OBSCURED_BY_SYSTEM\"" ) );
+        delete messageSnapshot.payload;
+        return messageSnapshot;
+    }
+
+}
+
+const instance = new MessageTracer();
+module.exports.instance = Object.freeze( instance );

package/components/service-caller.js

@@ -1,6 +1,6 @@
 /*
  * 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>
+ * 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/>.
@@ -95,7 +95,7 @@ class ServiceCaller extends MessageObserver {
             this.#findServiceInRegistry( serviceAddress ).then( () => {
                 return this.#prepareServiceCall( serviceAddress, serviceParams, serviceExecContext );
             } ).then( ( serviceCall ) => {
-                return messageDispatcher.sendRequest( serviceCall );
+                return messageDispatcher.instance.sendRequest( serviceCall );
             } ).then( ( messageID ) => {
                 this.#addTaskHandler( messageID, ( serviceCall ) => {
                     this.#completeServiceCall( serviceCall ).then( ( serviceCall ) => {
@@ -187,7 +187,7 @@ class ServiceCaller extends MessageObserver {
     #findServiceInRegistry( serviceAddress ) {
         return new Promise( ( resolve, reject ) => {
             let serviceCatalog = config.getSetting( config.setting.SERVICE_REGISTRY_ADDRESS ) + serviceAddress.serviceDomainName;
-            cache.isSetMember( serviceCatalog, serviceAddress.serviceAlias ).then( ( result ) => {
+            cache.instance.isSetMember( serviceCatalog, serviceAddress.serviceAlias ).then( ( result ) => {
                 if ( result === true ) {
                     resolve();
                 } else {
@@ -210,7 +210,7 @@ class ServiceCaller extends MessageObserver {
      * @private
      */
     #prepareServiceCall( serviceAddress, serviceParams, serviceExecContext ) {
-        return new Promise( ( resolve, reject ) => {
+        return new Promise( ( resolve ) => {
             const ServiceInstance = require( "#service-instance" );
 
             // assemble the new service call:
@@ -258,7 +258,7 @@ class ServiceCaller extends MessageObserver {
      * @private
      */
     #completeServiceCall( serviceCall ) {
-        return new Promise( ( resolve, reject ) => {
+        return new Promise( ( resolve ) => {
             serviceCall.finishedOn = Date.now();
             serviceCall.executionTime = serviceCall.finishedOn - serviceCall.createdOn;
             serviceCall.isCompleted = true;
@@ -306,4 +306,4 @@ class ServiceCaller extends MessageObserver {
 
 }
 
-module.exports = ServiceCaller;
+module.exports = ServiceCaller;

package/components/service-consumer.js

@@ -1,6 +1,6 @@
 /*
  * 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>
+ * 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/>.
@@ -65,7 +65,7 @@ class ServiceConsumer extends ServiceInstance {
             this.#serviceCaller = new ServiceCaller();
 
             super.onStart().then( () => {
-                messageDispatcher.addMessageObserverResponsesIn( this.#serviceCaller );
+                messageDispatcher.instance.addMessageObserverResponsesIn( this.#serviceCaller );
                 resolve();
             } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );
@@ -128,4 +128,4 @@ class ServiceConsumer extends ServiceInstance {
 
 }
 
-module.exports = ServiceConsumer;
+module.exports = ServiceConsumer;

package/components/service-executor.js

@@ -58,6 +58,8 @@ class ServiceExecutor extends MessageObserver {
     #serviceInterface = {};
     /** @type VerifyAccessMethod */
     #verifyAccess;
+    #registrationTasks = {};
+    #registrationRetryInterval = 500;
 
     /**
      * @constructor
@@ -65,11 +67,12 @@ class ServiceExecutor extends MessageObserver {
     constructor() {
         super();
 
+        // Setup a default empty verify access method:
         this.#verifyAccess = () => {
             return Promise.resolve();
         };
 
-        cache.addConnectionObserver( this );
+        cache.instance.addConnectionObserver( this );
     }
 
     /* Public interface */
@@ -81,7 +84,9 @@ class ServiceExecutor extends MessageObserver {
      * @returns {ServiceInterface}
      * @public
      */
-    get serviceInterface() { return this.#serviceInterface; }
+    get serviceInterface() {
+        return this.#serviceInterface;
+    }
 
     /**
      *
@@ -94,7 +99,7 @@ class ServiceExecutor extends MessageObserver {
      */
     onMessage( identifier, message ) {
         this.#processServiceCall( message ).then( ( serviceCall ) => {
-            return messageDispatcher.sendResponse( serviceCall );
+            return messageDispatcher.instance.sendResponse( serviceCall );
         } ).catch( ( error ) => {
             logger.log( `Failed to send service call response after processing! Service call ID was: '${ message.messageID }'`, logger.logSeverity.ERROR, error );
         } );
@@ -123,17 +128,15 @@ class ServiceExecutor extends MessageObserver {
     onConnectionRecovered( identifier ) {
         super.onConnectionRecovered( identifier );
 
-        if ( identifier !== cache.connectionIdentifier ) {
-            if ( cache.isOperational ) {
-                let serviceCatalog = config.getSetting( config.setting.SERVICE_REGISTRY_ADDRESS ) + ServiceInstance.serviceDomainName;
-                _.forOwn( this.#serviceInterface, ( versions, serviceAlias ) => {
-                    cache.addToSet( serviceCatalog, serviceAlias ).catch( ( error ) => {
-                        logger.log( `Record for service '${ serviceAlias }' could not be added to the service registry.`, logger.logSeverity.ERROR, error );
-                    } );
-                } );
-            } else {
-                //TODO: Retry service registration after 0.5 seconds.
-            }
+        if ( identifier !== cache.instance.connectionIdentifier ) {
+            let serviceCatalog = config.getSetting( config.setting.SERVICE_REGISTRY_ADDRESS ) + ServiceInstance.serviceDomainName;
+            _.forOwn( this.#serviceInterface, ( versions, serviceAlias ) => {
+                if ( !this.#registrationTasks[ serviceAlias ] ) {
+                    this.#registrationTasks[ serviceAlias ] = setInterval( () => {
+                        this.#registerServiceToCatalog( serviceCatalog, serviceAlias );
+                    }, this.#registrationRetryInterval );
+                }
+            } );
         }
     }
 
@@ -200,6 +203,25 @@ class ServiceExecutor extends MessageObserver {
         };
     }
 
+    /**
+     * Used to register a service in the service registry.
+     *
+     * @method
+     * @param {string} serviceCatalog
+     * @param {string} serviceAlias
+     * @private
+     */
+    #registerServiceToCatalog( serviceCatalog, serviceAlias ) {
+        if ( cache.instance.isOperational ) {
+            cache.instance.addToSet( serviceCatalog, serviceAlias ).then( () => {
+                clearTimeout( this.#registrationTasks[ serviceAlias ] );
+                delete this.#registrationTasks[ serviceAlias ];
+            } ).catch( ( error ) => {
+                logger.log( `Record for service '${ serviceAlias }' could not be added to the service registry. Will retry in '${ this.#registrationRetryInterval }' milliseconds.`, logger.logSeverity.ERROR, error );
+            } );
+        }
+    }
+
     /**
      * Used to process the actual service call.
      *
@@ -209,7 +231,7 @@ class ServiceExecutor extends MessageObserver {
      * @private
      */
     #processServiceCall( serviceCall ) {
-        return new Promise( ( resolve, reject ) => {
+        return new Promise( ( resolve ) => {
             this.#verifyAccess( serviceCall.authToken, serviceCall.serviceAddress ).then( () => {
                 return this.#identifyService( serviceCall.serviceAddress );
             } ).then( ( serviceHandler ) => {
@@ -256,4 +278,4 @@ class ServiceExecutor extends MessageObserver {
 
 }
 
-module.exports = ServiceExecutor;
+module.exports = ServiceExecutor;

package/components/service-instance.js

@@ -1,6 +1,6 @@
 /*
  * 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>
+ * 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/>.
@@ -24,8 +24,6 @@ const messageDispatcher = require( "#message-dispatcher" );
  * Abstract class used to define a Service Instance behavior.
  * <br/>
  * NOTE: Inherit this to create a module that can be started as a microservice instance.
- * <br/>
- * NOTE: This class does not
  *
  * @class ServiceInstance
  * @abstract
@@ -46,12 +44,22 @@ class ServiceInstance {
      * @param {Object} [serviceConfig={}] The JSON configuration for this service.
      */
     constructor( serviceDomainName, serviceConfig = {} ) {
-        // make sure this abstract class cannot be instantiated:
+        // Ensure this abstract class cannot be instantiated:
         if ( new.target === ServiceInstance ) {
             throw exceptions.raise( exceptions.exceptionCode.E_GEN_ABSTRACT_CLASS_INIT, { name: this.constructor.name } );
         }
 
-        ServiceInstance.#instanceID = process.env.TI_INSTANCE_ID || tools.getUUID();
+        // Guard against multiple instances in a single process (not supported):
+        if ( ServiceInstance.#instanceID && ServiceInstance.#serviceDomainName ) {
+            throw exceptions.raise( exceptions.exceptionCode.E_GEN_FEATURE_UNSUPPORTED, {
+                details: "Multiple ServiceInstance initializations per process are not supported."
+            } );
+        }
+
+        // Ensure uniform 'ti-' prefix even if env is missing or custom starter script is used:
+        const envID = process.env.TI_INSTANCE_ID;
+        ServiceInstance.#instanceID = ( envID && String( envID ).startsWith( "ti-" ) ) ? envID : ( "ti-" + ( envID || tools.getUUID() ) );
+
         ServiceInstance.#serviceDomainName = serviceDomainName;
         this.#serviceConfig = ( _.isObjectLike( serviceConfig ) ) ? serviceConfig : { services: [] };
     }
@@ -65,7 +73,9 @@ class ServiceInstance {
      * @returns {string}
      * @public
      */
-    static get instanceID() { return ServiceInstance.#instanceID; }
+    static get instanceID() {
+        return ServiceInstance.#instanceID;
+    }
 
     /**
      * Property returning the current service domain name.
@@ -74,7 +84,9 @@ class ServiceInstance {
      * @returns {string}
      * @public
      */
-    static get serviceDomainName() { return ServiceInstance.#serviceDomainName; }
+    static get serviceDomainName() {
+        return ServiceInstance.#serviceDomainName;
+    }
 
     /**
      * Property to indicate that this and every child class is a {@link ServiceInstance}.
@@ -83,7 +95,9 @@ class ServiceInstance {
      * @returns {boolean}
      * @public
      */
-    get isServiceInstance() { return true; }
+    get isServiceInstance() {
+        return true;
+    }
 
     /**
      * Property returning the service configuration JSON.
@@ -92,7 +106,9 @@ class ServiceInstance {
      * @returns {ServiceConfiguration}
      * @public
      */
-    get serviceConfig() { return this.#serviceConfig; }
+    get serviceConfig() {
+        return this.#serviceConfig;
+    }
 
     /**
      * Initializes the instance.
@@ -134,14 +150,16 @@ class ServiceInstance {
      */
     onStart() {
         return new Promise( ( resolve, reject ) => {
-            const DefaultMessageExchange = require( "#default-message-exchange" );
-            const ServiceProvider = require( "#service-provider" );
-            const ServiceConsumer = require( "#service-consumer" );
+            cache.instance.initialize().then( () => {
+                const DefaultMessageExchange = require( "#default-message-exchange" );
+                const ServiceProvider = require( "#service-provider" );
+                const ServiceConsumer = require( "#service-consumer" );
 
-            let configureInbound = ( this instanceof ServiceProvider );
-            let configureOutbound = ( this instanceof ServiceConsumer );
+                let configureInbound = ( this instanceof ServiceProvider );
+                let configureOutbound = ( this instanceof ServiceConsumer );
 
-            messageDispatcher.initialize( new DefaultMessageExchange( ServiceInstance.instanceID, ServiceInstance.serviceDomainName ), configureInbound, configureOutbound ).then( () => {
+                return messageDispatcher.instance.initialize( new DefaultMessageExchange( ServiceInstance.instanceID, ServiceInstance.serviceDomainName ), configureInbound, configureOutbound );
+            } ).then( () => {
                 resolve();
             } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );
@@ -160,6 +178,8 @@ class ServiceInstance {
         return new Promise( ( resolve, reject ) => {
             this.#preStop().then( () => {
                 return this.onStop();
+            } ).then( () => {
+                return cache.instance.shutDown();
             } ).then( () => {
                 return this.#postStop();
             } ).then( () => {
@@ -175,7 +195,7 @@ class ServiceInstance {
      * <br/>
      * NOTE: This method will be invoked automatically.
      * <br/>
-     * NOTE: If you need to add more onStop logic you can override this method but make sure to call it in the
+     * NOTE: If you need to add more onStop logic, you can override this method but make sure to call it in the
      * overriding method using: super.onStop()
      *
      * @method
@@ -185,7 +205,7 @@ class ServiceInstance {
      */
     onStop() {
         return new Promise( ( resolve, reject ) => {
-            messageDispatcher.shutDown().then( () => {
+            messageDispatcher.instance.shutDown().then( () => {
                 resolve();
             } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );
@@ -205,9 +225,9 @@ class ServiceInstance {
      * @public
      */
     reportHealthy() {
-        if ( cache.isOperational ) {
+        if ( cache.instance.isOperational ) {
             let timestamp = new Date();
-            cache.setValue( this.#serviceHealthCheck, timestamp.toISOString(), config.getSetting( config.setting.SERVICE_HEALTH_CHECK_TIMEOUT ) ).catch( ( error ) => {
+            cache.instance.setValue( this.#serviceHealthCheck, timestamp.toISOString(), config.getSetting( config.setting.SERVICE_HEALTH_CHECK_TIMEOUT ) ).catch( ( error ) => {
                 logger.log( `Error while trying to report for health check from '${ ServiceInstance.instanceID }'!`, logger.logSeverity.WARNING, error );
             } );
         }
@@ -225,8 +245,8 @@ class ServiceInstance {
      * @private
      */
     #preStart() {
-        return new Promise( ( resolve, reject ) => {
-            this.#serviceHealthCheck = config.getSetting( config.setting.SERVICE_HEALTH_CHECK_ADDRESS ) + process.env.TI_INSTANCE_NAME + ":" + ServiceInstance.instanceID;
+        return new Promise( ( resolve ) => {
+            this.#serviceHealthCheck = config.getSetting( config.setting.SERVICE_HEALTH_CHECK_ADDRESS ) + ServiceInstance.serviceDomainName + ":" + ServiceInstance.instanceID;
             resolve();
         } );
     }
@@ -241,8 +261,8 @@ class ServiceInstance {
      * @private
      */
     #postStart() {
-        return new Promise( ( resolve, reject ) => {
-            // schedule regular health check:
+        return new Promise( ( resolve ) => {
+            // Schedule regular health check:
             this.#reportHealthyJob = schedule.scheduleJob( config.getSetting( config.setting.SERVICE_HEALTH_CHECK_INTERVAL ), () => {
                 this.reportHealthy();
             } );
@@ -266,11 +286,10 @@ class ServiceInstance {
      * @private
      */
     #preStop() {
-        return new Promise( ( resolve, reject ) => {
+        return new Promise( ( resolve ) => {
             if ( this.#reportHealthyJob ) {
                 this.#reportHealthyJob.cancel();
             }
-
             resolve();
         } );
     }
@@ -285,13 +304,12 @@ class ServiceInstance {
      * @private
      */
     #postStop() {
-        return new Promise( ( resolve, reject ) => {
+        return new Promise( ( resolve ) => {
             logger.log( `Instance '${ ServiceInstance.instanceID }' shut down successfully.`, logger.logSeverity.NOTICE );
-
             resolve();
         } );
     }
 
 }
 
-module.exports = ServiceInstance;
+module.exports = ServiceInstance;

package/components/service-provider.js

@@ -1,6 +1,6 @@
 /*
  * 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>
+ * 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/>.
@@ -74,7 +74,7 @@ class ServiceProvider extends ServiceConsumer {
                 let serviceDefinitions = this.serviceConfig.services;
                 return this.registerServices( serviceDefinitions );
             } ).then( () => {
-                messageDispatcher.addMessageObserverRequestsIn( this.#serviceExecutor );
+                messageDispatcher.instance.addMessageObserverRequestsIn( this.#serviceExecutor );
                 resolve();
             } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );
@@ -203,10 +203,10 @@ class ServiceProvider extends ServiceConsumer {
                     // If this happens, a corresponding log entry will be created but the loading process will continue. Therefore, the following
                     // promise will always resolve (unless a programming error occurs in it of course).
                     let registrationPromise = ( serviceDefinition, defaultServiceHandler ) => {
-                        return new Promise( ( resolve, reject ) => {
+                        return new Promise( ( resolve ) => {
                             this.registerService( serviceDefinition, defaultServiceHandler ).then( () => {
                                 resolve( true );
-                            } ).catch( ( error ) => {
+                            } ).catch( () => {
                                 resolve( false );
                             } );
                         } );
@@ -244,4 +244,4 @@ class ServiceProvider extends ServiceConsumer {
 
 }
 
-module.exports = ServiceProvider;
+module.exports = ServiceProvider;