iotagent-node-lib 2.17.0 → 2.20.0

package/lib/plugins/expressionPlugin.js

@@ -90,30 +90,19 @@ function update(entity, typeInformation, callback) {
         return false;
     }
 
-    function processEntityUpdateNgsi1(entity) {
-        let parser = legacyParser;
-        if (checkJexl(typeInformation)) {
-            parser = jexlParser;
-        }
-        let expressionAttributes = [];
-        const ctx = parser.extractContext(entity.attributes);
-
-        if (typeInformation.active) {
-            expressionAttributes = parser.processExpressionAttributes(typeInformation, typeInformation.active, ctx);
-        }
-
-        entity.attributes = mergeAttributes(entity.attributes, expressionAttributes);
-
-        return entity;
-    }
-
     function processEntityUpdateNgsi2(attributes) {
         let parser = legacyParser;
         if (checkJexl(typeInformation)) {
             parser = jexlParser;
         }
         let expressionAttributes = [];
-        const ctx = parser.extractContext(attributes);
+        let attributesCtxt = [...attributes]; // just copy
+        if (typeInformation.static) {
+            typeInformation.static.forEach(function (att) {
+                attributesCtxt.push(att);
+            });
+        }
+        const ctx = parser.extractContext(attributesCtxt);
 
         if (typeInformation.active) {
             expressionAttributes = parser.processExpressionAttributes(typeInformation, typeInformation.active, ctx);
@@ -124,13 +113,10 @@ function update(entity, typeInformation, callback) {
     }
 
     try {
-        if (config.isCurrentNgsi()) {
-            let attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
-            attsArray = processEntityUpdateNgsi2(attsArray);
-            entity = utils.createNgsi2Entity(entity.id, entity.type, attsArray, true);
-        } else {
-            entity.contextElements = entity.contextElements.map(processEntityUpdateNgsi1);
-        }
+        logger.debug(context, 'expressionPlugin entity %j', entity);
+        let attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+        attsArray = processEntityUpdateNgsi2(attsArray);
+        entity = utils.createNgsi2Entity(entity.id, entity.type, attsArray, true);
 
         callback(null, entity, typeInformation);
     } catch (e) {

package/lib/plugins/jexlParser.js

@@ -30,9 +30,10 @@
 const jexl = require('jexl');
 const errors = require('../errors');
 const logger = require('logops');
+const fillService = require('../services/common/domain').fillService;
 const config = require('../commonConfig');
 const baseTranformsMap = require('../jexlTranformsMap.js').map;
-const logContext = {
+let logContext = {
     op: 'IoTAgentNGSI.JEXL'
 };
 
@@ -42,6 +43,8 @@ function parse(expression, context, callback) {
 
     try {
         result = jexl.evalSync(expression, context);
+        //avoid undefined result
+        result = result !== undefined ? result : null;
         logger.debug(logContext, 'parse expression "[%j]" over "[%j]" result "[%j]" ', expression, context, result);
     } catch (e) {
         error = new errors.InvalidExpression(expression);
@@ -94,9 +97,10 @@ function extractContext(attributeList) {
 }
 
 function applyExpression(expression, context, typeInformation) {
-    const result = jexl.evalSync(expression, context);
+    logContext = fillService(logContext, typeInformation);
+    const result = parse(expression, context);
     logger.debug(logContext, 'applyExpression "[%j]" over "[%j]" result "[%j]" ', expression, context, result);
-    let expressionResult = result !== undefined ? result : expression;
+    const expressionResult = result !== undefined ? result : expression;
     return expressionResult;
 }
 
@@ -118,7 +122,7 @@ function expressionApplier(context, typeInformation) {
         };
 
         /*jshint camelcase: false */
-        if (config.isCurrentNgsi() && attribute.object_id) {
+        if (attribute.object_id) {
             newAttribute.object_id = attribute.object_id;
         }
 

package/lib/plugins/multiEntity.js

@@ -64,24 +64,6 @@ function hasEntityName(item) {
     return item.entity_name;
 }
 
-function ensureEntityId(entityName, originalEntityName) {
-    // ensure no return null, 0, false, NaN and other invalids entityIDs
-    return entityName ? entityName : originalEntityName;
-}
-
-/**
- * Return a list of all the attributes that don't have a multientity option. It considers NGSIv1.
- *
- * @param {Array} originalAttrs        Array of original attributes coming from the single-entity device.
- * @param {Array} meAttributes         Array of all the multientity attributes.
- * @return {Array}                     List of all the attrbiutes without multientity flag.
- */
-function filterOutMultientitiesNgsi1(originalAttrs, meAttributes) {
-    return originalAttrs.filter(function (item) {
-        return !_.contains(meAttributes, item.name);
-    });
-}
-
 /**
  * Return a list of all the attributes that don't have a multientity option. It considers NGSIv2.
  *
@@ -121,87 +103,30 @@ function filterOutMultientitiesNgsi2(originalAttrs, meAttributes) {
     return result;
 }
 
-/**
- * Generate new Context Elements for each new Entity, with the attributes of the original entity matching its
- * entity_name. It considers Ngsiv1.
- *
- * @param {Object} entity                   The original entity
- * @param {Array} newEntities               List of the new entities that will be generated
- * @param {Array} entityTypes               Map of the types for each entity ID
- * @param {Object} typeInformation          Object with all the data about the device type
- * @param {Array} multiEntityAttributes     List of attributes with multientity option
- * @return {Array}                          List of the new Context Entities
- */
-function generateNewCEsNgsi1(entity, newEntities, entityTypes, typeInformation, multiEntityAttributes) {
-    const result = [];
-    let newEntityAttributes;
-    let newEntityAttributeNames;
-    let entityName;
-    let parser = legacyParser;
-    if (checkJexl(typeInformation)) {
-        parser = jexlParser;
-    }
-    function filterByEntityName(entityName) {
-        return function (item) {
-            return item.entity_name === entityName;
-        };
-    }
-
-    function filterByAttributeNames(item) {
-        return _.contains(newEntityAttributeNames, item.name);
-    }
-
-    const ctx = parser.extractContext(entity.contextElements[0].attributes);
-
-    for (let i = 0; i < newEntities.length; i++) {
-        newEntityAttributeNames = _.pluck(multiEntityAttributes.filter(filterByEntityName(newEntities[i])), 'name');
-
-        newEntityAttributes = entity.contextElements[0].attributes.filter(filterByAttributeNames);
-        // Fix duplicated attributes in entity
-        newEntityAttributes = _.uniq(newEntityAttributes, JSON.stringify);
-        if (parser.contextAvailable(newEntities[i], ctx)) {
-            entityName = parser.applyExpression(newEntities[i], ctx, typeInformation);
-        }
-
-        result.push({
-            type: entityTypes[newEntities[i]],
-            isPattern: 'false',
-            id: ensureEntityId(entityName, newEntities[i]),
-            attributes: newEntityAttributes
-        });
-    }
-
-    return result;
-}
-
 /**
  * Generate new Context Elements for each new Entity, with the attributes of the original entity matching its
  * entity_name. It considers Ngsiv2.
  *
  * @param {Object} entity                   The original entity
  * @param {Array} newEntities               List of the new entities that will be generated
- * @param {Array} entityTypes               Map of the types for each entity ID
- * @param {Object} typeInformation          Object with all the data about the device type
  * @param {Array} multiEntityAttributes     List of attributes with multientity option
  * @return {Array}                          List of the new Context Entities
  */
-function generateNewCEsNgsi2(entity, newEntities, entityTypes, typeInformation, multiEntityAttributes) {
+function generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes) {
     const result = [];
     let newEntityAttributes;
     let newEntityAttributeNames;
     let newEntityAttributeObjectIds;
-    let entityName;
-    let parser = legacyParser;
-    if (checkJexl(typeInformation)) {
-        parser = jexlParser;
-    }
-    function filterByEntityName(entityName) {
+    function filterByEntityNameandType(entityNameType) {
         return function (item) {
-            return item.entity_name === entityName;
+            return (
+                item.entity_name === entityNameType.entity_name &&
+                (!item.entity_type || item.entity_type === entityNameType.entity_type)
+            );
         };
     }
 
-    function filterByAttributeObjectIds() {
+    function filterByAttributeObjectIds(entity, newEntityAttributeNames, newEntityAttributeObjectIds) {
         const result = {};
         for (const att in entity) {
             if (entity.hasOwnProperty(att)) {
@@ -227,40 +152,44 @@ function generateNewCEsNgsi2(entity, newEntities, entityTypes, typeInformation,
         return result;
     }
 
-    const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
-    const ctx = parser.extractContext(attsArray);
-
     for (let i = 0; i < newEntities.length; i++) {
-        newEntityAttributeNames = _.pluck(multiEntityAttributes.filter(filterByEntityName(newEntities[i])), 'name');
+        newEntityAttributeNames = _.pluck(
+            multiEntityAttributes.filter(filterByEntityNameandType(newEntities[i])),
+            'name'
+        );
         newEntityAttributeObjectIds = _.pluck(
-            multiEntityAttributes.filter(filterByEntityName(newEntities[i])),
+            multiEntityAttributes.filter(filterByEntityNameandType(newEntities[i])),
             'object_id'
         );
-        newEntityAttributes = filterByAttributeObjectIds();
-
-        if (parser.contextAvailable(newEntities[i], ctx)) {
-            entityName = parser.applyExpression(newEntities[i], ctx, typeInformation);
-        }
-
-        newEntityAttributes.type = entityTypes[newEntities[i]];
-        newEntityAttributes.id = ensureEntityId(entityName, newEntities[i]);
-
+        newEntityAttributes = filterByAttributeObjectIds(entity, newEntityAttributeNames, newEntityAttributeObjectIds);
+        newEntityAttributes.type = newEntities[i].entity_type;
+        newEntityAttributes.id = newEntities[i].entity_name;
         result.push(newEntityAttributes);
     }
-
     return result;
 }
 
-function extractTypes(attributeList, defaultType) {
-    const typeMap = {};
-
-    for (let i = 0; i < attributeList.length; i++) {
-        typeMap[attributeList[i].entity_name] = attributeList[i].entity_type || defaultType;
+function extractNewEntities(multiEntityAttributes, defaultType) {
+    let newEntitieswithDuplicates = multiEntityAttributes.map((elem) => {
+        return { entity_name: elem.entity_name, entity_type: elem.entity_type || defaultType };
+    });
+    let auxOverwriteTree = {};
+    for (let entityItem in newEntitieswithDuplicates) {
+        if (!auxOverwriteTree[newEntitieswithDuplicates[entityItem].entity_name]) {
+            auxOverwriteTree[newEntitieswithDuplicates[entityItem].entity_name] = {};
+        }
+        auxOverwriteTree[newEntitieswithDuplicates[entityItem].entity_name][
+            newEntitieswithDuplicates[entityItem].entity_type
+        ] = null;
     }
-
-    return typeMap;
+    let flatNewEntities = [];
+    for (let entityItem in auxOverwriteTree) {
+        for (let typeItem in auxOverwriteTree[entityItem]) {
+            flatNewEntities.push({ entity_name: entityItem, entity_type: typeItem });
+        }
+    }
+    return flatNewEntities;
 }
-
 /**
  * Propagates the same timestamp used in entity to entities. This is needed given that timestamp processing
  * plugin runs before multientity plugin, so we could have issues as the one described here:
@@ -295,44 +224,32 @@ function propagateTimestamp(entity, entities) {
     });
 }
 
-function updateAttributeNgsi1(entity, typeInformation, callback) {
-    if (typeInformation.active) {
-        const multiEntityAttributes = typeInformation.active.filter(hasEntityName);
-        const newEntities = _.uniq(_.pluck(multiEntityAttributes, 'entity_name'));
-        const attributesList = _.pluck(multiEntityAttributes, 'name');
-        const entityTypes = extractTypes(multiEntityAttributes, entity.contextElements[0].type);
-        const resultAttributes = filterOutMultientitiesNgsi1(entity.contextElements[0].attributes, attributesList);
-
-        entity.contextElements = entity.contextElements.concat(
-            generateNewCEsNgsi1(entity, newEntities, entityTypes, typeInformation, multiEntityAttributes)
-        );
-
-        entity.contextElements[0].attributes = resultAttributes;
+function updateAttribute(entity, typeInformation, callback) {
+    let parser = legacyParser;
+    if (checkJexl(typeInformation)) {
+        parser = jexlParser;
     }
+    const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+    const ctx = parser.extractContext(attsArray);
 
-    callback(null, entity, typeInformation);
-}
-
-function updateAttributeNgsi2(entity, typeInformation, callback) {
-    let entities = [];
-    entities.push(entity);
+    let entities = [entity];
     if (typeInformation.active) {
         const multiEntityAttributes = typeInformation.active.filter(hasEntityName);
-        const newEntities = _.uniq(_.pluck(multiEntityAttributes, 'entity_name'));
-        const entityTypes = extractTypes(multiEntityAttributes, typeInformation.type);
-        let resultAttributes;
+        for (let i in multiEntityAttributes) {
+            if (parser.contextAvailable(multiEntityAttributes[i].entity_name, ctx)) {
+                let entityName = parser.applyExpression(multiEntityAttributes[i].entity_name, ctx, typeInformation);
+                // An entity_name could not be null, but a result or expression could be null
+                if (entityName !== null) {
+                    multiEntityAttributes[i].entity_name = entityName;
+                }
+            }
+        }
+        const newEntities = extractNewEntities(multiEntityAttributes, typeInformation.type);
 
         if (multiEntityAttributes.length > 0) {
-            resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
-            const newCes = generateNewCEsNgsi2(
-                entity,
-                newEntities,
-                entityTypes,
-                typeInformation,
-                multiEntityAttributes
-            );
-            entities = entities.concat(newCes);
-            entities[0] = resultAttributes;
+            let resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
+            const newCes = generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes);
+            entities = [resultAttributes].concat(newCes);
             propagateTimestamp(entity, entities);
         } else {
             entities = entity;
@@ -341,12 +258,4 @@ function updateAttributeNgsi2(entity, typeInformation, callback) {
     callback(null, entities, typeInformation);
 }
 
-function updateAttribute(entity, typeInformation, callback) {
-    if (config.isCurrentNgsi()) {
-        updateAttributeNgsi2(entity, typeInformation, callback);
-    } else {
-        updateAttributeNgsi1(entity, typeInformation, callback);
-    }
-}
-
 exports.update = updateAttribute;

package/lib/plugins/pluginUtils.js

@@ -23,8 +23,6 @@
  * Modified by: Daniel Calvo - ATOS Research & Innovation
  */
 
-const config = require('../commonConfig');
-
 /**
  * Creates an array of attributes from an entity
  * @param       {Object}             entity
@@ -66,8 +64,6 @@ function extractAttributesArrayFromNgsi2Entity(entity) {
  */
 function createNgsi2Entity(id, type, attsArray, withObjectId) {
     const entity = {};
-    entity.id = id;
-    entity.type = type;
     for (let i = 0; i < attsArray.length; i++) {
         /*jshint camelcase: false */
         if (entity[attsArray[i].name] && withObjectId && attsArray[i].object_id) {
@@ -93,7 +89,8 @@ function createNgsi2Entity(id, type, attsArray, withObjectId) {
             }
         }
     }
-
+    entity.id = id;
+    entity.type = type;
     return entity;
 }
 
@@ -102,24 +99,15 @@ function createProcessAttribute(fn, attributeType) {
         if (attribute.type && attribute.type === attributeType) {
             attribute.value = fn(attribute.value);
         }
-        if (config.isCurrentNgsi()) {
-            // This code is backwards compatible to process metadata in the older NGSIv1-style (array)
-            // as well as supporting the newer NGSIv2-style (object). The redundant Array Check can be
-            // therefore be removed if/when NGSIv1 support is removed from the library.
-            if (Array.isArray(attribute.metadata)) {
-                attribute.metadata = attribute.metadata.map(createProcessAttribute(fn, attributeType));
-            } else if (attribute.metadata) {
-                Object.keys(attribute.metadata).forEach(function (key) {
-                    const entry = attribute.metadata[key];
-                    if (entry.type === 'DateTime') {
-                        entry.value = fn(entry.value);
-                    }
-                });
-            }
-        } else if (attribute.metadatas) {
-            attribute.metadatas = attribute.metadatas.map(createProcessAttribute(fn, attributeType));
-        }
 
+        if (attribute.metadata) {
+            Object.keys(attribute.metadata).forEach(function (key) {
+                const entry = attribute.metadata[key];
+                if (entry.type === 'DateTime') {
+                    entry.value = fn(entry.value);
+                }
+            });
+        }
         return attribute;
     };
 }
@@ -135,12 +123,6 @@ function createProcessAttribute(fn, attributeType) {
 
 function createUpdateFilter(fn, attributeType) {
     return function update(entity, typeInformation, callback) {
-        function processEntityUpdateNgsi1(entity) {
-            entity.attributes = entity.attributes.map(createProcessAttribute(fn, attributeType));
-
-            return entity;
-        }
-
         function processEntityUpdateNgsi2(entity) {
             let attsArray = extractAttributesArrayFromNgsi2Entity(entity);
             attsArray = attsArray.map(createProcessAttribute(fn, attributeType));
@@ -148,12 +130,7 @@ function createUpdateFilter(fn, attributeType) {
             return entity;
         }
 
-        if (config.isCurrentNgsi()) {
-            entity = processEntityUpdateNgsi2(entity);
-        } else {
-            entity.contextElements = entity.contextElements.map(processEntityUpdateNgsi1);
-        }
-
+        entity = processEntityUpdateNgsi2(entity);
         callback(null, entity, typeInformation);
     };
 }
@@ -168,14 +145,6 @@ function createUpdateFilter(fn, attributeType) {
  */
 function createQueryFilter(fn, attributeType) {
     return function query(entity, typeInformation, callback) {
-        function processEntityQueryNgsi1(entity) {
-            entity.contextElement.attributes = entity.contextElement.attributes.map(
-                createProcessAttribute(fn, attributeType)
-            );
-
-            return entity;
-        }
-
         function processEntityQueryNgsi2(entity) {
             let attsArray = extractAttributesArrayFromNgsi2Entity(entity);
             attsArray = attsArray.map(createProcessAttribute(fn, attributeType));
@@ -183,12 +152,7 @@ function createQueryFilter(fn, attributeType) {
             return entity;
         }
 
-        if (config.isCurrentNgsi()) {
-            entity = processEntityQueryNgsi2(entity);
-        } else {
-            entity.contextResponses = entity.contextResponses.map(processEntityQueryNgsi1);
-        }
-
+        entity = processEntityQueryNgsi2(entity);
         callback(null, entity, typeInformation);
     };
 }

package/lib/plugins/timestampProcessPlugin.js

@@ -31,7 +31,6 @@ const logger = require('logops');
 const context = {
     op: 'IoTAgentNGSI.TimestampProcessPlugin'
 };
-const config = require('../commonConfig');
 const utils = require('./pluginUtils');
 
 /**
@@ -84,57 +83,13 @@ function updatePluginNgsi2(entity, entityType, callback) {
     }
 }
 
-/**
- * Looks for Thinking Thing modules and parses them, updating the entity (NGSIv1) with the transformed value.
- *
- * @param {Object} entity           NGSI Entity as it would have been sent before the plugin.
- */
-function updatePluginNgsi1(entity, entityType, callback) {
-    let timestamp;
-
-    function insertMetadata(element) {
-        if (element.name !== constants.TIMESTAMP_ATTRIBUTE) {
-            element.metadatas = [
-                {
-                    name: constants.TIMESTAMP_ATTRIBUTE,
-                    type: constants.TIMESTAMP_TYPE,
-                    value: timestamp.value
-                }
-            ];
-        }
-
-        return element;
-    }
-
-    if (entity.contextElements && entity.contextElements[0] && entity.contextElements[0].attributes) {
-        for (const i in entity.contextElements[0].attributes) {
-            if (entity.contextElements[0].attributes[i].name === constants.TIMESTAMP_ATTRIBUTE) {
-                timestamp = entity.contextElements[0].attributes[i];
-            }
-        }
-
-        if (timestamp) {
-            entity.contextElements[0].attributes = entity.contextElements[0].attributes.map(insertMetadata);
-        }
-
-        callback(null, entity, entityType);
-    } else {
-        logger.error(context, 'Bad payload received while processing timestamps');
-        callback(new errors.WrongSyntax(entity));
-    }
-}
-
 /**
  * Looks for Thinking Thing modules and parses them, updating the entity with the transformed value.
  *
  * @param {Object} entity           NGSI Entity as it would have been sent before the plugin.
  */
 function updatePlugin(entity, entityType, callback) {
-    if (config.isCurrentNgsi()) {
-        updatePluginNgsi2(entity, entityType, callback);
-    } else {
-        updatePluginNgsi1(entity, entityType, callback);
-    }
+    updatePluginNgsi2(entity, entityType, callback);
 }
 
 exports.update = updatePlugin;

package/lib/request-shim.js

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
+ *
+ * This file is part of fiware-iotagent-lib
+ *
+ * fiware-iotagent-lib is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * fiware-iotagent-lib 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License along with fiware-iotagent-lib.
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ * For those usages not covered by the GNU Affero General Public License
+ * please contact with::daniel.moranjimenez@telefonica.com
+ */
+
+const got = require('got');
+const logger = require('logops');
+const context = {
+    op: 'IoTAgentNGSI.Request'
+};
+
+/**
+ *  Transform the "request" options into "got" options and add additional "got" defaults
+ *
+ *  The following options are currently exposed:
+ *   - `method` - HTTP Method
+ *   - `searchParams` - query string params
+ *   - `qs` - alias for query string params
+ *   - `headers`
+ *   - `responseType` - either `text` or `json`. `json` is the default
+ *   - `json` - a supplied JSON object as the request body
+ *   - `body` - any ASCII text as  the request body
+ *   - `url` - the request URL
+ *   - `uri` - alternative alias for the request URL.
+ *
+ * @param {Object} options          Original definition of the request using the request library
+ * @return {Object}                 Updated definition of the request using the got library
+ *
+ */
+function getOptions(options) {
+    const httpOptions = {
+        method: options.method,
+        searchParams: options.searchParams || options.qs,
+        headers: options.headers,
+        throwHttpErrors: options.throwHttpErrors || false,
+        retry: options.retry || 0,
+        responseType: options.responseType || 'json'
+    };
+
+    // got library is not properly documented, so it is not clear which takes precedence
+    // among body, json and form (see https://stackoverflow.com/q/70754880/1485926).
+    // Thus, we are enforcing our own precedence with the "else if" chain below.
+    // Behaviour is consistent with the one described at usermanual.md#iotagentlibrequest
+
+    if (options.method === 'GET' || options.method === 'HEAD' || options.method === 'OPTIONS') {
+        // Do nothing - Never add a body
+    } else if (options.body) {
+        // body takes precedence over json or form
+        httpOptions.body = options.body;
+    } else if (options.json) {
+        // json takes precedence over form
+        httpOptions.json = options.json;
+    } else if (options.form) {
+        // Note that we don't consider 'form' part of the function API (check usermanual.md#iotagentlibrequest)
+        // but we are preparing the code anyway as a safe measure
+        httpOptions.form = options.form;
+    }
+
+    return httpOptions;
+}
+
+/*
+ *
+ *  Make a direct HTTP request using the underlying request library
+ *  (currently [got](https://github.com/sindresorhus/got)),
+ *
+ *  This function mimics the interface of the obsolete request library and switches
+ *  back from promises to callbacks to avoid re-writing large chunks of code.
+ *  This centralizes all HTTP requests in a single location and is useful
+ *  when creating agents which use an HTTP transport for their southbound
+ *  commands, and removes the need for the custom IoT Agent to import its own
+ *  additonal request library.
+ *
+ * @param {Object} options            Definition of the request .
+ * @param {Function} callback         The callback function.
+ *
+ */
+
+function request(options, callback) {
+    const httpOptions = getOptions(options);
+    logger.debug(context, 'Options: %s', JSON.stringify(options, null, 4));
+    got(options.url || options.uri, httpOptions)
+        .then((response) => {
+            logger.debug(context, 'Response %s', JSON.stringify(response.body, null, 4));
+            return callback(null, response, response.body);
+        })
+        .catch((error) => {
+            logger.debug(context, 'Error: %s', JSON.stringify(error, null, 4));
+            return callback(error);
+        });
+}
+
+module.exports = request;

package/lib/services/common/domain.js

@@ -47,6 +47,8 @@ function cleanDomain(domainToClean) {
     delete domainToClean.from;
     delete domainToClean.op;
     delete domainToClean.path;
+    delete domainToClean.service;
+    delete domainToClean.subservice;
     domainToClean.exit();
 }
 
@@ -139,8 +141,10 @@ function ensureSouthboundTransaction(context, callback) {
         reqDomain.corr = reqDomain.trans;
     }
 
-    if (context && context.op) {
-        reqDomain.op = context.op;
+    if (context) {
+        if (context.op) {
+            reqDomain.op = context.op;
+        }
 
         if (context.srv) {
             reqDomain.service = context.srv;