@alertlogic/al-collector-js 2.0.3 → 3.0.1

package/.travis.yml

@@ -1,7 +1,7 @@
 sudo: false
 language: node_js
 node_js:
-  - "8"
+  - "12"
 install:
   - npm install
 script:

package/al_log.js

@@ -3,6 +3,7 @@
  * @doc
  *
  * Helper utilities for  Alert Logic log collector.
+ * NOTE: parameters to all functions are passed as (object, callback)
  *
  * @end
  * -----------------------------------------------------------------------------
@@ -11,6 +12,7 @@ const crypto = require('crypto');
 const async = require('async');
 const zlib = require('zlib');
 
+const alLogFilter = require('./al_log_filter');
 const alcHealthPb = require('./proto/alc_health.piqi_pb').alc_health;
 const commonProtoPb = require('./proto/common_proto.piqi_pb').common_proto;
 const dictPb = require('./proto/dict.piqi_pb').alc_dict;
@@ -50,6 +52,11 @@ const PAYLOAD_BATCH_SIZE = 10000000;
  *      applicationId: 'o365'
  *  };
  *  Consult 'collected_message' definition in proto/common_proto.piqi.proto
+ *  @param filterJson - JSON parsed object representing key-value pairs which 
+ *  should exist in a message. For example, {type: 'Security', category: 'Admin'}.
+ *  NOTE: do NOT use json filter if 'content' is an array of strings.
+ *  @param filterRegexp - regexp object filter. If content messages are JSON object
+ *  then regexp filter if applied to a stringified message value.
  *  @param callback
  *  
  *  @return callback - (error, builtPayload, payloadSize)
@@ -58,46 +65,69 @@ const PAYLOAD_BATCH_SIZE = 10000000;
  *  For an AWS Lambda via kinesis trigger batch size configuration.
  */
 
-var buildPayload = function (hostId, sourceId, hostmetaElems, content, parseCallback, mainCallback) {
+var buildPayload = function ({hostId, sourceId, hostmetaElems, content, parseCallback, filterJson, filterRegexp}, mainCallback) {
     async.waterfall([
         function(callback) {
-            buildMessages(content, parseCallback, function(err, msg) {
+            const params = {
+                content: content,
+                parseContentFun: parseCallback,
+                filterJson: filterJson,
+                filterRegexp: filterRegexp
+            };
+            buildMessages(params, function(err, msg) {
                 return callback(err, msg);
             });
         },
         function(msg, callback) {
-            buildHostmeta(hostId, hostmetaElems, function(err, meta) {
+            const params = {
+                hostId: hostId,
+                hostmetaElems: hostmetaElems
+            };
+            buildHostmeta(params, function(err, meta) {
                 return callback(err, meta, msg);
             });
         },
         function(meta, msg, callback) {
-            buildBatch(sourceId, meta, msg, function(err, batch) {
-                return callback(err, batch);
+            const params = {
+                sId: sourceId,
+                metadata: meta,
+                messages:msg
+            };
+            buildBatch(params, function(err, batch) {
+                return callback(err, batch, msg);
             });
         },
-        function(batchBuf, callback) {
-            buildBatchList(batchBuf, function(err, batchList) {
-                return callback(err, batchList);
+        function(batchBuf, msg, callback) {
+            const params = {
+                batches: batchBuf
+            };
+            buildBatchList(params, function(err, batchList) {
+                return callback(err, batchList, msg);
             });
         },
-        function(batchList, callback) {
-            var batchListType = commonProtoPb.collected_batch_list;
-            var buf = batchListType.encode(batchList).finish();
-            return callback(null, buf);
+        function(batchList, msg, callback) {
+            let batchListType = commonProtoPb.collected_batch_list;
+            let buf = batchListType.encode(batchList).finish();
+            return callback(null, buf, msg);
         }],
-        function(err, result) {
+        function (err, result, msg) {
             if (err) {
                 return mainCallback(err);
             } else {
+                // calculate the actual collected messages byte size
+                let collectedMessageBytes = 0;
+                msg.map(eachMessage => {
+                    collectedMessageBytes += eachMessage.messageLength;
+                });
                 zlib.deflate(result, function(defalteErr, compressed) {
                     if (defalteErr) {
                         return mainCallback(defalteErr);
                     } else {
-                        var payloadSize = compressed.byteLength;
+                        let payloadSize = compressed.byteLength;
                         if (payloadSize > PAYLOAD_BATCH_SIZE) {
                             return mainCallback(`Maximum payload size exceeded: ${payloadSize}`, compressed);
                         } else {
-                            return mainCallback(null, compressed);
+                            return mainCallback(null, { payload: compressed, payload_size: payloadSize, raw_count: msg.length, raw_bytes: collectedMessageBytes });
                         }
                     }
                 });
@@ -111,14 +141,12 @@ var buildPayload = function (hostId, sourceId, hostmetaElems, content, parseCall
  * 
  */
 
-function buildType(type, payload, callback) {
-    var verify = type.verify(payload);
+function buildType({type, payload}, callback) {
+    let verify = type.verify(payload);
     if (verify)
         return callback(verify);
 
-    var payloadCreated = type.create(payload);
-
-    return callback(null, payloadCreated);
+    return callback(null, type.create(payload));
 }
 
 /**
@@ -140,32 +168,41 @@ function buildType(type, payload, callback) {
  *  @returns callback
  */
 
-function buildHostmeta(hostId, hostmetaElems, callback) {
-    var hostmetaType = hostMetadataPb.metadata;
-    var hostmeta = {
+function buildHostmeta({hostId, hostmetaElems}, callback) {
+    let hostmetaType = hostMetadataPb.metadata;
+    let hostmeta = {
         elem : hostmetaElems
     };
-    buildType(dictPb.dict, hostmeta, function(err, hostmetaData){
+    const paramsDict = {
+        type: dictPb.dict,
+        payload: hostmeta
+    };
+    
+    buildType(paramsDict, function(err, hostmetaData){
         if (err) {
             return callback(err);
         } else {
-            var meta = {
+            let meta = {
                 hostUuid : hostId,
                 data : hostmetaData,
                 dataChecksum : new Buffer('')
             };
-            var sha = crypto.createHash('sha1');
-            var hashPayload = hostmetaType.encode(meta).finish();
-            var hashValue = sha.update(hashPayload).digest();
+            let sha = crypto.createHash('sha1');
+            let hashPayload = hostmetaType.encode(meta).finish();
+            let hashValue = sha.update(hashPayload).digest();
             
-            var metadataPayload = {
+            let metadataPayload = {
                 hostUuid : hostId,
                 dataChecksum : hashValue,
                 timestamp : Math.floor(Date.now() / 1000),
                 data : hostmetaData
             };
     
-            return buildType(hostmetaType, metadataPayload, callback);
+            const paramsHostmeta = {
+                type: hostmetaType,
+                payload: metadataPayload
+            };
+            return buildType(paramsHostmeta, callback);
         }
     });
 }
@@ -186,46 +223,72 @@ function buildHostmeta(hostId, hostmetaElems, callback) {
  *      applicationId: 'o365'
  *  };
  *  Consult 'collected_message' definition in proto/common_proto.piqi.proto
+ * @param filterJson - JSON parsed object representing key-value pairs which 
+ * should exist in a message. For example, {type: 'Security', category: 'Admin'}.
+ * @param filterRegexp - regexp object filter. If content messages are JSON object
+ * then regexp filter if applied to a stringified message value.
  * @param callback
  * @returns
  */
 
-function buildMessages(content, parseContentFun, callback) {
-    async.reduce(content, [], function(memo, item, asyncCallback) {
-        var messageType = commonProtoPb.collected_message;
-        var messagePayload = parseContentFun(item);
-        buildType(messageType, messagePayload, function(err, buf) {
-            if (err) {
-                return asyncCallback(err);
+function buildMessages({content, parseContentFun, filterJson, filterRegexp}, callback) {
+    const jsonFilteredContent = alLogFilter.filterJson(content, filterJson);
+    const reFilter = alLogFilter.initRegExpFilter(filterRegexp);
+    
+    async.reduce(jsonFilteredContent, [], function(memo, item, asyncCallback) {
+        let messageType = commonProtoPb.collected_message;
+        let messagePayload = parseContentFun(item);
+        if (messagePayload && messagePayload.message) {
+            // Apply RegExp filter
+            const passFilter = reFilter ? reFilter.test(messagePayload.message) : true;
+            if (passFilter) {
+                const paramsMessage = {
+                    type: messageType,
+                    payload: messagePayload
+                };
+                buildType(paramsMessage, function(err, buf) {
+                    if (err) {
+                        return asyncCallback(err);
+                    } else {
+                        buf.messageLength = buf.message.length;
+                        memo.push(buf);
+                        return asyncCallback(err, memo);
+                    }
+                });
             } else {
-                memo.push(buf);
-                return asyncCallback(err, memo);
+                return asyncCallback(null, memo);
             }
-        });
+        } else {
+            return asyncCallback(null, memo);
+        }
     },
     callback);
 }
 
-function buildBatch(sId, metadata, messages, callback) {
-    var batchType = commonProtoPb.collected_batch;
-
-    var batchPayload = {
+function buildBatch({sId, metadata, messages}, callback) {
+    const batchPayload = {
         sourceId: sId,
         metadata: metadata,
         message: messages
     };
 
-    buildType(batchType, batchPayload, callback);
+    const params = {
+        type: commonProtoPb.collected_batch,
+        payload: batchPayload
+    };
+    buildType(params, callback);
 }
 
-function buildBatchList(batches, callback) {
-    var batchListType = commonProtoPb.collected_batch_list;
-
-    var batchListPayload = {
+function buildBatchList({batches}, callback) {
+    const batchListPayload = {
         elem: [batches]
     };
 
-    buildType(batchListType, batchListPayload, callback);
+    const params = {
+        type: commonProtoPb.collected_batch_list,
+        payload: batchListPayload
+    };
+    buildType(params, callback);
 }
 
 

package/al_log_filter.js

@@ -0,0 +1,117 @@
+/* -----------------------------------------------------------------------------
+ * @copyright (C) 2021, Alert Logic, Inc
+ * @doc
+ *
+ * Helper log filter utilities for  Alert Logic log collector.
+ *
+ * @end
+ * -----------------------------------------------------------------------------
+ */
+const lodashFilter = require('lodash.filter');
+const lodashRemove = require('lodash.remove');
+const lodashcloneDeep = require('lodash.clonedeep');
+
+/**
+ *  @function initializes JSON filter
+ *
+ *  @param filter - string or object,
+ *      for example, string '{"a": 1}',
+ *                   object {a:1},
+ *                   deep object '{"a": "firstlevelChild": 1}', '{"a": "firstlevelChild": "secondlevelChild": 2}', '{"a": "...nth levelChild": n},
+ *                   array object '[{"a": 1}, {"b": 2}]',
+ *
+ *  @return filter - inited Json filter or null if json is incorrect
+ */
+var initJsonFilter = function (filter) {
+    if (typeof filter === 'string') {
+        try {
+            return JSON.parse(filter);
+        } catch (exception) {
+            return null;
+        }
+    } else {
+        return filter;
+    }
+};
+
+/**
+ *  @function filter messages using JSON like filters.
+ *  
+ *  @param messages - array of JSON parsed log messages
+ *  @param filterString - filter string/object, for example, '{user: \"a\"}'
+ *  
+ *  @return array - filtered messages
+ *  @NOTE: If json filter  is bad then 'messages' is returned unfiltered.
+ */
+
+var filterJson = function (messages, filter) {
+    const filterJ = initJsonFilter(filter);
+    if (filterJ) {
+        let result = [];
+        let clonedMsgs = lodashcloneDeep(messages);
+        if (Array.isArray(filterJ)) {
+            // Iterate over filterJson and push filtered items into array
+            filterJ.forEach(function (e) {
+                result = result.concat(lodashRemove(clonedMsgs, function (t) {
+                    // filter messages with filterJson element
+                    return lodashFilter([t], e).length;
+                }));
+            });
+        } else {
+            result = result.concat(lodashFilter(clonedMsgs, filterJ));
+        }
+        // Return filtered items
+        return result;
+    } else {
+        return messages;
+    }
+};
+
+/**
+ *  @function initializes reg exp filter
+ *  
+ *  @param filter - string or regexp, for example, 'ab+c', /ab+c/
+ *  
+ *  @return filter - inited regexp or null if regexp is incorrect
+ */
+var initRegExpFilter = function (filter) {
+    if (typeof filter === 'string') {
+        try {
+            return new RegExp(filter);
+        } catch (exception) {
+            return null;
+        }
+    } else {
+        return filter;
+    }
+};
+
+/**
+ *  @function filters messages using regexp
+ *  
+ *  @param messages - array of JSON parsed log messages
+ *  @param filter - filter string regexp or regexp object, for example, 'ab+c', /ab+c/
+ *  
+ *  @return array - filtered messages
+ *  @NOTE: If regexp filter is bad then 'messages' is returned unfiltered.
+ */
+
+var filterRegExp = function (messages, filter) {
+    const re = initRegExpFilter(filter);
+    if (re) {
+        return messages.filter(function (m) {
+            return re.test(m);
+        });
+    } else {
+        return messages;
+    }
+};
+
+
+module.exports = {
+    filterJson: filterJson,
+    filterRegExp: filterRegExp,
+    initRegExpFilter: initRegExpFilter,
+    initJsonFilter: initJsonFilter
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alertlogic/al-collector-js",
-  "version": "2.0.3",
+  "version": "3.0.1",
   "license": "MIT",
   "description": "Alert Logic Collector Common Library",
   "repository": {
@@ -32,6 +32,9 @@
   "dependencies": {
     "async": "3.1.0",
     "debug": "4.1.1",
+    "lodash.filter": "^4.6.0",
+    "lodash.remove": "^4.7.0",
+    "lodash.clonedeep": "^4.5.0",
     "moment": "2.24.0",
     "protobufjs": "6.8.8",
     "request": "2.88.0",

package/test/al_log_filter_test.js

@@ -0,0 +1,159 @@
+/* -----------------------------------------------------------------------------
+ * @copyright (C) 2021, Alert Logic, Inc
+ * @doc
+ *
+ * Tests for log filtering.
+ *
+ * @end
+ * -----------------------------------------------------------------------------
+ */
+
+const assert = require('assert');
+const alLogFilter = require('../al_log_filter');
+
+describe('Unit Tests', function() {
+    describe('Filter Messages', function() {
+        let msgJson = [];
+        const msgString = [
+            'message1',
+            'message2',
+            'message3'
+        ];
+        
+        before(function(){
+            msgJson = [
+                { message1: 1, text: 'test1' },
+                { message2: 2, text: 'test12'},
+                { messageA: "a", text: 'testa'},
+                { messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                }, text: 'testb'},
+                { messageC: {
+                    childTestMsg: 'childTest',
+                    childTestValue: {
+                        messageC: "c"
+                    }
+                }, text: 'testc'},
+                { messageD: {
+                    childTestMsg: 'childTestD',
+                    childTestValue: {
+                        messageC: "c"
+                    }
+                }, text: 'testd'}
+            ];
+        });
+        after(function() {
+        });
+
+        it('Sunny case ', function(done) {
+            assert.deepEqual([{ message1: 1, text: 'test1' }], alLogFilter.filterJson(msgJson, '{"message1":1}'));
+            assert.deepEqual(['message1'], alLogFilter.filterRegExp(msgString, '.*1'));
+            assert.deepEqual(['message1', 'message2', 'message3'], alLogFilter.filterRegExp(msgString, '^message.*'));
+            return done();
+        });
+        
+        it('Wrong JSON filter', function(done) {
+            assert.deepEqual(msgJson, alLogFilter.filterJson(msgJson, '{"message1":1'));
+            return done();
+        });
+        
+        it('Wrong RegExp filter', function(done) {
+            assert.deepEqual(msgString, alLogFilter.filterRegExp(msgString, '['));
+            return done();
+        });
+        
+        it('Undefined filters', function (done) {
+            assert.deepEqual(msgString, alLogFilter.filterRegExp(msgString, null));
+            assert.deepEqual(msgJson, alLogFilter.filterJson(msgJson));
+            return done();
+        });
+
+        it('Should filter array based on object child property', function (done) {
+            assert.deepEqual([{
+                messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                },
+                text: 'testb'
+            }], alLogFilter.filterJson(msgJson, '{"messageB":{"childTestMsg":"childTest"}}'));
+            return done();
+        });
+
+        it('Should filter array based on object child of child property', function (done) {
+            assert.deepEqual([{
+                messageC: {
+                    childTestMsg: 'childTest',
+                    childTestValue: {
+                        messageC: "c"
+                    }
+                },
+                text: 'testc'
+            }], alLogFilter.filterJson(msgJson, '{"messageC":{"childTestMsg": "childTest","childTestValue":{"messageC":"c"}}}'));
+            return done();
+        });
+
+        it('Should filter array based on array of object with AND case', function (done) {
+            assert.deepEqual([{
+                messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                },
+                text: 'testb'
+            }, {
+                messageC: {
+                    childTestMsg: 'childTest',
+                    childTestValue: {
+                        messageC: "c"
+                    }
+                },
+                text: 'testc'
+            }], alLogFilter.filterJson(msgJson, '[{"messageB":{"childTestMsg":"childTest"}}, {"messageC":{"childTestMsg": "childTest","childTestValue":{"messageC":"c"}}}]'));
+            return done();
+        });
+
+        it('Should filter array based on array of object with OR case', function (done) {
+            assert.deepEqual([{
+                messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                },
+                text: 'testb'
+            }], alLogFilter.filterJson(msgJson, '[{"messageB":{"childTestMsg":"childTest"}}, {"messageC":{"childTestMsgT": "childTest","childTestValue":{"messageC":"c"}}}]'));
+            return done();
+        });
+
+        it('Two condition match of same object for array based filtering on array of object with OR case', function (done) {
+            assert.deepEqual([{
+                messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                },
+                text: 'testb'
+            }], alLogFilter.filterJson(msgJson, '[{"messageB":{"childTestMsg":"childTest"}}, {"messageB":{"childTestValue":"childValue"}}]'));
+            return done();
+        });
+
+        it('three condition match of same object for array based filtering on array of object with OR case', function (done) {
+            assert.deepEqual([{
+                messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                },
+                text: 'testb'
+            }], alLogFilter.filterJson(msgJson, '[{"messageB":{"childTestMsg":"childTest"}}, {"messageB":{"childTestValue":"childValue"}}, {"text": "testb"}]'));
+            return done();
+        });
+
+        it('negative case for array based filtering on array of object with OR case', function (done) {
+            assert.deepEqual([{
+                messageB: {
+                    childTestMsg: 'childTest',
+                    childTestValue: 'childValue'
+                },
+                text: 'testb'
+            }], alLogFilter.filterJson(msgJson, '[{"messageB":{"childTestMsg":"childTest"}}, {"messageB":{"childTestValue":"childValue1"}}]'));
+            return done();
+        });
+    });
+});

package/test/al_log_test.js

@@ -54,8 +54,105 @@ describe('Unit Tests', function() {
                 return messagePayload;
             };
             var expectedPayload = 'eJzjamHi4izOLy1KTtXNTBGK5mLPyC8uATFFdm6e97ZBfLqW665Nbkkbdic+E771WoJByYJLhosvJz85MScepDQvMTdViEuKozg/NxXE5pLg4gSJx5dUFqQKcUtxJlaVFqXGp5XmSfkIHtV4Hc0ABLLcQEKJO9/YzLQ8NSkjPz/biCM3tbg4MT3V0Io/qzg/Tx+sTQ+kwknEEcR2TC7JLEt1ySxKTS7JL6okzjQjIk0DAFuCVYc=';
-            alLog.buildPayload('host-id', 'source-id', hml, msgs, parseFun, function(err, payload){
-                assert.equal(expectedPayload, payload.toString('base64'));
+            const params = {
+                    hostId: 'host-id',
+                    sourceId: 'source-id',
+                    hostmetaElems: hml,
+                    content: msgs,
+                    parseCallback: parseFun
+            };
+            alLog.buildPayload(params, function(err, payloadObject){
+                assert.equal(expectedPayload, payloadObject.payload.toString('base64'));
+                return done();
+            });
+        });
+
+        it('Sunny case with JSON filter', function(done) {
+            let hostTypeElem = {
+                key: 'host_type',
+                value: {str: 'azure_fun'}
+            };
+            let localHostnameElem = {
+                key: 'local_hostname',
+                value: {str: 'somename'}
+            };
+            let hml = [localHostnameElem, hostTypeElem];
+            let msgs = [
+                {message:'message1', prop: 'value1', filter: 'pass'},
+                {message:'message2', prop: 'value2'},
+                {message:'messagea', prop: 'valuea', filter: 'pass'}
+            ];
+            
+            let parseFun = function(m) {
+                let messagePayload = {
+                  messageTs: 1542138053,
+                  priority: 11,
+                  progName: 'o365webhook',
+                  pid: undefined,
+                  message: JSON.stringify(m),
+                  messageType: 'json/azure.o365',
+                  messageTypeId: 'AzureActiveDirectory',
+                  messageTsUs: undefined
+                };
+                
+                return messagePayload;
+            };
+            let expectedPayload = 'eJzjesDExVmcX1qUnKqbmSIUzcWekV9cAmKK7Nw8722D+HQt112b3JI27E58JnzrtQSDkgWXDBdfTn5yYk48SGleYm6qEJcUR3F+biqIzSXBxQkSjy+pLEgV4pbiTKwqLUqNTyvNk6oSPKrxOpoBCGS5gYQSd76xmWl5alJGfn62kVm1Um5qcXFieqqSFYxlqKSjVFCUXwAUKUvMKQXz0zJzSlKLgCIFicXFSrVW/FnF+Xn6YEv0QOY5iTiC2I7JJZllqS6ZRanJJflFlaTbnYhmdyLZdgMAFp90iA==';
+            const params = {
+                    hostId: 'host-id',
+                    sourceId: 'source-id',
+                    hostmetaElems: hml,
+                    content: msgs,
+                    parseCallback: parseFun,
+                    filterJson: {filter: 'pass'}
+            };
+            alLog.buildPayload(params, function(err, payloadObject){
+                assert.equal(expectedPayload, payloadObject.payload.toString('base64'));
+                return done();
+            });
+        });
+
+        it('Sunny case with regexp filter', function(done) {
+            let hostTypeElem = {
+                key: 'host_type',
+                value: {str: 'azure_fun'}
+            };
+            let localHostnameElem = {
+                key: 'local_hostname',
+                value: {str: 'somename'}
+            };
+            let hml = [localHostnameElem, hostTypeElem];
+            let msgs = [
+                'message1',
+                'message2',
+                'messagea'
+            ];
+            
+            let parseFun = function(m) {
+                let messagePayload = {
+                  messageTs: 1542138053,
+                  priority: 11,
+                  progName: 'o365webhook',
+                  pid: undefined,
+                  message: m,
+                  messageType: 'json/azure.o365',
+                  messageTypeId: 'AzureActiveDirectory',
+                  messageTsUs: undefined
+                };
+                
+                return messagePayload;
+            };
+            let expectedPayload = 'eJzjamHi4izOLy1KTtXNTBGK5mLPyC8uATFFdm6e97ZBfLqW665Nbkkbdic+E771WoJByYJLhosvJz85MScepDQvMTdViEuKozg/NxXE5pLg4gSJx5dUFqQKcUtxJlaVFqXGp5XmSfkIHtV4Hc0ABLLcQEKJO9/YzLQ8NSkjPz/biCM3tbg4MT3V0Io/qzg/Tx+sTQ+kwknEEcR2TC7JLEt1ySxKTS7JL6okzjQjIk0DAFuCVYc=';
+            const params = {
+                    hostId: 'host-id',
+                    sourceId: 'source-id',
+                    hostmetaElems: hml,
+                    content: msgs,
+                    parseCallback: parseFun,
+                    filterRegexp: 'message[0-9]'
+            };
+            alLog.buildPayload(params, function(err, payloadObject){
+                assert.equal(expectedPayload, payloadObject.payload.toString('base64'));
                 return done();
             });
         });
@@ -91,7 +188,15 @@ describe('Unit Tests', function() {
                 messagePayload.message = JSON.stringify(messagePayload);
                 return messagePayload;
             };
-            alLog.buildPayload('host-id', 'source-id', hml, msgs, parseFun, function(err, payload){
+            
+            const params = {
+                    hostId: 'host-id',
+                    sourceId: 'source-id',
+                    hostmetaElems: hml,
+                    content: msgs,
+                    parseCallback: parseFun
+            };
+            alLog.buildPayload(params, function(err, payload){
                 sinon.match(err, 'Maximum payload size exceeded');
                 return done();
             });
@@ -125,7 +230,15 @@ describe('Unit Tests', function() {
                 
                 return messagePayload;
             };
-            alLog.buildPayload('host-id', 'source-id', hml, msgs, parseFun, function(err, payload){
+            
+            const params = {
+                    hostId: 'host-id',
+                    sourceId: 'source-id',
+                    hostmetaElems: hml,
+                    content: msgs,
+                    parseCallback: parseFun
+            };
+            alLog.buildPayload(params, function(err, payload){
                 assert.equal(err, 'elem.key: string expected');
                 return done();
             });
@@ -156,7 +269,15 @@ describe('Unit Tests', function() {
                 
                 return messagePayload;
             };
-            alLog.buildPayload('host-id', 'source-id', hml, msgs, parseFun, function(err, payload){
+            
+            const params = {
+                    hostId: 'host-id',
+                    sourceId: 'source-id',
+                    hostmetaElems: hml,
+                    content: msgs,
+                    parseCallback: parseFun
+            };
+            alLog.buildPayload(params, function(err, payload){
                 assert.equal(err, 'messageTs: integer|Long expected');
                 return done();
             });

package/test/azcollectc_test.js

@@ -207,7 +207,6 @@ describe('Unit Tests', function() {
             
             fakePost = sinon.stub(AzcollectC.prototype, 'post').callsFake(
                 function fakeFn(path, options) {
-                    console.log('!!!!FAKE POST', path);
                     return new Promise(function(resolve, reject) {
                         resolve('ok');
                     });