notification-processor 4.20.0 → 4.21.1

package/.node-version

@@ -0,0 +1 @@
+12.22.12

package/lib/observers/monitoringCenter.observer.js

@@ -40,7 +40,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
       _classCallCheck(this, MonitoringCenterObserver);
 
-      this.uploadTrackingFile = this.uploadTrackingFile.bind(this);
+      this.registerRecord = this.registerRecord.bind(this);
       this.sender = sender;
       this.clientId = clientId;
       this.app = app1;
@@ -57,25 +57,25 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         var _this = this;
 
         observable.on("unsuccessful_non_retryable", function (payload) {
-          return _this.uploadTrackingFile(payload, "unsuccessful_non_retryable");
+          return _this.registerRecord(payload, "unsuccessful");
         });
         observable.on("unsuccessful", function (payload) {
-          return _this.uploadTrackingFile(payload, "unsuccessful");
+          return _this.registerRecord(payload, "unsuccessful");
         });
         observable.on("started", function (payload) {
-          return _this.uploadTrackingFile(payload, "pending");
+          return _this.registerRecord(payload, "pending");
         });
         return observable.on("successful", function (payload) {
-          return _this.uploadTrackingFile(payload, "successful");
+          return _this.registerRecord(payload, "successful");
         });
       }
     }, {
-      key: "uploadTrackingFile",
-      value: function uploadTrackingFile(payload, executionStatus) {
+      key: "registerRecord",
+      value: function registerRecord(payload, executionStatus) {
         var _this2 = this;
 
         return this._mapper(_.merge({ executionStatus: executionStatus }, payload)).tap(function (record) {
-          return debug("Record to save in firehose %j", record);
+          return debug("Record to save in firehose %s %j", _this2.deliveryStream, record);
         }).then(function (record) {
           var __uploadToFirehose, uploadParams;
           if (_.isEmpty(record)) {
@@ -87,17 +87,17 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
               Data: JSON.stringify(record)
             }
           };
-          debug("Uploading file " + record.event + "/" + record.id + " to firehose delivery stream " + uploadParams.DeliveryStreamName);
+          debug("Uploading record " + record.event + "/" + record.id + " to firehose delivery stream " + uploadParams.DeliveryStreamName);
           __uploadToFirehose = function __uploadToFirehose() {
             return _this2.uploadToFirehose(uploadParams);
           };
           return retry(__uploadToFirehose, {
             throw_original: true
           }).tap(function () {
-            return debug("Uploaded file " + record.event + "/" + record.id + " to firehose delivery stream " + uploadParams.DeliveryStreamName);
+            return debug("Uploaded record " + record.event + "/" + record.id + " to firehose delivery stream " + uploadParams.DeliveryStreamName);
           }).catch(function (e) {
             // We'll do nothing with this error
-            return debug("Error uploading file " + record.event + "/" + record.id + " to firehose delivery stream " + uploadParams.DeliveryStreamName + " %o", e);
+            return debug("Error uploading record " + record.event + "/" + record.id + " to firehose delivery stream " + uploadParams.DeliveryStreamName + " %o", e);
           });
         });
       }

package/lib/processor.js

@@ -70,7 +70,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
       value: function process(context, raw) {
         var _this2 = this;
 
-        var $promise, execute, id, notification;
+        var $promise, _isIgnoredError, execute, id, notification;
         boundMethodCheck(this, Processor);
         id = uuid();
         notification = this.source.newNotification({
@@ -94,9 +94,12 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
             });
           });
         };
+        _isIgnoredError = function _isIgnoredError(error) {
+          return error instanceof IgnoredError;
+        };
         execute().tap(function () {
           return _this2._emitEvent("successful", { context: context, id: id, notification: notification });
-        }).catch(IgnoredError, function (error) {
+        }).catch(_isIgnoredError, function (error) {
           return _this2._emitEvent("successful", {
             context: context,
             id: id,

package/lib/processors/job/index.js

@@ -15,16 +15,20 @@
         notificationApiUrl = _ref.notificationApiUrl,
         maxRetries = _ref.maxRetries,
         _ref$nonRetryable = _ref.nonRetryable,
-        nonRetryable = _ref$nonRetryable === undefined ? [400] : _ref$nonRetryable;
+        nonRetryable = _ref$nonRetryable === undefined ? [400] : _ref$nonRetryable,
+        _ref$silentErrors = _ref.silentErrors,
+        silentErrors = _ref$silentErrors === undefined ? [] : _ref$silentErrors;
 
     var jobProcesor;
     jobProcesor = new JobProcessor({
       processor: RequestAsyncProcessor({
         apiUrl: apiUrl,
-        fullResponse: true
+        fullResponse: true,
+        silentErrors: silentErrors
       }),
       maxRetries: maxRetries,
       nonRetryable: nonRetryable,
+      silentErrors: silentErrors,
       notificationApiUrl: notificationApiUrl
     });
     return function (it, context, executionId) {

package/lib/processors/job/job.processor.js

@@ -56,6 +56,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
       _this.notificationApiUrl = args.notificationApiUrl;
       _this.notificationApiAsyncUrl = args.notificationApiAsyncUrl;
       _this.nonRetryable = args.nonRetryable;
+      _this.silentErrors = args.silentErrors;
       return _this;
     }
 

package/lib/processors/maxRetries.processor.js

@@ -6,7 +6,11 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 // Generated by CoffeeScript 2.7.0
 (function () {
-  var MaxRetriesProcessor;
+  var IgnoredError, MaxRetriesProcessor, Promise;
+
+  Promise = require("bluebird");
+
+  IgnoredError = require("../exceptions/ignored.error");
 
   module.exports = MaxRetriesProcessor = function () {
     function MaxRetriesProcessor(_ref) {
@@ -16,6 +20,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
       _classCallCheck(this, MaxRetriesProcessor);
 
+      this._onIgnoredError_ = this._onIgnoredError_.bind(this);
       this.processor = processor;
       this.maxRetries = maxRetries;
     }
@@ -28,6 +33,9 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         return this.processor(notification, context, executionId).tap(function (it) {
           return _this._onSuccess_(notification, it);
         }).catch(function (err) {
+          if (_this._isIgnoredError_(err)) {
+            return _this._onIgnoredError_(notification, err);
+          }
           if (_this._shouldRetry_(notification, err)) {
             throw _this._sanitizeError_(err);
           }
@@ -57,6 +65,22 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       value: function _onMaxRetryExceeded_(notification, err) {
         throw new Error("subclass responsability");
       }
+    }, {
+      key: "_onIgnoredError_",
+      value: function _onIgnoredError_(notification, err) {
+        var _this2 = this;
+
+        return Promise.try(function () {
+          return _this2._onSuccess_(notification, err);
+        }).tap(function () {
+          throw err;
+        });
+      }
+    }, {
+      key: "_isIgnoredError_",
+      value: function _isIgnoredError_(err) {
+        return err instanceof IgnoredError;
+      }
     }]);
 
     return MaxRetriesProcessor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notification-processor",
-  "version": "4.20.0",
+  "version": "4.21.1",
   "description": "notification-processor",
   "main": "index.js",
   "scripts": {