@alertlogic/al-collector-js 3.0.5 → 3.0.7

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_util.js

@@ -15,6 +15,7 @@ let MAX_CONNS_PER_SERVICE = 128;
 
 /**
  * @default Refer to https://www.npmjs.com/package/retry
+ * set maxRetryTime to 180seconds(3min) to avoid lambda timeout.
  */
 let DEFAULT_RETRY = {
     // Default values
@@ -22,7 +23,8 @@ let DEFAULT_RETRY = {
     factor: 7,
     minTimeout: 300,
     retries: 2,
-    maxTimeout: 10000
+    maxTimeout: 10000,
+    maxRetryTime: 180000 // Maximum time to spend retrying in milliseconds.
 };
 
 /**
@@ -124,6 +126,9 @@ class RestServiceClient {
     deleteRequest(path, extraOptions) {
         return this.request('DELETE', path, extraOptions);
     }
+    put(path, extraOptions) {
+        return this.request('PUT', path, extraOptions);
+    }
     get host() {
         return this._host;
     }

package/collector_statusc.js

@@ -0,0 +1,42 @@
+/* -----------------------------------------------------------------------------
+ * @copyright (C) 2023, Alert Logic, Inc
+ * @doc
+ *
+ * HTTP client for Collector status service.
+ *
+ * @end
+ * -----------------------------------------------------------------------------
+ */
+'use strict';
+
+const AlServiceC = require('./al_servicec').AlServiceC;
+
+/**
+ * @class
+ * HTTPS client for Alert Logic Collector_status service.
+ *
+ * @constructor
+ * @param {string} apiEndpoint - Alert Logic API hostname.
+ * @param {Object} aimsCreds - Alert Logic API credentials object, refer to AimsC.
+ * @param {*} retryOptions
+ */
+class CollectorStatusC extends AlServiceC {
+    constructor(apiEndpoint, aimsCreds, retryOptions) {
+        super(apiEndpoint, 'collectors_status', 'v1', aimsCreds, retryOptions);
+    }
+    sendStatus(statusId, stream, data) {
+        let payload = {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: data
+        };
+        // 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);
+    }
+}
+
+module.exports = {
+    CollectorStatusC: CollectorStatusC
+};

package/index.js

@@ -16,6 +16,7 @@ module.exports = {
     EndpointsC : require('./al_servicec').EndpointsC,
     AlLog : require('./al_log'),
     Parse: require('./parse'),
-    RestServiceClient: require('./al_util').RestServiceClient
+    RestServiceClient: require('./al_util').RestServiceClient,
+    CollectorStatusC: require('./collector_statusc').CollectorStatusC
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alertlogic/al-collector-js",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "license": "MIT",
   "description": "Alert Logic Collector Common Library",
   "repository": {

package/test/al_mock.js

@@ -28,6 +28,7 @@ const CID = '12345678';
 
 const AL_API = 'al-api-endpoint.alertlogic.com';
 const INGEST_API = 'ingest-api-endpoint.alertlogic.com';
+const COLLECTOR_STATUS_API = 'collector-status-api-endpoint.alertlogic.com';
 
 const AWS_CHECKIN_URL = '/aws/cwe/checkin/1234567890/us-east-1/test-function';
 
@@ -94,6 +95,21 @@ const AZCOLLECT_CHECKIN_QUERY_COMPRESSED = {
     body : COMPRESSED_CHECKIN_BODY
 };
 
+const SEND_COLLECTOR_STATUS_BODY_DATA = {
+    status: "error",
+    inst_type: "collector",
+    stream: "Audit.Exchange",
+    status_id: "FC561097-E51D-4CB6-AB86-2A90CFFE60C7",
+    timestamp: 1685377308,
+    reported_by: "paws",
+    collection_type: "o365",
+    errorinfo: {
+        code: "500",
+        description: "server error",
+        details: "failed to send logmsgs"
+    }
+};
+
 const AIMS_RESPONSE_200 = {
         'authentication': {
             'user': {
@@ -143,6 +159,10 @@ const AIMS_RESPONSE_200 = {
           }
         };
 
+const SERVER_ERROR_500 = {
+    statusCode: 500,
+    message: "Internal Server Error"
+};
 function gen_auth_response() {
     return {
         authentication : {
@@ -170,6 +190,9 @@ module.exports = {
     AIMS_RESPONSE_200: AIMS_RESPONSE_200,
     AZURE_REGISTER_VALUES: AZURE_REGISTER_VALUES,
     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' },
+                body: 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

@@ -0,0 +1,164 @@
+/* -----------------------------------------------------------------------------
+ * @copyright (C) 2023, Alert Logic, Inc
+ * @doc
+ *
+ * Tests for base Alert Logic Collectors Status client
+ *
+ * @end
+ * -----------------------------------------------------------------------------
+ */
+
+const fs = require('fs');
+const sinon = require('sinon');
+const assert = require('assert');
+const AimsC = require('../al_servicec').AimsC;
+const AlServiceC = require('../al_servicec').AlServiceC;
+const m_alMock = require('./al_mock');
+const CollectorStatusC = require('../collector_statusc').CollectorStatusC;
+
+
+describe('Unit Tests', function () {
+
+    describe('Collector_statusc', function () {
+        var fakeAuth;
+        let fakePut;
+        beforeEach(function () {
+            fakeAuth = sinon.stub(AimsC.prototype, 'authenticate').callsFake(
+                function fakeFn() {
+                    return new Promise(function (resolve, reject) {
+                        resolve(m_alMock.gen_auth_response());
+                    });
+                });
+        });
+        afterEach(function (done) {
+            fakeAuth.restore();
+            fakePut.restore();
+            fs.unlink(m_alMock.CACHE_FILENAME, function (err) {
+                done();
+            });
+        });
+
+        it('Verify send Status called with correct parameter', function (done) {
+
+            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/${m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.stream}`);
+                    done();
+                });
+
+            var aimsc = new AimsC(m_alMock.AL_API, m_alMock.AIMS_CREDS);
+            var collectorStatus = new CollectorStatusC(m_alMock.COLLECTOR_STATUS_API, aimsc);
+            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('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": {
+                    "error_id": "246A66D0-2910-46E1-9C1F-24359B6714A0",
+                    "description": "Stream does not match payload",
+                    "code": "stream_mismatch"
+                }
+            };
+            fakePut = sinon.stub(AlServiceC.prototype, 'put').callsFake(
+                function fakeFn(path, extraOptions) {
+                    return new Promise(function (resolve, reject) {
+                        reject(error);
+                    });
+                });
+
+            var aimsc = new AimsC(m_alMock.AL_API, m_alMock.AIMS_CREDS);
+            var collectorStatus = new CollectorStatusC(m_alMock.COLLECTOR_STATUS_API, aimsc);
+            collectorStatus.sendStatus(m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.stream, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.status_id, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA).then(res => {
+            }).catch(err => {
+                assert.deepEqual(err, error);
+                done();
+            });
+        });
+
+        it('collection_type and inst_type value should be within the defined enum else throw error', function (done) {
+            const error = {
+                "errorinfo": {
+                    "error_id": "5BC87CAB-8CC7-4B36-9B09-3E26B3088F77",
+                    "details": {
+                        "schema_validation_error": [
+                            {
+                                "invalid": "data",
+                                "schema": {
+                                    "type": "string",
+                                    "enum": [
+                                        "o365",
+                                        "auth0",
+                                        "Carbonblack",
+                                        "Ciscoamp",
+                                        "Ciscoduo",
+                                        "crowdstrike",
+                                        "googlestackdriver",
+                                        "gsuite",
+                                        "Mimecast",
+                                        "salesforce",
+                                        "aws_elb_classic",
+                                        "s3_audit_logs",
+                                        "redshift_connection_logs",
+                                        "redshift_user_activity_logs",
+                                        "redshift_user_logs",
+                                        "vpc_flow_logs_v2",
+                                        "aws_elb_application",
+                                        "aws_elb_network",
+                                        "aws_network_firewall",
+                                        "carbon_black_edr",
+                                        "aws_eks_log_cwl_export",
+                                        "crowdstrike_fdr",
+                                        "aws_waf"
+                                    ]
+                                },
+                                "error": "not_in_enum",
+                                "data": "CiscoMeraki",
+                                "path": [
+                                    "collection_type"
+                                ]
+                            }
+                        ]
+                    },
+                    "description": "JSON Schema Validation error",
+                    "code": "schema_validation_error"
+                }
+            };
+            fakePut = sinon.stub(AlServiceC.prototype, 'put').callsFake(
+                function fakeFn(path, extraOptions) {
+                    return new Promise(function (resolve, reject) {
+                        reject(error);
+                    });
+                });
+
+            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.collection_type = 'CiscoMeraki';
+            collectorStatus.sendStatus(m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.stream, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA.status_id, m_alMock.SEND_COLLECTOR_STATUS_BODY_DATA).then(res => {
+            }).catch(err => {
+                assert.deepEqual(err.code, error.code);
+                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) {
@@ -202,4 +203,33 @@ describe('HTTP request retry tests', function() {
                 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.statusCode, 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();
+            });
+    });
 });