scheduled delay changed

Author: alexk-blackops

.gitignore

@@ -1,4 +1,5 @@
 node_modules
 npm-debug.log
 proxy.js
-proxy2.js
+proxy2.js
+new.js

config/config.js

@@ -1,20 +1,27 @@
 module.exports = {
-    'PROTOCOL' : 'https',
-    'HOST': 'dev.stackify.com',
-    'PORT': 443,
-    'IDENTIFY_PATH': '/API/Metrics/IdentifyApp',
-    'LOG_SAVE_PATH': '/API/Log/Save',
-    'MSG_LIMIT': 100, // number of messages per batch
-    'MSG_CAP': 10000, // overall messages cap in the queue
-    'SCAN_TIMER': 30 * 1000,
-    'REQUEST_TIMER': 5 * 1000,
-    'REQUEST_ATTEMPTS': 5, // number of attempts if API call isn't succesful
-    /**
-     * Number of instances of a unique error that are allowed to be sent in one minute 
-     */
-    'MAX_DUP_ERROR_PER_MINUTE': 5,
+    PROTOCOL               : 'https',
+    HOST                   : 'dev.stackify.com',
+    PORT                   : 443,
+    IDENTIFY_PATH          : '/API/Metrics/IdentifyApp',
+    LOG_SAVE_PATH          : '/API/Log/Save',
+    // possible delay values in millis
+    DELAY: {
+        ONE_SECOND_DELAY   : 1000,
+        FIVE_SECONDS_DELAY : 5000,
+        ONE_MINUTE_DELAY   : 60000,
+        FIVE_MINUTES_DELAY : 300000,
+    },
+    MSG: {
+        QUEUE_CAP          : 10000, // overall messages cap in the queue
+        // minimum and maximum batch sizes
+        MIN_BATCH_SIZE     : 10,
+        MAX_BATCH_SIZE     : 100,
+        // Number of instances of a unique error that are allowed to be sent in one minute 
+        MAX_DUP_ERROR_PER_MINUTE: 5,
+    }, 
+    IDENTIFY_DELAY: 300000, // 5 minutes delay if identifyApp call failed
     /**
      * Cookie value 
      */
-    'COOKIE_MASK': 'X-MASKED-X'
+    COOKIE_MASK: 'X-MASKED-X'
 };

index.js

@@ -10,8 +10,8 @@ module.exports = {
 
     start: function(options) {
         api.methods.identifyApp(options);
-        exc.exc();
-    },
+/*        exc.exc();
+*/    },
 
     log: logger.methods.log,
     trace: logger.methods.trace,

lib/api.js

@@ -8,7 +8,9 @@ var os      = require('os'),
 
     pkginfo = require('pkginfo')(module, 'name'),
 
-    appname = module.exports.name, //name of the app from package.json
+    appname = module.exports.name, // name of the app from package.json
+    fail_delay = 0, // scheduled delay when postLogs call failed
+    last_api_error, 
 
     //getting all the headers for requests
     options = function options(path, body, proxy) {
@@ -32,7 +34,7 @@ var os      = require('os'),
         return result;
 
     };
-
+module.exports.last_api_error = last_api_error;
 module.exports.methods = {
 
     identifyApp: function identifyApp(settings) {
@@ -43,23 +45,19 @@ module.exports.methods = {
                 AppLocaton: process.env.PWD
             },
             opt = options(CONFIG.IDENTIFY_PATH, body, settings ? settings.proxy : undefined),
-            fail_counter = 0,
             callback = function (data) {
                 console.log('successfully identified');
 
                 CONFIG.APP_DETAILS = data;
                 CONFIG.APIKEY = settings.apiKey;
 
-                logger.methods.init();
+                logger.methods.send();
 
             },
             fail = function () {
-                fail_counter += 1;
-                if (fail_counter <= CONFIG.REQUEST_ATTEMPTS) {
-                    setTimeout(function () {
-                        send(opt, callback, fail);
-                    }, CONFIG.REQUEST_TIMER);
-                }
+                setTimeout(function () {
+                    send(opt, callback, fail);
+                }, CONFIG.IDENTIFY_DELAY);
             };
 
         console.log('Identifying...');
@@ -80,7 +78,7 @@ module.exports.methods = {
 
     },
 
-    postLogs: function postLogs(messages, cb, fail) {
+    postLogs: function postLogs(messages, cb) {
         var body = {
                 CDID: CONFIG.APP_DETAILS.DeviceID,
                 CDAppID: CONFIG.APP_DETAILS.DeviceAppID,
@@ -95,7 +93,26 @@ module.exports.methods = {
                 Platform: 'Node.js',
                 Msgs : messages
             },
-            opt = options(CONFIG.LOG_SAVE_PATH, body, CONFIG.PROXY);
+            opt = options(CONFIG.LOG_SAVE_PATH, body, CONFIG.PROXY),
+
+            //retry the request if it failed
+            fail = function(code) {
+                var sinceFirstError;
+
+                if (code === 401) {
+                    fail_delay = CONFIG.DELAY.FIVE_MINUTES;
+                    last_api_error = new Date().getTime();
+                } else {
+                    last_api_error = last_api_error || new Date().getTime();
+                    sinceFirstError = new Date().getTime() - last_api_error;
+                    fail_delay = Math.min(Math.max(sinceFirstError, CONFIG.DELAY.ONE_SECOND), CONFIG.DELAY.ONE_MINUTE);
+                }
+
+                setTimeout(function () {
+                    send(opt, cb, fail);
+                }, fail_delay);
+  
+            };
 
         send(opt, cb, fail);
     }

lib/exception.js

@@ -9,38 +9,11 @@ var qs      = require('querystring'),
 
     // function that sends all the messages in the queue to Stackify when exception is caught
     handler = function handler(err, req, cb) {
-        var rec = {
-                Msg: err.name + ': ' + err.message,
-                Level: 'ERROR',
-                EpochMs: Date.now(),
-                Ex: error.formatEx(err, req)
-            },
-            fail_counter = 0,
-
-            cb = function () {
-                console.log('sent', util.inspect(logger.storage, {depth: null}));
-            }
-
-            //retry the request if it failed
-            fail = function () {
-                fail_counter += 1;
-                if (fail_counter < CONFIG.REQUEST_ATTEMPTS) {
-                    setTimeout(function () {
-                        api.methods.postLogs(logger.storage, null, fail);
-                    }, CONFIG.REQUEST_TIMER);
-                }
-            };
-
-        if (CONFIG.APP_DETAILS) {
-            console.log('handled');
-            logger.storage.push(rec);
-            api.methods.postLogs(logger.storage, cb, fail);
-        } else {
-            console.log('not identified yet');
-        }
+        logger.methods.push('error', err.message, {error: error}, req);
+        api.methods.postLogs(logger.storage, cb);
     };
 
-// flag used for not catching the same exception twice (inside and outside of the createServer method) 
+// flag used to prevent catching the same exception twice (inside and outside of the createServer method) 
 module.exports.excCaught = excCaught = false;
 
 module.exports = {

lib/logger.js

@@ -7,71 +7,60 @@ var util    = require('util'),
 
     storage = [],
 
-    // flag that indicates if logs are being sent right now. if false then new batches of messages won't be sent.
-    flag = false,
-    // deferred checking of logs
-    timeout = 0,
-    //number of failed attempts of sending logs
-    fail_counter = 0,
+    // current delay
+    delay   = CONFIG.DELAY.ONE_SECOND_DELAY,
+
     // hash that contains all the errors and their number logged during the current minute
     error_storage = {},
 
-    // automatically send all the messages from the queue after some timeout
-    checkLogs = function () {
-        var length = Math.min(storage.length, CONFIG.MSG_LIMIT);
-        if (flag && length) {
-            sendLogs(length);
-        }
-        console.log('logs checked');
-    },
     // handler for sending logs
-    sendLogs = function (length) {
-        var self = this,
-            data = storage.slice(0, length || CONFIG.MSG_LIMIT),
+    sendLogs = function () {
+        var length = storage.length,
+            chunk  = Math.min(length, CONFIG.MSG.MAX_BATCH_SIZE),
+            data   = storage.slice(0, chunk),
 
-            /* if request is succesful remove messages from the queue, change the timeout for the next checkLogs call,
-               switch the flag, send another batch (if there are enough messages in the queue)
+            /* if request is succesful remove messages from the queue,
+               send another batch (if there are enough messages in the queue)
             */
             success = function (response) {
-                fail_counter = 0;
+                storage = storage.slice(chunk); // remove this chunk from the queue
+                length -= chunk;
+                api.last_api_error = 0; // reset the last HTTP error
 
-                storage = storage.slice(length);
-                console.log('logs sent');
+                console.log(chunk, ' sent');
+                console.log(length, ' last');
 
-                // if there are enough messages for the batch, send another request
+                if (length) {
+                    chunk  = Math.min(length, CONFIG.MSG.MAX_BATCH_SIZE);
+                    data   = storage.slice(0, chunk);
 
-                if (storage.length >= CONFIG.MSG_LIMIT) {
-                    sendLogs();
+                    api.methods.postLogs(data, success);
                 } else {
-                    flag = true;
-
-                    // reset previous timeout, define the new one
-                    if (timeout) {
-                        clearTimeout(timeout);
-                    }
-
-                    timeout = setTimeout(checkLogs, CONFIG.SCAN_TIMER);
+                    console.log('all sent');
+                    // full batch is sent, set timeout for the next request
+                    setTimeout(sendLogs, delay);
                 }
-            },
-
-            // retry the attempt after some timeout
-            fail = function () {
-                flag = false;
-                fail_counter += 1;
-
-                setTimeout(function () {
-                    api.methods.postLogs(data, success, fail);
-                }, CONFIG.REQUEST_TIMER);
             };
 
-        if (fail_counter <= CONFIG.REQUEST_ATTEMPTS) {
-            api.methods.postLogs(data, success, fail);
-            flag = false;
+        // count the delay
+        if (length >= CONFIG.MSG.MAX_BATCH_SIZE) {
+            delay = Math.max(Math.round(delay / 2.0), CONFIG.DELAY.ONE_SECOND_DELAY);
+        } else {
+            delay = Math.min(Math.round(1.25 * delay), CONFIG.DELAY.FIVE_SECONDS_DELAY);
+        }
+
+        if (data.length && CONFIG.APIKEY) {
+            api.methods.postLogs(data, success);
+        } else {
+            console.log('no messages');
+            console.log('delay ', delay);
+            // queue is empty, set timeout for the next request
+            setTimeout(sendLogs, delay);
         }
     },
     /**
-    Check for duplicate error messages. If the same error message logged more than configurated limit in one minute
-    don't push it to the queue
+    * Check for duplicate error messages. If the same error message logged more than configurated limit in one minute
+    * don't push it to the queue
     */
     checkErrorLimitMessage = function checkErrorLimitMessage(ex) {
         var min = new Date().getMinutes(),
@@ -93,14 +82,14 @@ var util    = require('util'),
             error_storage[min][key] = 1;
         }
 
-        return (error_storage[min][key] < CONFIG.MAX_DUP_ERROR_PER_MINUTE) ? true : false;
+        return (error_storage[min][key] < CONFIG.MSG.MAX_DUP_ERROR_PER_MINUTE) ? true : false;
     };
 
 module.exports.storage = storage;
 
 module.exports.methods = {
     // create the message object, push it to the queue and execute sendLogs call if messages cap is exceeded
-    push : function push(level, msg, meta) {
+    push : function push(level, msg, meta, req) {
         var err = new Error(),
             getStack = error.getStackTraceItem(err),
             rec = {
@@ -117,7 +106,7 @@ module.exports.methods = {
             if (level.toLowerCase() === 'error') {
                 data = helpers.parseMeta(meta, true);
                 if (data.ex) {
-                    rec.Ex = error.formatEx(data.ex);
+                    rec.Ex = error.formatEx(data.ex, req);
                 }
             } else {
                 data = helpers.parseMeta(meta);
@@ -137,27 +126,16 @@ module.exports.methods = {
             console.log('logged', storage.length);
 
             // remove the earliest message from the queue if message cap is exceeded    
-            if (storage.length === CONFIG.MSG_CAP) {
+            if (storage.length === CONFIG.MSG.QUEUE_CAP) {
                 storage.shift();
             }
         }
-        
-        if (flag && storage.length >= CONFIG.MSG_LIMIT && CONFIG.APIKEY) {
-            sendLogs();
-        }
     },
 
-    /* check the queue after IdentifyApp call is done, switch the flag, set the timeout for the next checking the queue,
-       set environment details for already logged messages
+    /* check the queue after IdentifyApp call is done
     */
-    init: function init() {
-        flag = true;
-
-        timeout = setTimeout(checkLogs, CONFIG.SCAN_TIMER);
-
-        if (storage.length >= CONFIG.MSG_LIMIT) {
-            sendLogs(exc.excCaught ? storage.length : null);
-        }
+    send: function send() {
+        setTimeout(sendLogs, delay);
     },
 
     log: function log(level, msg, meta) {

lib/sender.js

@@ -7,22 +7,25 @@ Low level function for sending http/https requests
 var http    = require('http'),
     util    = require('util'),
 
-    request = require('request');
+    request = require('request'),
+
+    logger  = require('./logger');
 
 module.exports = function sender(options, cb, fail) {
 
     var callback = function (error, response, body) {
         if (!error) {
             if (response.statusCode === 200) {
                 if (cb) {
-                    cb(body);                }
+                    cb(body);               
+                }
             } else {
                 if (fail) {
-                    fail();
+                    fail(response.statusCode);
                 }
             }
         } else {
-            console.log(error);
+            logger.methods.push('error', error.message, {error: error});
         }
     };