@ti-engine/core 1.1.1 → 1.1.3

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # ti-engine changelog
 
+## Version 1.1.3
+
+* feat(config)!: removed ENV variable `TI_OPERATION_MODE` as it was duplicating the practical purpose of `NODE_ENV`
+* feat(config)!: setting `OPERATION_MODE` is now initialized by the `NODE_ENV` ENV variable (if provided)
+* feat(service instance): show application operation mode in log at successful startup
+* docs: add more sections and information in `README.md`
+
+## Version 1.1.2
+
+* feat(localization): add new functionality for localization based on labels and system language. It is currently utilized by the `exceptions` module for localizing the exception descriptions. The new `localization` module can also be accessed externally in the implementing application's files via standard import
+* feat(config): add new setting `localization.labelsPath` that specifies the file path for the localization labels
+* feat(config): add new setting `localization.language` that specifies the language to be used for the labels
+* feat(config): add new ENV variable `TI_LOCALIZATION_LABELS_PATH` that controls the `localization.labelsPath` setting
+* feat(config): add new ENV variable `TI_LOCALIZATION_LANGUAGE` that controls the `localization.language` setting
+* feat(logger): log exception label instead of system-level description
+* fix(start instance): fix the order of ENV loading in the `start-instance.js` script. It will now properly load the `.env` file first and then proceed with any configuration overrides in `config` module
+* fix(service provider): normalize service file paths on dynamic service handler loading
+* build(npm): update npm dependencies to their latest versions
+
 ## Version 1.1.1
 
 * feat(config): add new ENV variable `TI_AUDITING_LOG_DETAILS` that controls the `auditing.logDetails` setting

package/README.md

@@ -6,10 +6,6 @@ Flexible framework for the creation of microservices with [node.js](https://node
 
 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**. The architectural concept of the framework is based on a standard _messaging system_ that allows for certain customization but also provides predictability and traceability of its behavior.
 
-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.
-
-Please be aware, that this framework is under active development and will expand in the near future. Also, this documentation is still in the process of being created and refined. Make sure to keep an eye on the changes in case you want to use it in the meantime.
-
 ## Why ti-engine?
 
 The framework is created based on a decade of professional experience with the utilized technologies and architectural approach. It's primary goal is to provide you with a lightweight and flexible solution that can help you build quickly a microservice ecosystem with any degree of size and complexity.
@@ -27,12 +23,19 @@ These are just some benefits **ti-engine** offers. Get to know it better to find
 
 ## Prerequisites & installation
 
+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:
 
 * 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.
+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:
+
+* `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`.
+* `TI_MEMORY_CACHE_REDIS_HOST` can be used to provide the remote host. This can be an IP or URL depending on your setup.
+* `TI_MEMORY_CACHE_REDIS_PORT` can be used to provide the remote port. By default, Redis uses `6379` however many implementations might use a custom port that needs to be specified in the connection settings.
 
 To get the framework itself, use the command `npm install @ti-engine/core`. And to include it directly in your package.json dependencies execute `npm install @ti-engine/core --save-prod`.
 
@@ -330,11 +333,132 @@ Now without exiting this node process let's start the original tester microservi
 
 This means the service call processing was successful and result was returned to `my-service`. Because we made the receiving of the result blocking and part of the initialization sequence, the new microservice did not report successful startup until it received that response from `ti-tester-service`.
 
-And with this we are ready. The new microservice is now operational. You can continue to tweak and play with it in order to understand better how it all works. For more details on the **ti-engine** inner working please see the following sections.
+And with this step we are done. The new microservice is now operational. You can continue to tweak and play with it in order to understand better how it all works. For more details on the **ti-engine** inner working please see the following sections.
 
 ## Using the framework
 
-Under development...
+### 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.
+
+AUDITING_LOG_CONSOLE_ENABLED
+: JSON path `auditing.logConsoleEnabled`, type `boolean`, default `true`
+: ENV variable `TI_AUDITING_LOG_CONSOLE_ENABLED`
+: This setting controls whether the `auditing` module will send the log entries to the OS console or not. In some cases, like Cloud environments, you might want to disable this, especially if the OS console is not made available. This functions independently of other logging outputs like for example GCloud error reporting.
+
+AUDITING_LOG_DETAILS
+: JSON path `auditing.logDetails`, type `boolean`, default `true`
+: ENV variable `TI_AUDITING_LOG_DETAILS`
+: This setting controls whether the `auditing` module will include the log entry details (located in the `data` property) in the final log output. You might want to disable this if you want a leaner log output or the log entry details are not something you plan to use for analysis later.
+
+AUDITING_LOG_MIN_LEVEL
+: JSON path `auditing.logMinLevel`, type `number`, default `0`
+: ENV variable `TI_AUDITING_LOG_MIN_LEVEL`
+: This setting controls the minimum log severity level that the framework will log in the log output. You can and should set this to `200` (INFO) for production environments in order to filter out the DEBUG and the low-level DEFAULT entries.
+
+AUDITING_LOG_USES_JSON
+: JSON path `auditing.logUsesJSON`, type `boolean`, default `false`
+: ENV variable `TI_AUDITING_LOG_USES_JSON`
+: This setting controls whether the log entries would be sent to output formatted as JSONs or not. By default, the framework outputs log entries as prettified text. In some cases however you might want to have the entire entry as a JSON for further processing (for example if you're sending all logs to Elasticsearch).
+
+GCLOUD_API_KEY (Alpha)
+: JSON path `gcloudIntegration.apiKey`
+: This setting holds the API key for the GCloud integration module.
+
+GCLOUD_PROJECT_ID (Alpha)
+: JSON path `gcloudIntegration.projectID`
+: This setting holds the project ID for the GCloud integration module.
+
+LOCALIZATION_LABELS_PATH
+: JSON path `localization.labelsPath`, type `string`, default `../core/bin/localization/labels.json`
+: ENV variable `TI_LOCALIZATION_LABELS_PATH`
+: This setting holds the file system path to the `.json` file containing the localization information. By default, the framework provides such a file with english texts that can be customized further. Alternatively, you can provide your own file from a different location, but it still has to follow the rules of the `localization` module.
+
+LOCALIZATION_LANGUAGE
+: JSON path `localization.language`, type `string`, default `en`
+: ENV variable `TI_LOCALIZATION_LANGUAGE`
+: This setting specifies the default framework language. It will be used when translating labels into a localized text.
+
+MEMORY_CACHE_AUTH_KEY
+: JSON path `memoryCache.authKey`, type `string`, default `undefined`
+: ENV variable `TI_MEMORY_CACHE_AUTH_KEY`
+: This setting holds the Redis password for accessing the Redis server if such password is required.
+
+MEMORY_CACHE_REDIS_DB
+: JSON path `memoryCache.redisDB`, type `number`, default `0`
+: ENV variable `TI_MEMORY_CACHE_REDIS_DB`
+: This setting specifies the Redis DB to be used for all operations. When setting this make sure that the Redis server actually supports multiple DBs (for example Redis Cloud has only one DB with ID `0`).
+
+MEMORY_CACHE_REDIS_HOST
+: JSON path `memoryCache.redisHost`, type `string`, default `127.0.0.1`
+: ENV variable `TI_MEMORY_CACHE_REDIS_HOST`
+: This setting holds the Redis server hostname. It can be an IP or URL depending on your configuration.
+
+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.
+
+MEMORY_CACHE_USER
+: JSON path `memoryCache.user`, type `string`, default `default`
+: ENV variable `TI_MEMORY_CACHE_USER`
+: This setting holds the Redis username for accessing the Redis server if this is supported by the Redis version (it will be ignored otherwise).
+
+MESSAGE_EXCHANGE_QUEUE_PREFIX (Advanced)
+: JSON path `messageExchange.messageQueuePrefix`, type `string`, default `ti:messages:`
+: This setting holds the Redis key prefix for the queues that will hold the messages of the message exchange. This is not something you should modify unless you are making a customized implementation of the tier 1 architectural layer.
+
+MESSAGE_EXCHANGE_MESSAGE_STORE (Advanced)
+: JSON path `messageExchange.messageStore`, type `string`, default `ti:messages:store`
+: This setting holds the Redis key name of the hash table that will hold the message payloads of the message exchange. This is not something you should modify unless you are making a customized implementation of the tier 1 architectural layer.
+
+MESSAGE_EXCHANGE_SECURITY_HASH_ENABLED (Advanced)
+: JSON path `messageExchange.securityHashEnabled`, type `boolean`, default `true`
+: ENV variable `TI_MESSAGE_EXCHANGE_SECURITY_HASH_ENABLED`
+: This setting controls whether the message exchange will use a control hash mechanism to ensure there is no tampering with the messages in between service calls. In most cases you would want to keep this enabled since it ensures the integrity of your data. If you are concerned about performance (hashing with `blake2` is very fast, but it still eats some milliseconds) you might want to try and disable this to see if it makes any notable difference.
+
+MESSAGE_EXCHANGE_SECURITY_HASH_KEY (Advanced)
+: JSON path `messageExchange.securityHashKey`, type `string`, default `random uuid`
+: ENV variable `TI_MESSAGE_EXCHANGE_SECURITY_HASH_KEY`
+: This setting holds the encryption key used by the message exchange control hash mechanism. By default, this has a random uuid value that can be used for development purposes only. For production environments you absolutely must provide your own encryption key via the ENV variable. Depending on your configuration and infrastructure it might come from a secure storage, HSM, key vault, etc.
+
+MESSAGE_EXCHANGE_TRACE_EXPIRATION_TIME
+: JSON path `messageExchange.traceExpirationTime`, type `number`, default `3600`
+: This setting specifies the expiration time in seconds of the Redis key that will hold the message trace entries. Set this to `0` to disable expiration altogether.
+
+MESSAGE_EXCHANGE_TRACE_LOG_ENABLED
+: JSON path `messageExchange.traceLogEnabled`, type `boolean`, default `false`
+: ENV variable `TI_MESSAGE_EXCHANGE_TRACE_LOG_ENABLED`
+: This setting controls whether the `auditing` module should output all trace messages as normal log entries or not. Normally, you don't want that since it will clutter the standard log quite a lot. All traces go their own storage and can be reviewed and processed separately from the log entries. In some cases, however, as in debugging, enabling this can help you identify hard to track problem.
+
+MESSAGE_EXCHANGE_TRACE_REPOSITORY (Advanced)
+: JSON path `messageExchange.traceRepository`, type `string`, default `ti:messages:trace`
+: This setting holds the Redis key name for the message trace cache storage. This is not something you should modify unless you are making a customized implementation of the tier 1 architectural layer.
+
+SERVICE_EXECUTION_TIMEOUT
+: JSON path `serviceConfig.executionTimeout`, type `number`, default `180000`
+: This setting specifies the timeout in milliseconds of the service call executions at tier 2 of the architecture. Any service call that hasn't received response within this time will interrupt the wait and raise an `E_COM_SERVICE_EXEC_TIMEOUT` exception. Please keep in mind that reaching the timeout does not mean the remote service did not process the request. You might want to tweak this setting if you have many time-consuming operations in business services, or you plan to integrate with slow APIs.
+
+SERVICE_HEALTH_CHECK_ADDRESS (Advanced)
+: JSON path `serviceConfig.healthCheckAddress`, type `string`, default `ti:services:registry:health:`
+: This setting specifies the address of the health check report endpoint for the microservice. In the default implementation this is a prefix for a Redis key that gets updated once at every `SERVICE_HEALTH_CHECK_INTERVAL`. If you override the `reportHealthy` method of the microservice, this setting can contain a URL or another type of destination that can be used by your custom implementation.
+
+SERVICE_HEALTH_CHECK_INTERVAL (Advanced)
+: JSON path `serviceConfig.healthCheckInterval`, type `CRON string`, default `*/1 * * * * *`
+: This setting specifies the health check report interval at which the endpoint in `SERVICE_HEALTH_CHECK_ADDRESS` is notified.
+
+SERVICE_HEALTH_CHECK_TIMEOUT (Advanced)
+: JSON path `serviceConfig.healthCheckTimeout`, type `number`, default `3`
+: This setting specifies the timeout in seconds after which a microservice is no longer considered healthy. In the default implementation this represents an expiration parameter to the Redis key defined in `SERVICE_HEALTH_CHECK_ADDRESS`. Essentially, if the microservice does not update the Redis key within this time interval, it will expire and the monitoring application will lose the healthy status of the microservice. If you override the `reportHealthy` method of the microservice, this setting can be used for your custom implementation as needed.
+
+SERVICE_REGISTRY_ADDRESS (Advanced)
+: JSON path `serviceConfig.serviceRegistryAddress`, type `string`, default `ti:services:registry:catalog:`
+: This setting holds the prefix of the Redis key name used as business service registry. If the microservice is a `ServiceProvider`, on start up it will register its business service portfolio in that Redis set. Also, on each service call that same registry will be searched for the existence of the called business service. This is not something you should modify unless you are making a customized implementation of the tier 1 architectural layer.
+
+OPERATION_MODE
+: JSON path `operationMode`, type `string`, default `production`
+: ENV variable `NODE_ENV`
+: This setting holds the current operation mode of the node application. It will inherit the value from the `NODE_ENV` variable if it exists, otherwise will use its default.
 
 ## Advanced topics
 

package/bin/localization/labels.json

@@ -0,0 +1,65 @@
+{
+  "labels": {
+    "general": {
+      "exceptions": {
+        "0": {
+          "en": "Unidentified error encountered or unrecognized exception code provided."
+        },
+        "1000": {
+          "en": "Error thrown by internal JS source."
+        },
+        "1001": {
+          "en": "Attempt to construct an abstract class detected."
+        },
+        "1002": {
+          "en": "Attempt to call an abstract method detected."
+        },
+        "1003": {
+          "en": "Invalid or no service domain name provided at microservice startup."
+        },
+        "1004": {
+          "en": "The system cache required for proper engine operation is unavailable."
+        },
+        "1005": {
+          "en": "The provided service handler is not a proper function."
+        },
+        "1006": {
+          "en": "The requested feature is not supported by current configuration or version."
+        },
+        "2000": {
+          "en": "Invalid authorization token provided."
+        },
+        "2001": {
+          "en": "Invalid or expired session encountered."
+        },
+        "2002": {
+          "en": "Attempt for unauthorized access detected."
+        },
+        "2003": {
+          "en": "The system detected tampering with the message received via message exchange."
+        },
+        "3000": {
+          "en": "General error during cross-application communication."
+        },
+        "3001": {
+          "en": "The message sender instance is currently unavailable."
+        },
+        "3002": {
+          "en": "The execution of a service could not complete within the allowed timeout."
+        },
+        "3003": {
+          "en": "The specified service is not found in the service registry."
+        },
+        "3004": {
+          "en": "The specified service is not found in the service definition interface."
+        },
+        "3005": {
+          "en": "No handler found in the interface for the specified service or service version."
+        },
+        "3010": {
+          "en": "Connection retry attempts exceeded the configured limit."
+        }
+      }
+    }
+  }
+}

package/bin/settings.json

@@ -11,6 +11,10 @@
     "logName": "ti-engine",
     "projectID": ""
   },
+  "localization": {
+    "labelsPath": "../core/bin/localization/labels.json",
+    "language": "en"
+  },
   "memoryCache": {
     "authKey": null,
     "redisDB": 0,

package/bin/start-instance.js

@@ -7,12 +7,13 @@
 
 const _ = require( "lodash" );
 const path = require( "path" );
-const tools = require( "#tools" );
-const logger = require( "#logger" );
 
-// load any ENV variables defined in a .env file:
+// 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:
 process.env.TI_INSTANCE_ID = "ti-" + tools.getUUID();
 process.env.TI_INSTANCE_CLASS = process.env.TI_INSTANCE_CLASS || "";
@@ -74,13 +75,14 @@ process.on( "uncaughtException", ( error ) => {
 try {
     logger.log( `Starting new instance of type '${ process.env.TI_INSTANCE_NAME }' with instance ID '${ process.env.TI_INSTANCE_ID }'.`, logger.logSeverity.NOTICE );
 
-    /** @type ServiceInstance */
     const serviceConstructor = require( path.join( process.cwd(), process.env.TI_INSTANCE_CLASS ) );
     const serviceConfigPath = process.env.TI_INSTANCE_CONFIG;
+    /** @type ServiceConfiguration */
     let serviceConfig = {};
     if ( serviceConfigPath ) {
         serviceConfig = require( path.join( process.cwd(), process.env.TI_INSTANCE_CONFIG ) );
     }
+    /** @type ServiceInstance */
     const mainInstance = new serviceConstructor( process.env.TI_INSTANCE_NAME, serviceConfig );
 
     /** @override */

package/components/service-instance.js

@@ -225,7 +225,8 @@ class ServiceInstance {
             } );
 
             logger.log( `Instance '${ ServiceInstance.instanceID }' started successfully.`, logger.logSeverity.NOTICE, {
-                nodeVersion: process.version
+                nodeVersion: process.version,
+                operationMode: config.getSetting( config.setting.OPERATION_MODE )
             } );
 
             resolve();

package/components/service-provider.js

@@ -138,7 +138,7 @@ class ServiceProvider extends ServiceConsumer {
             /** @type {ServiceHandlerMethod} */
             let serviceHandler = null;
             if ( serviceDefinition.serviceFile ) {
-                let serviceFilePath = path.join( process.cwd(), serviceDefinition.serviceFile );
+                let serviceFilePath = path.normalize( path.join( process.cwd(), serviceDefinition.serviceFile ) );
                 try {
                     serviceHandler = require( serviceFilePath ).service;
                 } catch ( error ) {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@ti-engine/core",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "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.",
   "author": "Boris Kostadinov <kostadinov.boris@gmail.com>",
   "license": "ISC",
   "exports": {
     "./exceptions": "./utils/exceptions.js",
+    "./localization": "./utils/localization.js",
     "./logger": "./utils/logger.js",
     "./service-consumer": "./components/service-consumer.js",
     "./service-instance": "./components/service-instance.js",
@@ -22,6 +23,7 @@
     "#default-message-sender": "./components/exchange/default/default-message-sender.js",
     "#exceptions": "./utils/exceptions.js",
     "#gcloud-integration": "./integrations/gcloud-integration.js",
+    "#localization": "./utils/localization.js",
     "#logger": "./utils/logger.js",
     "#message-dispatcher": "./components/exchange/message-dispatcher.js",
     "#message-exchange": "./components/exchange/message-exchange.js",
@@ -43,7 +45,7 @@
   "dependencies": {
     "blake2": "^5.0.0",
     "dotenv": "^16.3.1",
-    "fs-extra": "^11.1.1",
+    "fs-extra": "^11.2.0",
     "lodash": "^4.17.21",
     "node-schedule": "^2.1.1",
     "ioredis": "^5.3.2"
@@ -54,7 +56,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Belleal/ti-engine.git"
+    "url": "git+https://github.com/Belleal/ti-engine.git"
   },
   "engines": {
     "node": ">=14.17.0"

package/utils/config.js

@@ -24,6 +24,8 @@ const tools = require( "#tools" );
  * @property {EnvironmentVariable} env.TI_AUDITING_LOG_DETAILS
  * @property {EnvironmentVariable} env.TI_AUDITING_LOG_MIN_LEVEL
  * @property {EnvironmentVariable} env.TI_AUDITING_LOG_USES_JSON
+ * @property {EnvironmentVariable} env.TI_LOCALIZATION_LABELS_PATH
+ * @property {EnvironmentVariable} env.TI_LOCALIZATION_LANGUAGE
  * @property {EnvironmentVariable} env.TI_MEMORY_CACHE_AUTH_KEY
  * @property {EnvironmentVariable} env.TI_MEMORY_CACHE_REDIS_DB
  * @property {EnvironmentVariable} env.TI_MEMORY_CACHE_REDIS_HOST
@@ -32,7 +34,6 @@ const tools = require( "#tools" );
  * @property {EnvironmentVariable} env.TI_MESSAGE_EXCHANGE_SECURITY_HASH_ENABLED
  * @property {EnvironmentVariable} env.TI_MESSAGE_EXCHANGE_SECURITY_HASH_KEY
  * @property {EnvironmentVariable} env.TI_MESSAGE_EXCHANGE_TRACE_LOG_ENABLED
- * @property {EnvironmentVariable} env.TI_OPERATION_MODE
  */
 
 /**
@@ -43,6 +44,7 @@ const tools = require( "#tools" );
  * @typedef {Object} SettingsMain
  * @property {SettingsAuditing} auditing
  * @property {SettingsGcloudIntegration} gcloudIntegration
+ * @property {SettingsLocalization} localization
  * @property {SettingsMemoryCache} memoryCache
  * @property {SettingsMessageExchange} messageExchange
  * @property {SettingsServiceConfig} serviceConfig
@@ -63,6 +65,12 @@ const tools = require( "#tools" );
  * @property {string} projectID
  */
 
+/**
+ * @typedef {Object} SettingsLocalization
+ * @property {string} labelsPath
+ * @property {string} language
+ */
+
 /**
  * @typedef {Object} SettingsMemoryCache
  * @property {string} authKey
@@ -105,6 +113,8 @@ let settingsEnum = tools.enum( {
     AUDITING_LOG_USES_JSON: [ "auditing.logUsesJSON", "logUsesJSON", "" ],
     GCLOUD_API_KEY: [ "gcloudIntegration.apiKey", "apiKey", "" ],
     GCLOUD_PROJECT_ID: [ "gcloudIntegration.projectID", "projectID", "" ],
+    LOCALIZATION_LABELS_PATH: [ "localization.labelsPath", "labelsPath", "" ],
+    LOCALIZATION_LANGUAGE: [ "localization.language", "language", "" ],
     MEMORY_CACHE_AUTH_KEY: [ "memoryCache.authKey", "authKey", "" ],
     MEMORY_CACHE_REDIS_DB: [ "memoryCache.redisDB", "redisDB", "" ],
     MEMORY_CACHE_REDIS_HOST: [ "memoryCache.redisHost", "redisHost", "" ],
@@ -140,6 +150,10 @@ if ( settings.auditing ) {
     settings.auditing.logMinLevel = ( process.env.TI_AUDITING_LOG_MIN_LEVEL !== undefined ) ? process.env.TI_AUDITING_LOG_MIN_LEVEL : settings.auditing.logMinLevel;
     settings.auditing.logUsesJSON = ( process.env.TI_AUDITING_LOG_USES_JSON !== undefined ) ? tools.toBool( process.env.TI_AUDITING_LOG_USES_JSON ) : settings.auditing.logUsesJSON;
 }
+if ( settings.localization ) {
+    settings.localization.labelsPath = ( process.env.TI_LOCALIZATION_LABELS_PATH !== undefined ) ? process.env.TI_LOCALIZATION_LABELS_PATH : settings.localization.labelsPath;
+    settings.localization.language = ( process.env.TI_LOCALIZATION_LANGUAGE !== undefined ) ? process.env.TI_LOCALIZATION_LANGUAGE : settings.localization.language;
+}
 if ( settings.memoryCache ) {
     settings.memoryCache.authKey = ( process.env.TI_MEMORY_CACHE_AUTH_KEY !== undefined ) ? process.env.TI_MEMORY_CACHE_AUTH_KEY : settings.memoryCache.authKey;
     settings.memoryCache.redisDB = ( process.env.TI_MEMORY_CACHE_REDIS_DB !== undefined ) ? process.env.TI_MEMORY_CACHE_REDIS_DB : settings.memoryCache.redisDB;
@@ -159,7 +173,7 @@ if ( process.env.TI_GCLOUD_ENABLED === true && settings.gcloudIntegration ) {
     settings.gcloudIntegration.projectID = ( process.env.TI_GCLOUD_PROJECT_ID !== undefined ) ? process.env.TI_GCLOUD_PROJECT_ID : settings.gcloudIntegration.projectID;
 }
 
-settings.operationMode = process.env.TI_OPERATION_MODE || settings.operationMode;
+settings.operationMode = process.env.NODE_ENV || settings.operationMode;
 
 // prevent further modifications to the settings object:
 Object.freeze( settings );

package/utils/localization.js

@@ -0,0 +1,27 @@
+/*
+ * SPDX-FileCopyrightText: © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * SPDX-License-Identifier: ICU
+ */
+
+const _ = require( "lodash" );
+const path = require( "path" );
+const config = require( "#config" );
+
+const labelsPath = path.normalize( path.join( process.cwd(), config.getSetting( config.setting.LOCALIZATION_LABELS_PATH ) ) );
+const labels = require( labelsPath );
+const defaultEmptyLabel = "!!! label not found !!!";
+
+// prevent further modifications to the labels object:
+Object.freeze( labels );
+
+/**
+ * Used to return the textual value for a label based on the current system language.
+ *
+ * @method
+ * @param {string} label This should be a dot-separated JSON path string.
+ * @returns {string}
+ * @public
+ */
+module.exports.getLabel = ( label ) => {
+    return _.get( labels, label + "." + config.getSetting( config.setting.LOCALIZATION_LANGUAGE ), defaultEmptyLabel );
+};

package/utils/logger.js

@@ -6,6 +6,7 @@
 const _ = require( "lodash" );
 const tools = require( "#tools" );
 const exceptions = require( "#exceptions" );
+const localization = require( "#localization" );
 
 /**
  * Enum for specifying the log entry severity. This is based on the Google Stackdriver severity levels.
@@ -52,7 +53,7 @@ module.exports.getSeverityName = ( severity ) => {
 const exceptionToLog = ( exception ) => {
     return {
         exceptionID: exception.id,
-        description: exception.description,
+        description: localization.getLabel( exception.label ),
         details: !_.isEmpty( exception.data ) ? exception.data : undefined
     };
 };