@alertlogic/al-collector-js 3.0.6 → 3.0.8

package/Makefile

@@ -20,6 +20,7 @@ clean:
 	rm -rf node_modules
 	rm -f package-lock.json
 	rm -f test/report.xml
+	rm -f *.report.xml
 	rm -rf ./coverage/
 
 publish:

package/README.md

@@ -25,7 +25,9 @@ const {
     AzcollectC,
     EndpointsC,
     AlLog,
-    Parse 
+    Parse ,
+    RestServiceClient,
+    CollectorStatusC
 } = require('@alertlogic/al-collector-js');
 ```
 
@@ -90,6 +92,14 @@ const azCollectClient = new AzcollectC(apiEndpoint, aimsCreds, collectorType, se
 ```javascript
 const alEndpointsClient = EndpointsC(apiEndpoint, aimsCreds, retryOption);
 ```
+## CollectorStatusC
+* @param {string} apiEndpoint - Alert Logic API hostname.
+* @param {Object} aimsCreds - Alert Logic API credentials object, refer to AimsC.
+* @param {*} retryOptions.
+
+```javascript
+const alCollectorStatusClient = CollectorStatusC(apiEndpoint, aimsCreds, retryOption);
+```
 
 ## AlLog
 *  @param hostId - host uuid obtained at collector registration

package/al_log.js

@@ -185,7 +185,7 @@ function buildHostmeta({hostId, hostmetaElems}, callback) {
             let meta = {
                 hostUuid : hostId,
                 data : hostmetaData,
-                dataChecksum : new Buffer('')
+                dataChecksum : Buffer.from('')
             };
             let sha = crypto.createHash('sha1');
             let hashPayload = hostmetaType.encode(meta).finish();

package/al_servicec.js

@@ -34,7 +34,7 @@ class AimsC extends m_alUtil.RestServiceClient {
         super(apiEndpoint, retryOptions);
         this._cid = cid;
         this._aimsAuth = {
-            user: aimsCreds.access_key_id,
+            username: aimsCreds.access_key_id,
             password: aimsCreds.secret_key
         };
         var cache = cacheDir ? cacheDir : DEFAULT_CACHE_DIR;

package/al_util.js

@@ -7,9 +7,10 @@
  * @end
  * -----------------------------------------------------------------------------
  */
-
-const rp = require('request-promise-native');
+const axios = require('axios');
 const retry = require('retry');
+const http = require('http');
+const https = require('https');
 
 let MAX_CONNS_PER_SERVICE = 128;
 
@@ -22,18 +23,26 @@ let DEFAULT_RETRY = {
     factor: 7,
     minTimeout: 300,
     retries: 2,
-    maxTimeout: 10000
+    maxTimeout: 10000,
+    maxRetryTime: 180000
+};
+
+/**
+ * @default Refer to httpAgent and httpAgents axios
+ */
+let DEFAULT_HTTP_HTTPS_AGENT_CONFIG = {
+    keepAlive: true,
+    maxSockets: MAX_CONNS_PER_SERVICE,   // Maximum number of sockets to open
 };
 
+
 /**
- * @function Default retry callback. 
- *  It doesn't retry 2XX, 3XX and 4XX.
+ * @function Default retry callback.
+ *  It doesn't retry 2XX, 3XX, and 4XX.
  *  Keeps retrying 5XX HTTP responses and any system level errors
  **/
-var defaultRetryCb = function(err){
-    if (err && 
-        (err.statusCode >= 500 ||
-        (err.error && err.error.errno))) {
+var defaultRetryCb = function (err) {
+    if (err && (err.status >= 500) || (err.response && err.response.status >= 500) || (err.errno)) {
         return true;
     } else {
         return false;
@@ -45,8 +54,7 @@ var defaultRetryCb = function(err){
  * Rest client.
  *
  * @constructor
- * @param {string} endpoint - hostname/address to sent HTTPS
- * requests to.
+ * @param {string} endpoint - hostname/address to sent HTTPS requests to.
  *
  */
 class RestServiceClient {
@@ -54,9 +62,6 @@ class RestServiceClient {
         'use strict';
         this._host = endpoint;
         this._url = 'https://' + endpoint;
-        this._pool = {
-            maxSockets: MAX_CONNS_PER_SERVICE
-        };
         if (retryOptions) {
             this._retryCb = retryOptions.retryCb ? retryOptions.retryCb : defaultRetryCb;
             delete retryOptions.retryCb;
@@ -72,40 +77,43 @@ class RestServiceClient {
         const defaultOptions = {
             method: method,
             url: this._url + path,
-            json: true,
             headers: {},
-            pool: this._pool
+            json: true,
+            httpAgent: new http.Agent(DEFAULT_HTTP_HTTPS_AGENT_CONFIG),
+            httpsAgent: new https.Agent(DEFAULT_HTTP_HTTPS_AGENT_CONFIG)
         };
         const options = Object.assign({}, defaultOptions, extra);
         const defaultHeaders = {
             'Accept': 'application/json'
         };
-        Object.assign(options.headers,
-                      defaultHeaders,
-                      extra.headers ? extra.headers : {});
+        if (!options.data || options.body) {
+            options.data = options.body;
+        }
+        Object.assign(options.headers, defaultHeaders, extra.headers ? extra.headers : {});
         return options;
     }
+
     request(method, path, extraOptions) {
         'use strict';
         const options = this._initRequestOptions(method, path, extraOptions);
         const retryOptions = this._retryOptions;
         var retryCb = this._retryCb;
-        
+
         var operation = retry.operation(retryOptions);
-        
-        return new Promise(function(resolve, reject) {
-            operation.attempt(function(currentAttempt) {
-                rp(options)
-                    .then( resp => {
-                        // We need opertaion.retry here as we want to check if
+
+        return new Promise(function (resolve, reject) {
+            operation.attempt(function (currentAttempt) {
+                axios(options)
+                    .then(resp => {
+                        // We need operation.retry here as we want to check if
                         // the maximum amount of retries has been reached
                         if (retryCb(resp) && operation.retry('retry')) {
                             return;
                         } else {
-                            return resolve(resp);
+                            return resolve(resp.data);
                         }
                     })
-                    .catch( err =>{
+                    .catch(err => {
                         if (retryCb(err) && operation.retry(err)) {
                             return;
                         } else {
@@ -115,21 +123,27 @@ class RestServiceClient {
             });
         });
     }
+
     post(path, extraOptions) {
         return this.request('POST', path, extraOptions);
     }
+
     get(path, extraOptions) {
         return this.request('GET', path, extraOptions);
     }
+
     deleteRequest(path, extraOptions) {
         return this.request('DELETE', path, extraOptions);
     }
+
     put(path, extraOptions) {
         return this.request('PUT', path, extraOptions);
     }
+
     get host() {
         return this._host;
     }
+
     get url() {
         return this._url;
     }
@@ -138,4 +152,3 @@ class RestServiceClient {
 module.exports = {
     RestServiceClient: RestServiceClient
 };
-

package/collector_statusc.js

@@ -31,7 +31,9 @@ class CollectorStatusC extends AlServiceC {
             },
             body: data
         };
-        return this.put(`/statuses/${statusId}/streams/${stream}`, payload);
+        // Few collector stream contain `/` which not excepted by collectors_status service. so Encode the stream before making the api call.It will encodes special characters including: , / ? : @ & = + $ # 
+        const encodedStream = encodeURIComponent(stream);
+        return this.put(`/statuses/${statusId}/streams/${encodedStream}`, payload);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alertlogic/al-collector-js",
-  "version": "3.0.6",
+  "version": "3.0.8",
   "license": "MIT",
   "description": "Alert Logic Collector Common Library",
   "repository": {
@@ -20,26 +20,25 @@
     }
   ],
   "devDependencies": {
-    "jshint": "^2.9.5",
+    "jshint": "^2.13.6",
     "mocha": "^10.2.0",
-    "mocha-jenkins-reporter": "^0.4.2",
-    "nock": "^13.2.9",
+    "mocha-jenkins-reporter": "^0.4.8",
+    "nock": "^13.3.2",
     "nyc": "^15.1.0",
-    "rewire": "^5.0.0",
-    "sinon": "^15.0.1",
-    "timekeeper": "^2.2.0"
+    "rewire": "^6.0.0",
+    "sinon": "^15.2.0",
+    "timekeeper": "^2.3.1"
   },
   "dependencies": {
-    "async": "^3.2.4",
-    "debug": "^4.3.4",
+    "async": "3.2.4",
+    "axios": "^1.4.0",
+    "debug": "4.3.4",
     "lodash.clonedeep": "^4.5.0",
     "lodash.filter": "^4.6.0",
     "lodash.remove": "^4.7.0",
-    "moment": "^2.29.4",
-    "protobufjs": "^7.1.2",
-    "request": "^2.88.2",
-    "request-promise-native": "^1.0.9",
-    "retry": "^0.13.1"
+    "moment": "2.29.4",
+    "protobufjs": "^7.2.4",
+    "retry": "0.13.1"
   },
   "author": "Alert Logic Inc."
 }

package/test/al_mock.js

@@ -16,7 +16,7 @@ const AIMS_CREDS = {
 
 const AIMS_AUTH = {
     auth : {
-        user: AIMS_CREDS.access_key_id,
+        username: AIMS_CREDS.access_key_id,
         password: AIMS_CREDS.secret_key
     }
 };
@@ -159,6 +159,10 @@ const AIMS_RESPONSE_200 = {
           }
         };
 
+const SERVER_ERROR_500 = {
+    statusCode: 500,
+    message: "Internal Server Error"
+};
 function gen_auth_response() {
     return {
         authentication : {
@@ -188,6 +192,7 @@ module.exports = {
     AZURE_CHECKIN_VALUES: AZURE_CHECKIN_VALUES,
     SEND_COLLECTOR_STATUS_BODY_DATA: SEND_COLLECTOR_STATUS_BODY_DATA,
     COLLECTOR_STATUS_API: COLLECTOR_STATUS_API,
+    SERVER_ERROR_500: SERVER_ERROR_500,
 
     gen_auth_response : gen_auth_response
 };

package/test/al_util_test.js

@@ -132,5 +132,51 @@ describe('Unit Tests', function() {
             done();
         });
 
+        it('check it should return server error after retry', function (done) {
+            var restC = new RestServiceClient(m_alMock.AL_API);
+
+            nock('https://' + m_alMock.AL_API, {
+                reqheaders: {
+                    'accept': 'application/json',
+                    'host': m_alMock.AL_API,
+                    'some_header': 'some_value'
+                }
+            })
+                .post(TEST_PATH, TEST_BODY)
+                .reply(500, m_alMock.SERVER_ERROR_500);
+
+            restC.post(TEST_PATH, {
+                headers: { 'some_header': 'some_value' },
+                data: TEST_BODY
+            })
+                .catch(err => {
+                    console.log(`err ${err}`);
+                    done();
+                });
+        });
+
+        it('check it should success if last response is successful after server error 500', function (done) {
+            var restC = new RestServiceClient(m_alMock.AL_API);
+            var restMock = nock('https://' + m_alMock.AL_API, {
+                reqheaders: {
+                    'accept': 'application/json',
+                    'host': m_alMock.AL_API,
+                    'content-type': 'application/json',
+                    'some_header': 'some_value'
+                }
+            })
+                .post(TEST_PATH, TEST_BODY)
+                .reply(500, m_alMock.SERVER_ERROR_500)
+                .post(TEST_PATH, TEST_BODY)
+                .reply(200, m_alMock.AIMS_RESPONSE_200);
+
+            restC.post(TEST_PATH, {
+                headers: { 'some_header': 'some_value' },
+                body: TEST_BODY
+            }).then(res => {
+                assert.ok(restMock.isDone());
+                done();
+            });
+        });
     });
 });

package/test/collector_statusc_test.js

@@ -54,6 +54,24 @@ describe('Unit Tests', function () {
             });
         });
 
+        it('it should encode the stream if it contain special char', function (done) {
+            let stream = 'projects/appliance-builds';
+            const encodedStream = encodeURIComponent(stream);
+            fakePut = sinon.stub(AlServiceC.prototype, 'put').callsFake(
+                function fakeFn(path, extraOptions) {
+                    assert.equal(extraOptions.body, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA);
+                    assert.equal(path, `/statuses/${m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.status_id}/streams/${encodedStream}`);
+                    done();
+                });
+
+            var aimsc = new AimsC(m_alMock.AL_API, m_alMock.AIMS_CREDS);
+            var collectorStatus = new CollectorStatusC(m_alMock.COLLECTOR_STATUS_API, aimsc);
+            m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.stream = stream;
+            collectorStatus.sendStatus(m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.status_id, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.stream, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA).then(res => {
+                fakePut.restore();
+            });
+        });
+
         it('If sequence of parameter is not correct then api throw the error', function (done) {
             const error = {
                 "errorinfo": {

package/test/parse_test.js

@@ -129,10 +129,10 @@ describe('Common parse functions unit tests.', function() {
         done();
     });
     
-    it('Wrong timestamp input', function(done) {
-        var privParseTs = parseWire.__get__('parseTs');
-        assert.deepEqual(privParseTs('foo'), {sec: 1234567, usec: null});
-        
+    it('Wrong timestamp input', function (done) {
+        let parseWire1 = rewire('../parse');
+        var privParseTs = parseWire1.__get__('parseTs');
+        assert.deepEqual(privParseTs('foo'), { sec: 1234567, usec: null });
         done();
     });
     

package/test/request_retry_test.js

@@ -14,6 +14,7 @@ const nock = require('nock');
 const m_alMock = require('./al_mock');
 const m_alService = require('../al_servicec');
 const EndpointsC = require('../al_servicec').EndpointsC;
+const moment = require('moment');
 
 describe('HTTP request retry tests', function() {
     beforeEach(function(done) {
@@ -79,7 +80,7 @@ describe('HTTP request retry tests', function() {
         var endpointsC = new EndpointsC(m_alMock.AL_API, aimsc, 'cwe');
 
         endpointsC.getEndpoint('azcollect', 'default').then( resp => {
-            assert.equal(resp, undefined);
+            assert.equal(resp, '');
             done();
         });
     });
@@ -134,7 +135,8 @@ describe('HTTP request retry tests', function() {
                 return done();
             })
             .catch(err => {
-                assert.equal(err.statusCode, 401);
+                assert.equal(err.code , 'ERR_BAD_REQUEST');
+                assert.equal(err.response.status , 401);
                 return done();
             });
     });
@@ -147,7 +149,7 @@ describe('HTTP request retry tests', function() {
             .post('/aims/v1/authenticate')
             .reply(201, m_alMock.AIMS_RESPONSE_200);
         var customRetry = function(resp) {
-            if (resp.retryCode === customRetryCode) {
+            if (resp.data.retryCode === customRetryCode) {
                 return true;
             } else {
                 return false;
@@ -177,7 +179,7 @@ describe('HTTP request retry tests', function() {
             .post('/aims/v1/authenticate')
             .reply(201, m_alMock.AIMS_RESPONSE_200);
         var customRetry = function(resp) {
-            if (resp.error.customError === customRetryCode) {
+            if (resp.customError === customRetryCode) {
                 return false;
             } else {
                 return true;
@@ -198,7 +200,36 @@ describe('HTTP request retry tests', function() {
                 return done();
             })
             .catch(err =>{
-                assert.equal(err.error.customError, customRetryCode);
+                assert.equal(err.customError, customRetryCode);
+                return done();
+            });
+    });
+
+    it('Retry 500 with custom retry config with maxRetryTime', function (done) {
+        const maxRetryTime = 1500;
+        const retryOptions = {
+            retries: 3,
+            factor: 2,
+            minTimeout: 300,
+            maxTimeout: 1000,
+            maxRetryTime: maxRetryTime,
+        };
+        nock('https://' + m_alMock.AL_API)
+            .post('/aims/v1/authenticate')
+            .times(4)
+            .reply(500, m_alMock.SERVER_ERROR_500);
+        var startTime = moment();
+        var aimsc = new m_alService.AimsC(
+            m_alMock.AL_API, m_alMock.AIMS_CREDS, '/tmp', retryOptions);
+        aimsc.authenticate()
+            .catch(err => {
+                assert.equal(err.response.status, 500);
+                var nowMoment = moment();
+                const elapsedTime = nowMoment.diff(startTime, 'milliseconds');
+                assert.ok(
+                    elapsedTime >= maxRetryTime && elapsedTime <= maxRetryTime + retryOptions.maxTimeout,
+                    'Test case failed: Request did not complete within maxRetryTime.'
+                );
                 return done();
             });
     });