@alertlogic/al-collector-js 3.0.0 → 3.0.1

package/al_log_filter.js

@@ -7,16 +7,22 @@
  * @end
  * -----------------------------------------------------------------------------
  */
-const where = require('lodash.where');
+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, '{"a": 1}', {a:1}
- *  
+ *
+ *  @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) {
+var initJsonFilter = function (filter) {
     if (typeof filter === 'string') {
         try {
             return JSON.parse(filter);
@@ -38,10 +44,24 @@ var initJsonFilter = function(filter) {
  *  @NOTE: If json filter  is bad then 'messages' is returned unfiltered.
  */
 
-var filterJson = function(messages, filter) {
+var filterJson = function (messages, filter) {
     const filterJ = initJsonFilter(filter);
     if (filterJ) {
-        return where(messages, 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;
     }
@@ -54,7 +74,7 @@ var filterJson = function(messages, filter) {
  *  
  *  @return filter - inited regexp or null if regexp is incorrect
  */
-var initRegExpFilter = function(filter) {
+var initRegExpFilter = function (filter) {
     if (typeof filter === 'string') {
         try {
             return new RegExp(filter);
@@ -76,10 +96,12 @@ var initRegExpFilter = function(filter) {
  *  @NOTE: If regexp filter is bad then 'messages' is returned unfiltered.
  */
 
-var filterRegExp = function(messages, filter) {
+var filterRegExp = function (messages, filter) {
     const re = initRegExpFilter(filter);
     if (re) {
-        return messages.filter(function(m) { return re.test(m); });
+        return messages.filter(function (m) {
+            return re.test(m);
+        });
     } else {
         return messages;
     }
@@ -87,9 +109,9 @@ var filterRegExp = function(messages, filter) {
 
 
 module.exports = {
-    filterJson : filterJson,
-    filterRegExp : filterRegExp,
-    initRegExpFilter : initRegExpFilter,
-    initJsonFilter : initJsonFilter
+    filterJson: filterJson,
+    filterRegExp: filterRegExp,
+    initRegExpFilter: initRegExpFilter,
+    initJsonFilter: initJsonFilter
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alertlogic/al-collector-js",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "license": "MIT",
   "description": "Alert Logic Collector Common Library",
   "repository": {
@@ -32,7 +32,9 @@
   "dependencies": {
     "async": "3.1.0",
     "debug": "4.1.1",
-    "lodash.where": "^3.1.0",
+    "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

@@ -11,15 +11,9 @@
 const assert = require('assert');
 const alLogFilter = require('../al_log_filter');
 
-
 describe('Unit Tests', function() {
     describe('Filter Messages', function() {
-        
-        const msgJson = [
-            { message1: 1, text: 'test1' },
-            { message2: 2, text: 'test12'},
-            { messageA: "a", text: 'testa'},
-        ];
+        let msgJson = [];
         const msgString = [
             'message1',
             'message2',
@@ -27,6 +21,27 @@ describe('Unit Tests', function() {
         ];
         
         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() {
         });
@@ -48,11 +63,97 @@ describe('Unit Tests', function() {
             return done();
         });
         
-        it('Undefined filters', function(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();
+        });
     });
 });