iotagent-node-lib 4.6.0 → 4.7.0

package/.github/workflows/ci.yml

@@ -51,7 +51,6 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - 14.x
           - 16.x
           - 18.x
     steps:

package/Changelog

@@ -0,0 +1,12 @@
+4.7.0 (February 3rd, 2025)
+
+- Add: store (and recover) previous jexlctxt and make available in current jexlctxt (#1690)
+- Add: option to force to use CB flow control with new API field useCBflowControl at group and device device level  (#1420)
+- Add: useCBflowControl config setting (IOTA_CB_FLOW_CONTROL env var) to set CB flow control behaviour at instance level (#1420)
+- Add: allow remove last measure in device
+- Add: store last measure in device (by id, apikey, service and subservice) and new API field storeLastMeasure at group and device levels (#1669)
+- Add: storeLastMeasure config setting  (IOTA_STORE_LAST_MEASURE env var) to set default store last measure behaviour at instance level (#1669)
+- Fix: set polling and transport for autoprovisioned devices
+- Upgrade express dep from 4.19.2 to 4.21.2
+- Upgrade mongodb devdep from 4.17.1 to 4.17.2
+- Upgrade mongoose dep from 5.13.20 to 8.9.5 (solving vulnerabilies CVE-2024-53900 and CVE-2025-23061) (#1674)

package/config.js

@@ -77,7 +77,9 @@ var config = {
     providerUrl: 'http://192.168.56.1:4041',
     deviceRegistrationDuration: 'P1M',
     defaultType: 'Thing',
-    expressLimit: '1Mb'
+    expressLimit: '1Mb',
+    useCBflowControl: false,
+    storeLastMeasure: false
 };
 
 module.exports = config;

package/doc/admin.md

@@ -125,9 +125,9 @@ allowing the computer to interpret the rest of the data with more clarity and de
 ```
 
 Under mixed mode, **NGSI v2** payloads are used for context broker communications by default, but this payload may also
-be switched to **NGSI LD** at group or device provisioning time using the `ngsiVersion` field in the
-provisioning API. The `ngsiVersion` field switch may be added at either group or device level, with the device level
-overriding the group setting.
+be switched to **NGSI LD** at group or device provisioning time using the `ngsiVersion` field in the provisioning API.
+The `ngsiVersion` field switch may be added at either group or device level, with the device level overriding the group
+setting.
 
 #### `server`
 
@@ -306,7 +306,8 @@ added `agentPath`:
 
 #### `types`
 
-This parameter includes additional groups configuration as described into the [Config group API](api.md#config-group-api) section.
+This parameter includes additional groups configuration as described into the
+[Config group API](api.md#config-group-api) section.
 
 #### `service`
 
@@ -415,7 +416,38 @@ IotAgents, as all Express applications that use the body-parser middleware, have
 size that the application will handle. This default limit for ioiotagnets are 1Mb. So, if your IotAgent receives a
 request with a body that exceeds this limit, the application will throw a “Error: Request entity too large”.
 
-The 1Mb default can be changed setting the `expressLimit` configuration parameter (or equivalente `IOTA_EXPRESS_LIMIT` environment variable).
+The 1Mb default can be changed setting the `expressLimit` configuration parameter (or equivalente `IOTA_EXPRESS_LIMIT`
+environment variable).
+
+#### `storeLastMeasure`
+
+If this flag is activated, last measure arrived to Device IoTAgent without be processed will be stored in Device under
+`lastMeasure` field (composed of sub-fields `timestamp` and `measure` for the measure itself, in multi-measure format).
+This flag is overwritten by `storeLastMeasure` flag in group or device. This flag is disabled by default.
+
+For example in a device document stored in MongoDB will be extended with a subdocument named lastMeasure like this:
+
+```json
+{
+    "lastMeasure": {
+        "timestamp": "2025-01-09T10:35:33.079Z",
+        "measure": [
+            [
+                {
+                    "name": "level",
+                    "type": "Text",
+                    "value": 33
+                }
+            ]
+        ]
+    }
+}
+```
+
+#### `useCBflowControl`
+
+If this flag is activated, when iotAgent invokes Context Broker will use [flowControl option](https://github.com/telefonicaid/fiware-orion/blob/master/doc/manuals/admin/perf_tuning.md#updates-flow-control-mechanism). This flag is overwritten by
+`useCBflowControl` flag in group or device. This flag is disabled by default.
 
 ### Configuration using environment variables
 
@@ -479,6 +511,8 @@ overrides.
 | IOTA_DEFAULT_ENTITY_NAME_CONJUNCTION | `defaultEntityNameConjunction`  |
 | IOTA_RELAX_TEMPLATE_VALIDATION       | `relaxTemplateValidation`       |
 | IOTA_EXPRESS_LIMIT                   | `expressLimit`                  |
+| IOTA_STORE_LAST_MEASURE              | `storeLastMeasure`              |
+| IOTA_CB_FLOW_CONTROL                 | `useCBflowControl`              |
 
 Note:
 

package/doc/api.md

@@ -12,6 +12,7 @@
     -   [Special measures and attributes names](#special-measures-and-attributes-names)
     -   [Device to NGSI Mapping](#device-to-ngsi-mapping)
     -   [Device autoprovision and entity creation](#device-autoprovision-and-entity-creation)
+    -   [Entity Name expression support](#entity-name-expression-support)
     -   [Multientity support](#multientity-support)
     -   [Metadata support](#metadata-support)
         -   [NGSI LD data and metadata considerations](#ngsi-ld-data-and-metadata-considerations)
@@ -164,7 +165,7 @@ parameters defined at device level in database, the parameters are inherit from
 
 ### Uniqueness of groups and devices
 
-Group uniqueness is defined by the combination of: service, subservice, resource and apikey
+Group uniqueness is defined by the combination of: resource and apikey. This is so because given a measure (identified by an apikey) there is no way to identify group related if apikey is not unique for all services and subservices.
 
 Device uniqueness is defined by the combination of: service, subservice, device_id and apikey. Note that several devices
 with the same device_id are allowed in the same service and subservice as long as their apikeys are different.
@@ -187,9 +188,9 @@ configured for a single device in the device provisioning, or it can be defined
 
 The entity type should be defined both in the group and in the device, but the entity name (entity ID) is not defined in
 the group. In that case, if there is no a existing device the same device ID, the entity name of the device generated
-will be a concatenation of the entity type and the device ID (I.E: `entityType:device_id`). It is possible to define the
-entity name as an expression, using the [Expression Language](#expression-language-support) through the `entityNameExp`
-attribute in the group.
+will be a concatenation of the entity type and the device ID (I.E: `entityType:device_id`). If you need to generate the
+entity name differently, it is possible to define an expression to generate it, using the parameter `entityNameExp` in
+the group as described in the [Entity Name expression support](#entity-name-expression-support) section.
 
 It is also possible to configure how each of the measures obtained from the device is mapped to different attributes.
 The name and type of the attribute is configured by the user (globally for all the devices in the group or in a per
@@ -271,6 +272,59 @@ If for any reason you need the entity at CB before the first measure of the corr
 IOTAgent, you can create it in advance using the Context Broker
 [NGSI v2 API](https://github.com/telefonicaid/fiware-orion/blob/master/doc/manuals/orion-api.md).
 
+## Entity Name expression support
+
+By default, the entity name used to persist the device measures in the Context Broker can be defined in the device
+provisioning or, if the device is autoprovisioned, it is generated by the IoT Agent as a concatenation of the entity
+type and the device ID. If you need to generate the entity name differently, it is possible to define an expression to
+generate it, using the [Expression Language](#expression-language-support) through the `entityNameExp` field in the
+group.
+
+With this feature, the entity name can be generated dynamically based not only on the device ID and entity type, but
+also on the measures reported by the device or any other context information. The `entityNameExp` field is only
+available at the group level. **Important**: when using `entityNameExp`, the `entity_name` field in the device
+provisioning is ignored. This means that the entity name used to store the device information in the Context Broker is
+always generated by the `entityNameExp` expression. If you need to explicitly define the entity name for a particular
+device, you can include a particular condition in the `entityNameExp` expression to handle that case (e.g.
+`id == 'myDevice' ? 'myEntity' : entityType + ':' + id`).
+
+The following example shows how to define an entity name expression:
+
+```json
+{
+    "services": [
+        {
+            "resource": "/json",
+            "apikey": "801230BJKL23Y9090DSFL123HJK09H324HV8732",
+            "entity_type": "TemperatureSensor",
+            "entityNameExp": "id + '__' + sn",
+            "attributes": [
+                {
+                    "object_id": "t",
+                    "name": "temperature",
+                    "type": "Number"
+                },
+                {
+                    "object_id": "sn",
+                    "name": "serialNumber",
+                    "type": "Text"
+                }
+            ]
+        }
+    ]
+}
+```
+
+As defined above, the `entityNameExp` is `id + '__' + sn` and it will generate the entity name by concatenating the
+device ID and the serial number reported by the device. For example, for a given measure with `id` equal to `dev123` and
+`sn` equal to `ABCDEF`, the resulting entity name will be `dev123__ABCDEF`.
+
+Note that, when using `entityNameExp`, the `entity_name` of the device provisioning is set to the result of the
+expression the first time the device is created. If the expression is modified later, the `entity_name` of the device
+provisioning will not be updated, but the value used to persist the device measures in the Context Broker will be the
+result of the new expression. This can lead to a situation where the `entity_name` of the device provisioning and the
+entity name used in the Context Broker are different.
+
 ## Multientity support
 
 The IOTA is able to persists measures coming from a single device to more than one entity, declaring the target entities
@@ -555,7 +609,8 @@ of expression in the IoT Agent are:
 -   [Metadata](#expression-support-in-metadata)
 -   Commands payload transformation (push and pull).
 -   Auto provisioned devices entity name. It is configured at config Group level by setting the `entityNameExp`
-    parameter. It defines an expression to generate the Entity Name for autoprovisioned devices.
+    parameter. It defines an expression to generate the Entity Name for autoprovisioned devices. More information in the
+    [Entity Name expression support](#entity-name-expression-support) section.
 -   Dynamic `endpoint` definition. Configured at device level, it defines where the device listen for push http
     commands. It can be either a static value or an expression.
 
@@ -568,6 +623,7 @@ expression. In all cases the following data is available to all expressions:
 -   `service`: device service (`Fiware-Service`)
 -   `subservice`: device subservice (`Fiware-ServicePath`)
 -   `staticAttributes`: static attributes defined in the device or config group
+-   `oldCtxt`: previous JEXL context (related to last processed measure)
 
 Additionally, for attribute expressions (`expression`, `entity_name`), `entityNameExp` and metadata expressions
 (`expression`) the following is available in the **context** used to evalute:
@@ -1715,13 +1771,15 @@ Config group is represented by a JSON object with the following fields:
 | `static_attributes`            | ✓        |                |            | this attributes will be added to all the entities of this group 'as is', additional `metadata` is optional.                                                                                                                                                                                                                                                                                                                         |
 | `internal_attributes`          | ✓        |                |            | optional section with free format, to allow specific IoT Agents to store information along with the devices in the Device Registry.                                                                                                                                                                                                                                                                                                 |
 | `explicitAttrs`                | ✓        | string or bool | ✓          | optional field to support selective ignore of measures so that IOTA doesn’t progress. See details in [specific section](#explicitly-defined-attributes-explicitattrs)                                                                                                                                                                                                                                                               |
-| `entityNameExp`                | ✓        | string         |            | optional field to allow use expressions to define entity name, instead default name, based on the device ID and the entity type (i.e. `<device_id>:<entity_type>`)                                                                                                                                                                                                                                                                  |
+| `entityNameExp`                | ✓        | string         |            | optional field to allow use expressions to define entity name, instead default name, based on the device ID and the entity type (i.e. `<device_id>:<entity_type>`). More information in [specific section](#entity-name-expression-entitynameexp)                                                                                                                                                                                   |
 | `ngsiVersion`                  | ✓        | string         |            | optional string value used in mixed mode to switch between **NGSI-v2** and **NGSI-LD** payloads. Possible values are: `v2` or `ld`. The default is `v2`. When not running in mixed mode, this field is ignored.                                                                                                                                                                                                                     |
 | `defaultEntityNameConjunction` | ✓        | string         |            | optional string value to set default conjunction string used to compose a default `entity_name` when is not provided at device provisioning time.                                                                                                                                                                                                                                                                                   |
 | `autoprovision`                | ✓        | bool           | ✓?         | optional boolean: If `false`, autoprovisioned devices (i.e. devices that are not created with an explicit provision operation but when the first measure arrives) are not allowed in this group. Default (in the case of omitting the field) is `true`.                                                                                                                                                                             |
 | `payloadType`                  | ✓        | string         |            | optional string value used to switch between **IoTAgent**, **NGSI-v2** and **NGSI-LD** measure payloads types. Possible values are: `iotagent`, `ngsiv2` or `ngsild`. The default is `iotagent`.                                                                                                                                                                                                                                    |
 | `transport`                    | ✓        | `string`       |            | Transport protocol used by the group of devices to send updates, for the IoT Agents with multiple transport protocols.                                                                                                                                                                                                                                                                                                              |
 | `endpoint`                     | ✓        | `string`       |            | Endpoint where the group of device is going to receive commands, if any.                                                                                                                                                                                                                                                                                                                                                            |
+| `storeLastMeasure`             | ✓        | `boolean`      |            | Store in device last measure received. See more info [in this section](admin.md#storelastmeasure). False by default                                                                                                                                                                                                                                                                                                                 |
+| `useCBflowControl`             | ✓        | `boolean`      |            | Use Context Broker flow control. See more info [in this section](admin.md#useCBflowControl). False by default                                                                                                                                                                                                                                                                                                                       |
 
 ### Config group operations
 
@@ -1942,6 +2000,9 @@ the API resource fields and the same fields in the database model.
 | `explicitAttrs`       | ✓        | `boolean` | ✓          | Field to support selective ignore of measures so that IOTA doesn’t progress. See details in [specific section](#explicitly-defined-attributes-explicitattrs)                                                                                                                                                                                                                                                               |
 | `ngsiVersion`         | ✓        | `string`  |            | string value used in mixed mode to switch between **NGSI-v2** and **NGSI-LD** payloads. The default is `v2`. When not running in mixed mode, this field is ignored.                                                                                                                                                                                                                                                        |
 | `payloadType`         | ✓        | `string`  |            | optional string value used to switch between **IoTAgent**, **NGSI-v2** and **NGSI-LD** measure payloads types. Possible values are: `iotagent`, `ngsiv2` or `ngsild`. The default is `iotagent`.                                                                                                                                                                                                                           |
+| `storeLastMeasure`    | ✓        | `boolean` |            | Store in device last measure received. Useful just for debugging purpose. See more info [in this section](admin.md#storelastmeasure). False by default.                                                                                                                                                                                                                                                                    |
+| `lastMeasure`         | ✓        | `object`  |            | last measure stored on device when `storeLastMeasure` is enabled. See more info [in this section](admin.md#storelastmeasure). This field can be cleared using `{}` in a device update request. In that case, `lastMeasure` is removed from device (until a next measure is received and `lastMesuare` gets created again).                                                                                                 |
+| `useCBflowControl`    | ✓        | `boolean` |            | Use Context Broker flow control. See more info [in this section](admin.md#useCBflowControl). False by default.                                                                                                                                                                                                                                                                                                             |
 
 ### Device operations
 

package/doc/requirements.txt

@@ -1,4 +1,4 @@
 mkdocs==1.2.4
 Pygments==2.15.0
 Markdown==3.3.4
-jinja2==3.1.4
+jinja2==3.1.5

package/lib/commonConfig.js

@@ -157,7 +157,9 @@ function processEnvironmentVariables() {
         'IOTA_FALLBACK_PATH',
         'IOTA_LD_SUPPORT_NULL',
         'IOTA_LD_SUPPORT_DATASET_ID',
-        'IOTA_EXPRESS_LIMIT'
+        'IOTA_EXPRESS_LIMIT',
+        'IOTA_USE_CB_FLOW_CONTROL',
+        'IOTA_STORE_LAST_MEASURE'
     ];
     const iotamVariables = [
         'IOTA_IOTAM_URL',
@@ -350,6 +352,11 @@ function processEnvironmentVariables() {
         config.defaultResource = process.env.IOTA_DEFAULT_RESOURCE;
     }
 
+    // Default transport
+    if (process.env.IOTA_DEFAULT_TRANSPORT !== undefined) {
+        config.defaultTransport = process.env.IOTA_DEFAULT_TRANSPORT;
+    }
+
     // Default explicitAttrs
     if (process.env.IOTA_EXPLICIT_ATTRS !== undefined) {
         config.explicitAttrs = process.env.IOTA_EXPLICIT_ATTRS;
@@ -474,6 +481,16 @@ function processEnvironmentVariables() {
     } else {
         config.expressLimit = config.expressLimit ? config.expressLimit : '1mb';
     }
+    if (process.env.IOTA_USE_CB_FLOW_CONTROL) {
+        config.useCBflowControl = process.env.IOTA_USE_CB_FLOW_CONTROL === 'true';
+    } else {
+        config.useCBflowControl = config.useCBflowControl === true;
+    }
+    if (process.env.IOTA_STORE_LAST_MEASURE) {
+        config.storeLastMeasure = process.env.IOTA_STORE_LAST_MEASURE === 'true';
+    } else {
+        config.storeLastMeasure = config.storeLastMeasure === true;
+    }
 }
 
 function setConfig(newConfig) {
@@ -503,7 +520,9 @@ function getConfigForTypeInformation() {
         multiCore: config.multiCore,
         relaxTemplateValidation: config.relaxTemplateValidation,
         defaultEntityNameConjunction: config.defaultEntityNameConjunction,
-        defaultType: config.defaultType
+        defaultType: config.defaultType,
+        useCBflowControl: config.useCBflowControl,
+        storeLastMeasure: config.storeLastMeasure
     };
     return conf;
 }

package/lib/model/Command.js

@@ -34,8 +34,8 @@ const Command = new Schema({
     creationDate: { type: Date, default: Date.now }
 });
 
-function load(db) {
-    module.exports.model = db.model('Command', Command);
+function load() {
+    module.exports.model = mongoose.model('Command', Command);
     module.exports.internalSchema = Command;
 }
 

package/lib/model/Device.js

@@ -53,11 +53,15 @@ const Device = new Schema({
     autoprovision: Boolean,
     explicitAttrs: Group.ExplicitAttrsType,
     ngsiVersion: String,
-    payloadType: String
+    payloadType: String,
+    useCBflowControl: Boolean,
+    storeLastMeasure: Boolean,
+    lastMeasure: Object,
+    oldCtxt: Object
 });
 
-function load(db) {
-    module.exports.model = db.model('Device', Device);
+function load() {
+    module.exports.model = mongoose.model('Device', Device);
     module.exports.internalSchema = Device;
 }
 

package/lib/model/Group.js

@@ -65,12 +65,14 @@ const Group = new Schema({
     defaultEntityNameConjunction: String,
     ngsiVersion: String,
     entityNameExp: String,
-    payloadType: String
+    payloadType: String,
+    useCBflowControl: Boolean,
+    storeLastMeasure: Boolean
 });
 
-function load(db) {
+function load() {
     Group.index({ apikey: 1, resource: 1 }, { unique: true });
-    module.exports.model = db.model('Group', Group);
+    module.exports.model = mongoose.model('Group', Group);
     module.exports.internalSchema = Group;
 }
 

package/lib/model/dbConn.js

@@ -31,7 +31,6 @@ const config = require('../commonConfig');
 const constants = require('../constants');
 const alarms = require('../services/common/alarmManagement');
 const logger = require('logops');
-const async = require('async');
 const errors = require('../errors');
 let defaultDb;
 const DEFAULT_DB_NAME = 'iotagent';
@@ -40,9 +39,9 @@ const context = {
 };
 
 function loadModels() {
-    require('./Device').load(defaultDb);
-    require('./Group').load(defaultDb);
-    require('./Command').load(defaultDb);
+    require('./Device').load();
+    require('./Group').load();
+    require('./Command').load();
 }
 
 /**
@@ -50,93 +49,52 @@ function loadModels() {
  *
  * @this Reference to the dbConn module itself.
  */
+
 function init(host, db, port, options, callback) {
-    /*jshint camelcase:false, validthis:true */
     let url;
     let retries = 0;
     let lastError;
-    const maxRetries =
-        (config.getConfig().mongodb && config.getConfig().mongodb.retries) || constants.DEFAULT_MONGODB_RETRIES;
+    const maxRetries = config.getConfig().mongodb?.retries || constants.DEFAULT_MONGODB_RETRIES;
 
     function addPort(item) {
-        return item + ':' + port;
-    }
-
-    function commaConcat(previous, current, currentIndex) {
-        if (currentIndex !== 0) {
-            previous += ',';
-        }
-
-        previous += current;
-
-        return previous;
+        return `${item}:${port}`;
     }
 
     url = 'mongodb://';
 
     if (options.auth) {
-        url += options.auth.user + ':' + options.auth.password + '@';
+        url += `${encodeURIComponent(options.auth.user)}:${encodeURIComponent(options.auth.password)}@`;
     }
 
-    const hosts = host.split(',').map(addPort).reduce(commaConcat, '');
-
-    url += hosts + '/' + db;
+    const hosts = host.split(',').map(addPort).join(',');
+    url += `${hosts}/${db}`;
 
     if (options.extraArgs) {
-        if (options.extraArgs instanceof Object && Object.keys(options.extraArgs).length > 0) {
-            url += '?';
-            url += Object.entries(options.extraArgs)
-                .map(function ([k, v]) {
-                    return encodeURIComponent(k) + '=' + encodeURIComponent(v);
-                })
-                .join('&');
+        const query = new URLSearchParams(options.extraArgs).toString();
+        if (query) {
+            url += `?${query}`;
         }
         delete options.extraArgs;
     }
 
-    /* eslint-disable-next-line no-unused-vars */
-    function createConnectionHandler(error, results) {
-        if (defaultDb) {
-            logger.info(context, 'Successfully connected to MongoDB.');
-            module.exports.db = defaultDb;
-            loadModels();
-        } else {
-            logger.error(context, 'MONGODB-002: Error found after [%d] attempts: %s', retries, error || lastError);
-        }
-
-        callback(error);
-    }
-
-    function retryCheck() {
-        return !defaultDb && retries < maxRetries;
-    }
-
-    function connectionAttempt(url, options, callback) {
-        logger.info(context, 'Attempting to connect to MongoDB instance with url %j. Attempt %d', url, retries);
-        // FIXME: useNewUrlParser is no longer used in underlying mongodb driver 4.x
-        // (see https://github.com/mongodb/node-mongodb-native/blob/HEAD/etc/notes/CHANGES_4.0.0.md)
-        // but not sure if current mongoose version is still using mongodb 3.x internally
-        // probably mongodb-connectionoptions-test.js needs to be fixed if useNewUrlParser is removed at the end
-        options.useNewUrlParser = true;
-        options.useUnifiedTopology = true;
-        mongoose.set('useCreateIndex', true);
-        /* eslint-disable-next-line no-unused-vars */
-        const candidateDb = mongoose.createConnection(url, options, function (error, result) {
-            if (error) {
-                logger.error(context, 'MONGODB-001: Error trying to connect to MongoDB: %s', error);
-                lastError = error;
-            } else {
-                defaultDb = candidateDb;
+    function connectionAttempt(callback) {
+        logger.info(context, `Attempting to connect to MongoDB at ${url}. Attempt ${retries + 1}`);
 
+        mongoose
+            .connect(url, options)
+            .then(() => {
+                defaultDb = mongoose.connection;
+                logger.info(context, 'Successfully connected to MongoDB.');
+                loadModels();
                 defaultDb.on('error', function (error) {
                     logger.error(context, 'Mongo Driver error: %j', error);
+                    lastError = error;
                     alarms.raise(constants.MONGO_ALARM, error);
                 });
                 /* eslint-disable-next-line no-unused-vars */
                 defaultDb.on('connecting', function (error) {
                     logger.debug(context, 'Mongo Driver connecting');
                 });
-
                 defaultDb.on('connected', function () {
                     logger.debug(context, 'Mongo Driver connected');
                 });
@@ -159,69 +117,52 @@ function init(host, db, port, options, callback) {
                 defaultDb.on('close', function () {
                     logger.debug(context, 'Mongo Driver close');
                 });
-            }
-
-            callback();
-        });
-    }
-
-    function tryCreateConnection(callback) {
-        const attempt = async.apply(connectionAttempt, url, options, callback);
-        const seconds =
-            (config.getConfig().mongodb && config.getConfig().mongodb.retryTime) ||
-            constants.DEFAULT_MONGODB_RETRY_TIME;
-
-        retries++;
-
-        if (retries === 1) {
-            logger.info(context, 'First connection attempt');
-            attempt();
-        } else {
-            logger.info(context, 'Waiting %d seconds before attempting again.', seconds);
-            setTimeout(attempt, seconds * 1000);
-        }
+                callback();
+            })
+            .catch((err) => {
+                logger.error(context, `MONGODB-001: Error trying to connect to MongoDB: ${err}`);
+                lastError = err;
+                retries++;
+                if (retries < maxRetries) {
+                    const retryTime = config.getConfig().mongodb?.retryTime || constants.DEFAULT_MONGODB_RETRY_TIME;
+                    logger.info(context, `Retrying in ${retryTime} seconds...`);
+                    setTimeout(() => connectionAttempt(callback), retryTime * 1000);
+                } else {
+                    logger.error(
+                        context,
+                        'MONGODB-002: Error to connect found after %d attempts: %s',
+                        retries,
+                        lastError
+                    );
+                    callback(err);
+                }
+            });
     }
 
-    defaultDb = null;
-    async.whilst(retryCheck, tryCreateConnection, createConnectionHandler);
+    connectionAttempt(callback);
 }
 
 function configureDb(callback) {
-    /*jshint camelcase:false, validthis:true */
     const currentConfig = config.getConfig();
-
-    if (currentConfig.deviceRegistry && currentConfig.deviceRegistry.type === 'mongodb') {
-        if (!currentConfig.mongodb || !currentConfig.mongodb.host) {
+    if (currentConfig.deviceRegistry?.type === 'mongodb') {
+        if (!currentConfig.mongodb?.host) {
             logger.fatal(context, 'MONGODB-003: No host found for MongoDB driver.');
             callback(new errors.BadConfiguration('No host found for MongoDB driver'));
         } else {
-            let dbName = currentConfig.mongodb.db;
+            const dbName = currentConfig.mongodb.db || DEFAULT_DB_NAME;
             const port = currentConfig.mongodb.port || 27017;
             const options = {};
 
-            if (!currentConfig.mongodb.db) {
-                dbName = DEFAULT_DB_NAME;
-            }
-
-            if (currentConfig.mongodb.replicaSet) {
-                options.replicaSet = currentConfig.mongodb.replicaSet;
-            }
-
-            if (currentConfig.mongodb.ssl) {
-                options.ssl = currentConfig.mongodb.ssl;
-            }
-
-            if (currentConfig.mongodb.extraArgs) {
-                options.extraArgs = currentConfig.mongodb.extraArgs;
-            }
+            if (currentConfig.mongodb.replicaSet) options.replicaSet = currentConfig.mongodb.replicaSet;
+            if (currentConfig.mongodb.ssl) options.ssl = currentConfig.mongodb.ssl;
+            if (currentConfig.mongodb.extraArgs) options.extraArgs = currentConfig.mongodb.extraArgs;
 
             if (currentConfig.mongodb.user && currentConfig.mongodb.password) {
-                options.auth = {};
-                options.auth.user = currentConfig.mongodb.user;
-                options.auth.password = currentConfig.mongodb.password;
-                // authSource only applies if auth is set
+                options.auth = {
+                    user: currentConfig.mongodb.user,
+                    password: currentConfig.mongodb.password
+                };
                 if (currentConfig.mongodb.authSource) {
-                    // Overload extraArgs if it was set
                     options.extraArgs = {
                         ...options.extraArgs,
                         authSource: currentConfig.mongodb.authSource
@@ -229,7 +170,7 @@ function configureDb(callback) {
                 }
             }
 
-            init(config.getConfig().mongodb.host, dbName, port, options, callback);
+            init(currentConfig.mongodb.host, dbName, port, options, callback);
         }
     } else {
         callback();