keen-event.js

"use strict";

var helpers = require('./core/helpers');

var KeenEventModule = (function (options, eventEmitter) {
  this._ee = helpers.setDefaultEvents(eventEmitter, ['error', 'debug']);

  var MAX_PROPERTY_HIERARCHY_DEPTH = options.defaults && options.defaults.MAX_PROPERTY_HIERARCHY_DEPTH || 10,
      MAX_STRING_LENGTH = options.defaults && options.defaults.MAX_STRING_LENGTH || 1000,
      MAX_PROPERTY_QUANTITY = options.defaults && options.defaults.MAX_PROPERTY_QUANTITY || 300;

  this._setupAddons = function (keenEvent, addonSwitches) {
    var keenAddons = [];

    if (keenEvent.identity.ipAddress && addonSwitches.ipToGeo) {
      keenAddons.push({
        name: "keen:ip_to_geo",
        input: {
          "ip": "identity.ipAddress"
        },
        output: "identity.ipGeography"
      });
    }
    if (keenEvent.identity.userAgent && addonSwitches.userAgentParser) {
      keenAddons.push({
        name: "keen:ua_parser",
        input: {
          "ua_string": "identity.userAgent"
        },
        output: "identity.parsedUserAgent"
      });
    }

    return keenAddons;
  };

  this.generateEvent = function (identity, parsedRequestData, parsedResponseData, routeConfig) {
    
    var keenEvent = {
      identity: identity,
      intention: {
        method: parsedRequestData.method,
        path: parsedRequestData.path,
        params: parsedRequestData.params,
        body: parsedRequestData.body,
        query: parsedRequestData.query
      },
      reaction: parsedResponseData.body,
      httpStatus: parsedResponseData.status,
      environment: {
        library: 'express-keenio',
        ipAddress: '${keen.ip}',
        userAgent: '${keen.user_agent}'
      },
      keen: {}
    };
    keenEvent.keen.addons = this._setupAddons(keenEvent, options.defaults.addons);

    if (parsedRequestData.referer) {
      keenEvent.intention.referer = parsedRequestData.referer;
    }

    if (routeConfig.tag) {
      keenEvent.tag = routeConfig.tag;
    }

    return this.sanitize(keenEvent, routeConfig.whitelistProperties || {});
  };

  this.sanitize = function (data, whitelistPropertiesObject) {
    this._checkPropertyDepth(data, true);

    this._checkForNonWhitelist(data, whitelistPropertiesObject);

    return this._sanitizeData(data);
  };

  this._checkPropertyDepth = function (data, smite, level) {
    level = level || 1;
    smite = smite || false;

    var self = this,
        depth = level;
    
    helpers.forEach(data, function (value, key, data) {
      if (level > MAX_PROPERTY_HIERARCHY_DEPTH) {
        var isSmiteMessage = '';
        if (smite) {
          isSmiteMessage = 'and has been smited.';
          delete data[key];
        }
        self._ee.emit('error', 'WARNING: The depth of the key (' + key + ') is greater than ' + MAX_PROPERTY_HIERARCHY_DEPTH + isSmiteMessage);
      }

      if (helpers.isEnumerable(value)) {
        depth = self._checkPropertyDepth(value, smite, level + 1);
      }

      depth = Math.max(depth, level);
    });
    return depth;
  };

  this._checkForNonWhitelist = function (data, whitelistPropertiesObject) {
    
    if (!whitelistPropertiesObject) {
      return data;
    }

    if (whitelistPropertiesObject.query) {
      data.intention.query = this._stripNonWhitelistedDeepProperties(data.intention.query, whitelistPropertiesObject.query);
    }
    if (whitelistPropertiesObject.body) {
      data.intention.body = this._stripNonWhitelistedDeepProperties(data.intention.body, whitelistPropertiesObject.body);
    }
    if (whitelistPropertiesObject.reaction) {
      data.reaction = this._stripNonWhitelistedDeepProperties(data.reaction, whitelistPropertiesObject.reaction);
    }

    return data;
  };

  this._stripNonWhitelistedProperties = function (data, whitelistProperties) {
    var self = this,
        PROPERTY_WHITELIST = whitelistProperties;

    if (!helpers.isEnumerable(data)) {
      return data;
    } else {
      helpers.forEach(data, function (value, key) {
        if (PROPERTY_WHITELIST.indexOf(key) === -1) {
          self._ee.emit('debug', "WARNING: The property (" + key + ") is not in the whitelist and has been smited.");
          delete data[key];
        } else {
          data[key] = self._stripNonWhitelistedProperties(value, whitelistProperties);
        }
      });
    }

    return data;
  };

  this._stripNonWhitelistedDeepProperties = function (data, whitelistProperties, parentKey, level) {
    parentKey = parentKey || '';
    level = level || 0;

    var self = this;

    var PROPERTY_WHITELIST_AT_LEVEL = whitelistProperties.map(function (wp) {
      return wp.split('.').slice(0, level + 1).join('.');
    }).filter(helpers.identity); // Filter falsey properties.

    if (!helpers.isEnumerable(data)) {
      return data;
    } else {
      helpers.forEach(data, function (value, key) {

        var keyUpToLevel = parentKey + key;

        if (helpers.isArray(value)) {
          keyUpToLevel = keyUpToLevel + '[]';
        }

        if (helpers.isNumber(key)) {
          data[key] = self._stripNonWhitelistedDeepProperties(value, whitelistProperties, parentKey, level + 1);
        } else if (PROPERTY_WHITELIST_AT_LEVEL.indexOf(keyUpToLevel) === -1) {
          self._ee.emit('debug', "WARNING: The property (" + key + ") is not in the whitelist and has been smited.");
          delete data[key];
        } else {

          data[key] = self._stripNonWhitelistedDeepProperties(value, whitelistProperties, keyUpToLevel + '.', level + 1);
        }
      });
    }

    return data;
  };

  this._sanitizeData = function (data) {
    var self = this;

    var propertyCount = 0;

    function execute (data) {
      if (!helpers.isEnumerable(data)) {
        return data;
      } else {
        helpers.forEach(data, function (value, key) {
          var isSmitedDueToMaxProperty = false;
          if (propertyCount >= MAX_PROPERTY_QUANTITY) {
            self._ee.emit('debug', "WARNING: The property (" + key + ") has been smited due to there being too many properties in the Keen Event.");
            delete data[key];
            isSmitedDueToMaxProperty = true;
          }

          var isSmitedDueToProperty = false;
          if (!isSmitedDueToMaxProperty && helpers.isObject(data)) {
            isSmitedDueToProperty = (self._checkBlacklist(value, key, data) || self._checkInvalidProperty(value, key, data));
          }

          var isSmitedDueToValue = false;
          if (!isSmitedDueToMaxProperty && !isSmitedDueToProperty) {
            isSmitedDueToValue = (self._checkForFunctions(value, key, data) ||
                                  self._checkForExtremelyLongStrings(value, key, data) ||
                                  self._checkForArraysOfObjects(value, key, data));
          }

          var isSmited = isSmitedDueToProperty || isSmitedDueToValue || isSmitedDueToMaxProperty;
          if (!isSmited) {
            propertyCount += 1;
            data[key] = execute(value);
          }
        });
      }
      return data;
    }

    return execute(data);
  };

  this._checkBlacklist = function (value, key, data) {
    var PROPERTY_BLACKLIST = ['password'].concat(options && options.blacklistProperties || []);
    if (PROPERTY_BLACKLIST.indexOf(key) !== -1) {
      this._ee.emit('debug', "WARNING: The property (" + key + ") is blacklisted and has been smited.");
      delete data[key];
      return true;
    }

    return false;
  };

  this._checkInvalidProperty = function (value, key, data) {
    if (!this._isValidProperty(key)) {
      this._ee.emit('error', "WARNING: The property (" + key + ") is not a valid Keen.IO property and has been smited.");
      delete data[key];
      return true;
    }

    return false;
  };

  this._checkForArraysOfObjects = function (value, key, data) {

    var isNotAddons = key !== 'addons';
    if (helpers.isArrayOfObjects(value) && isNotAddons) {
      this._ee.emit('debug', "WARNING: An array of objects was found at property (" + key + ") and has been SMITED from the event.");
      delete data[key];
      return true;
    }

    return false;
  };

  this._checkForFunctions = function (value, key, data) {
    if (helpers.isFunction(value)) {
      this._ee.emit('error', "WARNING: The value found at property (" + key + ") is a function and has been smited.");
      delete data[key];
      return true;
    }

    return false;
  };

  this._checkForExtremelyLongStrings = function (value, key, data) {
    if (helpers.isString(value) && value.length > MAX_STRING_LENGTH) {
      this._ee.emit('error', "WARNING: The string found at property (" + key + ") is huge and has been smited.");
      delete data[key];
      return true;
    }

    return false;
  };

  this._isValidProperty = function (potentialProperty) {
    if (!potentialProperty) {
      return false;
    }
    if (potentialProperty.length > 256) {
      return false;
    }
    if (potentialProperty.charAt(0) === '$') {
      return false;
    }
    if (potentialProperty.indexOf('.') !== -1) {
      return false;
    }

    return true;
  };
  
  return this;

}).bind({});

exports = module.exports = KeenEventModule;