Eslint

.eslintignore

+**/node_modules/*

.eslintrc.json

+{
+  "env": {
+    "commonjs": true,
+    "node": true
+  },
+  "plugins": [
+    "node"
+  ],
+  "extends": "eslint:recommended",
+  "rules": {
+    "no-console": "off",
+    "indent": "off",
+    "comma-dangle": "off",
+    "quotes": "off",
+    "eqeqeq": [
+      "warn",
+      "allow-null"
+    ],
+    "strict": [
+      "error",
+      "safe"
+    ],
+    "no-unused-vars": [
+      "warn"
+    ],
+    "no-extra-boolean-cast": [
+      "warn"
+    ],
+    "complexity": [
+      "error",
+      {
+        "max": 12
+      }
+    ],
+    "max-statements-per-line": [
+      "error",
+      {
+        "max": 3
+      }
+    ],
+    "no-debugger": "error",
+    "no-dupe-keys": "error",
+    "no-unsafe-finally": "error",
+    "no-with": "error",
+    "no-useless-call": "error",
+    "no-spaced-func": "error",
+    "max-statements": [
+      "warn",
+      30
+    ],
+    "max-depth": [
+      "error",
+      4
+    ],
+    "no-throw-literal": [
+      "error"
+    ],
+    "no-sequences": "error",
+    "no-warning-comments": [
+      "warn",
+      {
+        "terms": [
+          "fixme",
+          "xxx"
+        ],
+        "location": "anywhere"
+      }
+    ],
+    "radix": "error",
+    "yoda": "error",
+    "no-nested-ternary": "warn",
+    "no-whitespace-before-property": "error",
+    "no-trailing-spaces": [
+      "error",
+      {
+        "skipBlankLines": true
+      }
+    ],
+    "space-in-parens": [
+      "warn",
+      "never"
+    ],
+    "max-nested-callbacks": [
+      "error",
+      6
+    ],
+    "eol-last": "warn",
+    "no-mixed-spaces-and-tabs": "error",
+    "no-negated-condition": "warn",
+    "no-unneeded-ternary": "error",
+    "no-multi-spaces": [
+      "warn",
+      {
+        "exceptions": {
+          "Property": true
+        }
+      }
+    ],
+    "key-spacing": [
+      "warn",
+      {
+        "singleLine": {
+          "beforeColon": false,
+          "afterColon": true
+        },
+        "multiLine": {
+          "beforeColon": false,
+          "afterColon": true,
+          "mode": "minimum"
+        }
+      }
+    ],
+    "node/no-missing-require": "error",
+    "node/no-unsupported-features": [ "error", { "version": 0.10 } ]
+  }
+}

.gitignore

@@ -3,3 +3,4 @@ sentinel.dev.conf
 npm-debug.log
 node_modules
 *.sw*
+.eslintcache

.jshintrc

-{
-  "trailing": false, 
-  "unused": true, 
-  "node": true
-}

index.js

-module.exports = require('./lib/env');
\ No newline at end of file
+'use strict';
+
+module.exports = require('./lib/env');

lib/config.js

-/*jshint globalstrict:true, trailing:false, unused:true, node:true */
 "use strict";
+function configureNodeEnv() {
+  var nodeEnv = process.env.NODE_ENV;
+  if (nodeEnv) return nodeEnv;
+
+  /* Default to NODE_ENV=dev */
+  process.env.NODE_ENV = 'dev';
+  return 'dev';
+}
+
 /* Factory */
 exports.create = function(configDirectory) {
   var nconf = require('nconf');
@@ -11,14 +19,7 @@ exports.create = function(configDirectory) {
   var SYSTEM_CONFIG_DIR = '/etc/gitter/';
   /* Load configuration parameters */
-  var nodeEnv = process.env.NODE_ENV;
-  if(!nodeEnv) {
-    if(!nodeEnv) {
-      nodeEnv = 'dev';
-    }
-
-    process.env.NODE_ENV = nodeEnv;
-  }
+  var nodeEnv = configureNodeEnv();
   var staging = process.env.STAGING;
   staging = staging === '1' || staging === 'true';
@@ -35,24 +36,24 @@ exports.create = function(configDirectory) {
   nconf.argv()
        .env();
-  nconf.add('envUser',                  { type: 'file', file: path.join(configDir, 'config.' + nodeEnv + '.user-overrides.json')  });
-  nconf.add('user',                     { type: 'file', file: path.join(configDir, 'config.user-overrides.json')  });
+  nconf.add('envUser', { type: 'file', file: path.join(configDir, 'config.' + nodeEnv + '.user-overrides.json') });
+  nconf.add('user', { type: 'file', file: path.join(configDir, 'config.user-overrides.json') });
   if(staging) {
-    nconf.add('systemStagingOverrides', { type: 'file', file: path.join(SYSTEM_CONFIG_DIR, 'config.' + nodeEnv + '-staging.overrides.json')  });
+    nconf.add('systemStagingOverrides', { type: 'file', file: path.join(SYSTEM_CONFIG_DIR, 'config.' + nodeEnv + '-staging.overrides.json') });
   }
-  nconf.add('systemOverrides',          { type: 'file', file: path.join(SYSTEM_CONFIG_DIR, 'config.' + nodeEnv + '.overrides.json')  });
+  nconf.add('systemOverrides', { type: 'file', file: path.join(SYSTEM_CONFIG_DIR, 'config.' + nodeEnv + '.overrides.json') });
   if(staging) {
-    nconf.add('nodeEnvStaging',         { type: 'file', file: path.join(configDir, 'config.' + nodeEnv + '-staging.json')  });
+    nconf.add('nodeEnvStaging', { type: 'file', file: path.join(configDir, 'config.' + nodeEnv + '-staging.json') });
   }
-  nconf.add('nodeEnv',                  { type: 'file', file: path.join(configDir, 'config.' + nodeEnv + '.json')  });
-  nconf.add('systemDefaults',           { type: 'file', file: path.join(SYSTEM_CONFIG_DIR, 'config.' + nodeEnv + '.json')  });
-  nconf.add('defaults',                 { type: 'file', file: path.join(configDir, 'config.default.json') });
+  nconf.add('nodeEnv', { type: 'file', file: path.join(configDir, 'config.' + nodeEnv + '.json') });
+  nconf.add('systemDefaults', { type: 'file', file: path.join(SYSTEM_CONFIG_DIR, 'config.' + nodeEnv + '.json') });
+  nconf.add('defaults', { type: 'file', file: path.join(configDir, 'config.default.json') });
   process.on('SIGHUP', function() {
     async.parallel(

lib/env.js

@@ -136,7 +136,7 @@ exports.create = function(configDirectory) {
     mongo: {
       /* Bring your own mongoose connection configurer */
       configureMongoose: function(mongoose) {
-        return require('./mongoose-connection-configurer')({ config: config, logger: logger, mongoose: mongoose, env: env  });
+        return require('./mongoose-connection-configurer')({ config: config, logger: logger, mongoose: mongoose, env: env });
       }
     },

lib/install-diagnostics.js

 'use strict';
 var util = require('util');
-var os   = require('os');
+var os = require('os');
 var path = require('path');
 var processName = require('./process-name')

lib/logger.js

@@ -10,7 +10,7 @@ exports.create = function(options) {
   var transformMeta = require('./transform-meta');
   var nconf = options.config;
-  if(!nconf) throw "options must contain config";
+  if(!nconf) throw new Error("options must contain config");
   var defaultLogger = new winston.Logger({
     transports: []
@@ -31,7 +31,7 @@ exports.create = function(options) {
     }
     fs.stat(fullname, function (err, stat) {
-      if (err && err.code == 'ENOENT') {
+      if (err && err.code === 'ENOENT') {
         console.log('Log file no longer exists. Reopening');
         return reopen();
       }
@@ -39,7 +39,7 @@ exports.create = function(options) {
       if(fileTransport._stream && fileTransport._stream.fd) {
         fs.fstat(fileTransport._stream.fd, function(err2, fstat) {
-          if(stat.dev != fstat.dev || stat.ino !== fstat.ino) {
+          if(stat.dev !== fstat.dev || stat.ino !== fstat.ino) {
             console.log('File inode mismatch. Reopening');
             return reopen();
           }
@@ -170,7 +170,7 @@ exports.create = function(options) {
   var logLevel = nconf.get("logging:level");
   nconf.events.on('reload', function() {
-    if(logLevel ===  nconf.get("logging:level")) {
+    if(logLevel === nconf.get("logging:level")) {
       return;
     }

lib/middlewares/access-logger.js

@@ -23,21 +23,6 @@ function getPathTag(req) {
   return path;
 }
-function getUserId(req) {
-  var user = req.user;
-  if (!user) return;
-
-  return user.id || user._id; // Learn objects or not
-}
-
-function getClientId(req) {
-  var authInfo = req.authInfo;
-  if (!authInfo) return;
-  var client = authInfo.client;
-  if (!client) return;
-  return client.id || client._id;
-}
-
 exports.create = function(options) {
   var config = options.config;
@@ -48,22 +33,12 @@ exports.create = function(options) {
   return responseTime(function (req, res, time) {
     var routeTag = getPathTag(req);
-    // var userId = getUserId(req);
-    // var clientId = getClientId(req);
     var tags = ['method:' + req.method, 'sc:' + res.statusCode];
     if (routeTag) {
       tags.push('route:' + routeTag);
     }
-    // if (userId) {
-    //   tags.push('user:' + userId);
-    // }
-
-    // if (clientId) {
-    //   tags.push('client:' + clientId);
-    // }
-
     debug("%s %s [%s] completed %s with in %sms", req.method, req.originalUrl, req.routeIdentifier, res.statusCode, time);
     statsdClient.histogram('http.request', time, tags);

lib/middlewares/error-handler.js

 "use strict";
-module.exports = function errorHandlerMiddleware(err, req, res, next) { // jshint unused:false
+module.exports = function errorHandlerMiddleware(err, req, res, next) { // eslint-disable-line no-unused-vars
   var message = res.locals.errorMessage || "Internal Server Error";
-  
+
   // TODO: Add an HTML version for HTML clients
   res.send({ error: message, uniqueId: res.locals.errorIdentifer });
 };

lib/middlewares/error-reporter.js

@@ -100,7 +100,7 @@ exports.create = function(options) {
           errorIdentifer = Date.now();
           // Send to sentry
-          errorReporter (err, {
+          errorReporter(err, {
             type: 'response',
             status: status,
             userId: userId,

lib/mongoose-connection-configurer.js

 'use strict';
-var mongodbConnString       = require('mongodb-connection-string');
-var mongodbArbiterDiscover  = require('mongodb-arbiter-discovery');
-var mongoDogStats           = require('mongodb-datadog-stats');
-var shutdown                = require('shutdown');
+var mongodbConnString = require('mongodb-connection-string');
+var mongodbArbiterDiscover = require('mongodb-arbiter-discovery');
+var mongoDogStats = require('mongodb-datadog-stats');
+var shutdown = require('shutdown');
 var MONGO_CONNECTION_OPTIONS = {
   server: {

lib/stats.js

@@ -10,386 +10,412 @@ function getBucketFromUserId(userId) {
   return (parseInt(lastChar+'', 16) % 2) ? 'A' : 'B';
 }
-exports.create = function(options) {
-  // Stats requires a logger and logger requires stats, so
-  // we'll forego logging in the stats module rather than the
-  // other way around
-  var config = options.config;
-  var statsHandlers = {
-    trackRequest: [],
-    event: [],
-    charge: [],
-    eventHF: [],
-    gaugeHF: [],
-    userUpdate: [],
-    responseTime: [],
-    alias: []
-  };
-  var mixpanelEnabled = config.get("stats:mixpanel:enabled");
-  var gaEnabled = config.get('stats:ga:enabled');
-  var statsdEnabled = config.get("stats:statsd:enabled");
-  var cubeEnabled = config.get("stats:cube:enabled");
-  var consoleEnabled = config.get("stats:console:enabled");
-  var intercomEnabled = config.get("stats:intercom:enabled");
-  /**
-   * console
-   */
-  if (consoleEnabled) {
-    statsHandlers.event.push(function(eventName) {
-      console.log('stat: event: ' + eventName);
-    });
-    statsHandlers.charge.push(function (userId, usd) {
-      console.log('stat: charge:', userId, usd);
-    });
-    statsHandlers.eventHF.push(function(eventName, count, frequency, tags) {
-      console.log('stat: eventHF: ' + eventName + ' +' + count + (tags ? ' ' + tags.join(', ') : ''));
-    });
-    statsHandlers.gaugeHF.push(function(gaugeName, value, frequency, tags) {
-      console.log('stat: gaugeHF: ' + gaugeName + ": " + value + (tags ? ' ' + tags.join(', ') : ''));
+function configureConsole(statsHandlers) {
+  statsHandlers.event.push(function(eventName) {
+    console.log('stat: event: ' + eventName);
+  });
+
+  statsHandlers.charge.push(function (userId, usd) {
+    console.log('stat: charge:', userId, usd);
+  });
+
+  statsHandlers.eventHF.push(function(eventName, count, frequency, tags) {
+    console.log('stat: eventHF: ' + eventName + ' +' + count + (tags ? ' ' + tags.join(', ') : ''));
+  });
+
+  statsHandlers.gaugeHF.push(function(gaugeName, value, frequency, tags) {
+    console.log('stat: gaugeHF: ' + gaugeName + ": " + value + (tags ? ' ' + tags.join(', ') : ''));
+  });
+
+  statsHandlers.responseTime.push(function(timerName, duration, tags) {
+    console.log('stat: responseTime: ' + timerName + ": " + duration + (tags ? ' ' + tags.join(', ') : ''));
+  });
+}
+function configureCube(statsHandlers, config) {
+  var Cube = require("gitter-private-cube");
+  var statsUrl = config.get("stats:cube:cubeUrl");
+  var cube = Cube.emitter(statsUrl);
+  statsHandlers.event.push(function(eventName, properties) {
+    if(!properties) properties = {};
+    properties.env = config.runtimeEnvironment;
+    var event = {
+      type: "gitter_" + eventName.replace(/\./g, '_'),
+      time: new Date(),
+      data: properties
+    };
+    cube.send(event);
+  });
+
+  statsHandlers.charge.push(function (userId, usd) {
+
+    var event = {
+      type: 'gitter_charge',
+      time: new Date(),
+      data: {
+        userId: userId,
+        usd: usd,
+        env: config.runtimeEnvironment
+      }
+    };
+    cube.send(event);
+  });
+}
+function configureStatsD(statsHandlers, config) {
+  var statsdClient = require('./stats-client').create({
+      config: config,
+      prefix: config.get('stats:statsd:prefix')
     });
-    statsHandlers.responseTime.push(function(timerName, duration, tags) {
-      console.log('stat: responseTime: ' + timerName + ": " + duration + (tags ? ' ' + tags.join(', ') : ''));
-    });
-  }
-  /**
-   * cube
-   */
-  if (cubeEnabled) {
-    var Cube = require("gitter-private-cube");
-    var statsUrl = config.get("stats:cube:cubeUrl");
-    var cube = Cube.emitter(statsUrl);
-    statsHandlers.event.push(function(eventName, properties) {
-      if(!properties) properties = {};
-      properties.env = config.runtimeEnvironment;
-      var event = {
-        type: "gitter_" + eventName.replace(/\./g, '_'),
-        time: new Date(),
-        data: properties
-      };
-      cube.send(event);
-    });
-    statsHandlers.charge.push(function (userId, usd) {
-      var event = {
-        type: 'gitter_charge',
-        time: new Date(),
-        data: {
-          userId: userId,
-          usd: usd,
-          env: config.runtimeEnvironment
-        }
-      };
-      cube.send(event);
-    });
-  }
-
-  /**
-   * statsd
-   */
-  if (statsdEnabled) {
-    var statsdClient = require('./stats-client').create({
-        config: config,
-        prefix: config.get('stats:statsd:prefix')
-      });
-    statsHandlers.event.push(function(eventName) {
-      statsdClient.increment(eventName);
-    });
-    statsHandlers.charge.push(function (userId, usd) {
-      statsdClient.increment('charged', usd);
-    });
-    statsHandlers.eventHF.push(function(eventName, count, frequency, tags) {
-      if(!count) count = 1;
-      if(!frequency) frequency = 0.1;
-      /* Only send to the server one tenth of the time */
-      statsdClient.increment(eventName, count, frequency, tags);
-    });
-    statsHandlers.gaugeHF.push(function(gaugeName, value, frequency, tags) {
-      if(!frequency) frequency = 0.1;
-      /* Only send to the server one tenth of the time */
-      statsdClient.gauge(gaugeName, value, frequency, tags);
-    });
-    statsHandlers.responseTime.push(function(timerName, duration, tags) {
-      statsdClient.timing(timerName, duration, 1, tags);
+  statsHandlers.event.push(function(eventName) {
+    statsdClient.increment(eventName);
+  });
+  statsHandlers.charge.push(function (userId, usd) {
+    statsdClient.increment('charged', usd);
+  });
+  statsHandlers.eventHF.push(function(eventName, count, frequency, tags) {
+    if(!count) count = 1;
+    if(!frequency) frequency = 0.1;
+    /* Only send to the server one tenth of the time */
+    statsdClient.increment(eventName, count, frequency, tags);
+  });
+  statsHandlers.gaugeHF.push(function(gaugeName, value, frequency, tags) {
+    if(!frequency) frequency = 0.1;
+    /* Only send to the server one tenth of the time */
+    statsdClient.gauge(gaugeName, value, frequency, tags);
+  });
+  statsHandlers.responseTime.push(function(timerName, duration, tags) {
+    statsdClient.timing(timerName, duration, 1, tags);
+  });
+}
+function configureIntercom(statsHandlers, config) {
+  var intercomWhiteList = {
+    new_chat: true,
+    user_login:  true,
+    join_room: true,
+    create_room: true,
+    create_group: true,
+    join_group: true,
+    leave_group: true,
+    user_added_someone: true,
+    new_invited_user: true,
+    invite_accepted: true,
+    new_user: true,
+    charge_failed: true,
+    lurk_room: true
+  };
+  var Intercom = require('intercom.io');
+  var intercomOptions = {
+    apiKey: config.get("stats:intercom:key"),
+    appId: config.get("stats:intercom:app_id")
+  };
+  var intercom = new Intercom(intercomOptions);
+
+  statsHandlers.event.push(function(eventName, properties) {
+
+    /**
+     * Metadata can be used to submit an event with extra key value data.
+     * Each event can contain up to five metadata key values.
+     * https://doc.intercom.io/api#event-model
+     */
+    function selectIntercomMetaData(properties) {
+      var result = {};
+      var keys = Object.keys(properties);
+      var totalKeys = 0;
+      for (var i = 0; i < keys.length && totalKeys <= 5; i++) {
+        var key = keys[i];
+        if (key === 'userId') continue; // Already have this in the event
+
+        var value = properties[key];
+        var valueType = typeof value;
+        if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+          result[key] = value;
+        }
+      }
+      return result;
+    }
+    if(!intercomWhiteList[eventName]) return;
+    // intercom likes a seconds since epoch date not ms that node gives by default
+    var now = Number(Date.now()/1000).toFixed(0);
+    var attemptCount = 0;
+    var eventData = {
+      "event_name": eventName,
+      "created_at": now,
+      "user_id": properties.userId,
+    };
+    if (properties) {
+      eventData.metadata = selectIntercomMetaData(properties);
+    }
+    function createEvent() {
+      intercom.createEvent(eventData, function(err, res) {
+        if (err || res.errors && res.errors.length) {
+          attemptCount++;
+          if (attemptCount < 2) {
+            setTimeout(createEvent, 2000);
+          } else {
+              emergencyLog('Intercom error: ' + err, { exception: err });
+          }
+        }
+      });
+    }
+    createEvent();
+  });
+
+  statsHandlers.charge.push(function (userId, usd) {
+    // intercom likes a seconds since epoch date not ms that node gives by default
+    var now = Number(Date.now()/1000).toFixed(0);
+    var attemptCount = 0;
+    function createEvent() {
+      intercom.createEvent({
+        "event_name": 'charged',
+        "created_at": now,
+        "user_id": userId,
+        "metadata": {
+          "value": usd
+        }
+      }, function (err, res) {
+        if (err || res.errors && res.errors.length) {
+          attemptCount++;
+          if (attemptCount < 2) {
+            setTimeout(createEvent, 2000);
+          } else {
+            emergencyLog('Intercom error: ' + err, { exception: err });
+          }
+        }
+      });
+    }
+    createEvent();
+  });
+
+  statsHandlers.userUpdate.push(function(user/*, properties*/) {
+    var created_at = new Date(user._id.getTimestamp());
+    var now = Number(Date.now()/1000).toFixed(0);
+
+    var profile = {
+      "email": user.email,
+      "user_id": user._id,
+      "name": user.displayName,
+      "created_at": created_at,
+      "username": user.username,
+      "state": user.state || 'ACTIVE',
+      "last_impression_at": now,
+      "bucket": getBucketFromUserId(user._id)
+    };
+    intercom.createUser(profile, function(err) {
+      if (err) {
+        emergencyLog('Intercom error: ' + err, { exception: err });
+      }
     });
-  }
-  /**
-   * Intercom
-   */
-  if (intercomEnabled) {
-    var intercomWhiteList = {
-      new_chat: true,
-      user_login:  true,
-      join_room: true,
-      create_room: true,
-      create_group: true,
-      join_group: true,
-      leave_group: true,
-      user_added_someone: true,
-      new_invited_user: true,
-      invite_accepted: true,
-      new_user: true,
-      charge_failed: true,
-      lurk_room: true
-    };
-    var Intercom = require('intercom.io');
-    var intercomOptions = {
-      apiKey: config.get("stats:intercom:key"),
-      appId: config.get("stats:intercom:app_id")
-    };
-    var intercom = new Intercom(intercomOptions);
-    statsHandlers.event.push(function(eventName, properties) {
-      /**
-       * Metadata can be used to submit an event with extra key value data.
-       * Each event can contain up to five metadata key values.
-       * https://doc.intercom.io/api#event-model
-       */
-      function selectIntercomMetaData(properties) {
-        var result = {};
-        var keys = Object.keys(properties);
-        var totalKeys = 0;
-        for (var i = 0; i < keys.length && totalKeys <= 5; i++) {
-          var key = keys[i];
-          if (key === 'userId') continue; // Already have this in the event
-
-          var value = properties[key];
-          var valueType = typeof value;
-          if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
-            result[key] = value;
-          }
-        }
-        return result;
-      }
-      if(!intercomWhiteList[eventName]) return;
-      // intercom likes a seconds since epoch date not ms that node gives by default
-      var now = Number(Date.now()/1000).toFixed(0);
-      var attemptCount = 0;
-      var eventData = {
-        "event_name" : eventName,
-        "created_at" : now,
-        "user_id" : properties.userId,
-      };
-      if (properties) {
-        eventData.metadata = selectIntercomMetaData(properties);
-      }
-      function createEvent() {
-        intercom.createEvent(eventData, function(err, res) {
-          if (err || res.errors && res.errors.length) {
-            attemptCount++;
-            if (attemptCount < 2) {
-              setTimeout(createEvent, 2000);
-            } else {
-                emergencyLog('Intercom error: ' + err, { exception: err });
-            }
-          }
-        });
-      }
-      createEvent();
+  });
+}
+function configureMixpanel(statsHandlers, config) {
+  var mixpanelEventBlacklist = {
+    location_submission: true,
+    push_notification: true,
+    mail_bounce: true,
+    new_troupe: true,
+    new_mail_attachment: true,
+    remailed_email: true,
+    new_file_version: true,
+    new_file: true,
+    login_failed: true,
+    password_reset_invalid: true,
+    password_reset_completed: true,
+    invite_reused: true,
+    confirmation_reused: true,
+    client_error_404: true,
+    client_error_4xx: true,
+    client_error_5xx: true,
+    unread_notification_sent: true,
+    charge_failed: true,
+    suggest_room: true
+  };
+  var Mixpanel = require('mixpanel');
+  var token = config.get("stats:mixpanel:token");
+  var mixpanel = Mixpanel.init(token);
+  statsHandlers.alias.push(function(distinctId, userId, cb) {
+    mixpanel.alias(distinctId, userId, cb);
+  });
+  statsHandlers.event.push(function(eventName, properties) {
+    if(!properties || !(properties.userId || properties.distinctId)) {
+      return;
+    }
+    if(mixpanelEventBlacklist[eventName]) {
+      return;
+    }
+    properties.distinct_id = properties.distinctId || properties.userId;
+    mixpanel.track(eventName, properties, function(err) {
+      if (err) emergencyLog('Mixpanel Track error: ' + err, { exception: err });
     });
-    statsHandlers.charge.push(function (userId, usd) {
-      // intercom likes a seconds since epoch date not ms that node gives by default
-      var now = Number(Date.now()/1000).toFixed(0);
-      var attemptCount = 0;
-      function createEvent() {
-        intercom.createEvent({
-          "event_name" : 'charged',
-          "created_at" : now,
-          "user_id" : userId,
-          "metadata": {
-            "value": usd
-          }
-        }, function (err, res) {
-          if (err || res.errors && res.errors.length) {
-            attemptCount++;
-            if (attemptCount < 2) {
-              setTimeout(createEvent, 2000);
-            } else {
-              emergencyLog('Intercom error: ' + err, { exception: err });
-            }
-          }
-        });
-      }
-      createEvent();
+  });
+  statsHandlers.charge.push(function (userId, usd) {
+    if (!userId) return;
+    mixpanel.people.track_charge(userId, usd, {}, function (err) {
+      if (err) return emergencyLog('Mixpanel Charge error: ' + err, { exception: err });
     });
-    statsHandlers.userUpdate.push(function(user/*, properties*/) {
-      var created_at = new Date(user._id.getTimestamp());
-      var now = Number(Date.now()/1000).toFixed(0);
-
-      var profile = {
-        "email" : user.email,
-        "user_id" : user._id,
-        "name" : user.displayName,
-        "created_at" : created_at,
-        "username" : user.username,
-        "state" : user.state || 'ACTIVE',
-        "last_impression_at" : now,
-        "bucket": getBucketFromUserId(user._id)
-      };
-      intercom.createUser(profile, function(err) {
-        if (err) {
-          emergencyLog('Intercom error: ' + err, { exception: err });
-        }
-      });
-    });
-   }
-  /**
-   * Mixpanel
-   */
-  if (mixpanelEnabled) {
-    var mixpanelEventBlacklist = {
-      location_submission: true,
-      push_notification: true,
-      mail_bounce: true,
-      new_troupe: true,
-      new_mail_attachment: true,
-      remailed_email: true,
-      new_file_version: true,
-      new_file: true,
-      login_failed: true,
-      password_reset_invalid: true,
-      password_reset_completed: true,
-      invite_reused: true,
-      confirmation_reused: true,
-      client_error_404: true,
-      client_error_4xx: true,
-      client_error_5xx: true,
-      unread_notification_sent: true,
-      charge_failed: true,
-      suggest_room: true
+  });
+  statsHandlers.userUpdate.push(function(user, properties) {
+    properties = properties || {};
+    var createdAt = Math.round(user._id.getTimestamp().getTime());
+    var mp_properties = {
+      $created_at:  new Date(createdAt).toISOString(),
+      $name:        user.displayName,
+      $username:    user.username
     };
-    var Mixpanel  = require('mixpanel');
-    var token     = config.get("stats:mixpanel:token");
-    var mixpanel  = Mixpanel.init(token);
-
-    statsHandlers.alias.push(function(distinctId, userId, cb) {
-      mixpanel.alias(distinctId, userId, cb);
-    });
-    statsHandlers.event.push(function(eventName, properties) {
-      if(!properties || !(properties.userId || properties.distinctId)) {
-        return;
-      }
-      if(mixpanelEventBlacklist[eventName]) {
-        return;
-      }
-      properties.distinct_id = properties.distinctId || properties.userId;
-      mixpanel.track(eventName, properties, function(err) {
-        if (err) emergencyLog('Mixpanel Track error: ' + err, { exception: err });
-      });
+    if (user.email) mp_properties.$email = user.email;
+    properties.bucket = getBucketFromUserId(user._id);
+    for (var attr in properties) {
+      var value = properties[attr] instanceof Date ? properties[attr].toISOString() : properties[attr];
+      mp_properties[attr] = value;
+    }
+    mixpanel.people.set(user.id, mp_properties, function(err) {
+      if (err) emergencyLog('Mixpanel userUpdate: ' + err, { exception: err });
+    });
+  });
+}
+function configureGA(statsHandlers, config) {
+  var ua = require('universal-analytics');
+  var gaID = config.get('stats:ga:key');
+  if (!gaID) return emergencyLog(new Error('Missing key for Google Analytics'));
+
+  statsHandlers.event.push(function(eventName, properties) {
+    // Don't handle events that don't have a googleAnalyticsUniqueId
+    if(!properties || !properties.googleAnalyticsUniqueId) return;
+    var visitor = ua(gaID, properties.googleAnalyticsUniqueId);
+
+    visitor.event({
+      ec: "stats",
+      ea: eventName,
+      // Label: el: "",
+      // Value: ev: 0,
+      // Page: dp: "/"
+    }, function(err) {
+      if (err) emergencyLog('Google Analytics event error: ' + err, { exception: err });
     });
-    statsHandlers.charge.push(function (userId, usd) {
-      if (!userId) return;
-      mixpanel.people.track_charge(userId, usd, {}, function (err) {
-        if (err) return emergencyLog('Mixpanel Charge error: ' + err, { exception: err });
-      });
-    });
-    statsHandlers.userUpdate.push(function(user, properties) {
-      properties = properties || {};
-      var createdAt = Math.round(user._id.getTimestamp().getTime());
-      var mp_properties = {
-        $created_at:  new Date(createdAt).toISOString(),
-        $name:        user.displayName,
-        $username:    user.username
-      };
-      if (user.email) mp_properties.$email = user.email;
-      properties.bucket = getBucketFromUserId(user._id);
-      for (var attr in properties) {
-        var value = properties[attr] instanceof Date ? properties[attr].toISOString() : properties[attr];
-        mp_properties[attr] = value;
-      }
-      mixpanel.people.set(user.id, mp_properties, function(err) {
-        if (err) emergencyLog('Mixpanel userUpdate: ' + err, { exception: err });
-      });
-    });
+  });
+  statsHandlers.trackRequest.push(function (req) {
+    var UUID;
+    // checking for existent UUID
+    if (req.cookies && req.cookies._ga) {
+      UUID = (req.cookies._ga).split('.').slice(2, 4).join('.');
+    }
+    var visitor = ua(gaID, UUID);
+    visitor.pageview({
+        dp: req.url,
+        dh: req.get('host'),
+        dr: req.get('referer'),
+        ua: req.get('User-Agent')
+      }, function (err) {
+        if (err) emergencyLog('Google Analytics Track Request: ' + err, { exception: err });
+      });
+  });
+}
+exports.create = function(options) {
+  // Stats requires a logger and logger requires stats, so
+  // we'll forego logging in the stats module rather than the
+  // other way around
+  var config = options.config;
+  var statsHandlers = {
+    trackRequest: [],
+    event: [],
+    charge: [],
+    eventHF: [],
+    gaugeHF: [],
+    userUpdate: [],
+    responseTime: [],
+    alias: []
+  };
+  var mixpanelEnabled = config.get("stats:mixpanel:enabled");
+  var gaEnabled = config.get('stats:ga:enabled');
+  var statsdEnabled = config.get("stats:statsd:enabled");
+  var cubeEnabled = config.get("stats:cube:enabled");
+  var consoleEnabled = config.get("stats:console:enabled");
+  var intercomEnabled = config.get("stats:intercom:enabled");
+  /**
+   * console
+   */
+  if (consoleEnabled) {
+    configureConsole(statsHandlers, config);
   }
   /**
-   * Request Tracking for Google Analytics
+   * cube
    */
-  if (gaEnabled) {
-    var ua = require('universal-analytics');
-    var gaID = config.get('stats:ga:key');
-    if (!gaID) return emergencyLog(new Error('Missing key for Google Analytics'));
-
-    statsHandlers.event.push(function(eventName, properties) {
-      // Don't handle events that don't have a googleAnalyticsUniqueId
-      if(!properties || !properties.googleAnalyticsUniqueId) return;
-      var visitor = ua(gaID, properties.googleAnalyticsUniqueId);
-
-      visitor.event({
-        ec: "stats",
-        ea: eventName,
-        // Label: el: "",
-        // Value: ev: 0,
-        // Page: dp: "/"
-      }, function(err) {
-        if (err) emergencyLog('Google Analytics event error: ' + err, { exception: err });
-      });
-    });
-    statsHandlers.trackRequest.push(function (req) {
-      var UUID;
-      // checking for existent UUID
-      if (req.cookies && req.cookies._ga) {
-        UUID = (req.cookies._ga).split('.').slice(2, 4).join('.');
-      }
-      var visitor = ua(gaID, UUID);
-      visitor.pageview({
-          dp: req.url,
-          dh: req.get('host'),
-          dr: req.get('referer'),
-          ua: req.get('User-Agent')
-        }, function (err) {
-          if (err) emergencyLog('Google Analytics Track Request: ' + err, { exception: err });
-        });
-    });
+  if (cubeEnabled) {
+    configureCube(statsHandlers, config);
+  }
+  /**
+   * statsd
+   */
+  if (statsdEnabled) {
+    configureStatsD(statsHandlers, config)
+  }
+  /**
+   * Intercom
+   */
+  if (intercomEnabled) {
+    configureIntercom(statsHandlers, config);
+  }
+  /**
+   * Mixpanel
+   */
+  if (mixpanelEnabled) {
+    configureMixpanel(statsHandlers, config);
+  }
+  /**
+   * Request Tracking for Google Analytics
+   */
+  if (gaEnabled) {
+    configureGA(statsHandlers, config);
   }
   function makeHandler(handlers) {

lib/transform-meta.js

@@ -19,7 +19,7 @@ function transformMeta(meta, depth) {
     var valType = typeof value;
-    if(valType == 'string' || valType === 'number' || valType === 'boolean') {
+    if(valType === 'string' || valType === 'number' || valType === 'boolean') {
       return value;
     }
@@ -27,7 +27,7 @@ function transformMeta(meta, depth) {
     if(!value) return null;
     /* Deal with mongo objectIds so we dont get binary logged */
-    if(valType == 'object' && value._bsontype === 'ObjectID') {
+    if(valType === 'object' && value._bsontype === 'ObjectID') {
       return "" + value;
     }
@@ -52,4 +52,4 @@ function transformMeta(meta, depth) {
   return result;
 }
-module.exports = transformMeta;
\ No newline at end of file
+module.exports = transformMeta;

lib/unhandled-exceptions.js

@@ -25,6 +25,7 @@ exports.create = function(options) {
       try {
         console.log('The error handler crashed too');
       } catch(e) {
+        /* */
       }
     }

package.json

@@ -48,6 +48,9 @@
     "winston-udp": "^0.0.6"
   },
   "devDependencies": {
+    "eslint": "^2.11.1",
+    "eslint-plugin-mocha": "^3.0.0",
+    "eslint-plugin-node": "^1.4.0",
     "mocha": "^1.18.2",
     "retire": "^0.2.1",
     "temp": "^0.8.3"

tests/.eslintrc.json

+{
+  "env": {
+    "commonjs": true,
+    "node": true,
+    "mocha": true
+  },
+  "plugins": [
+    "mocha"
+  ],
+  "rules": {
+    "mocha/no-exclusive-tests": "error",
+    "strict": [
+      "warn",
+      "safe"
+    ],
+    "max-nested-callbacks": [
+      "error",
+      10
+    ]
+  }
+}

tests/.jshintrc

-{
-    "undef": true,
-    "node": true,
-    "unused": true,
-    "predef": [
-        "describe", 
-        "it",
-        "before",
-        "after",
-        "beforeEach",
-        "afterEach"
-    ]
-}

tests/config-test.js

-/*jslint node: true */
-/*global describe:true, it: true, before:false, after:false */
 "use strict";
 var assert = require('assert');
@@ -25,4 +23,4 @@ describe('gitter-config', function() {
     assert.equal('something', config.get('test:another_value'));
   });
-});
\ No newline at end of file
+});