kayvee 3.16.0 → 3.18.0

package/build/lib/middleware.js

@@ -11,11 +11,10 @@ var _ = require("underscore");
 /**
  * all relative files path in a directory
  */
-function walkDirSync(dir, files) {
-    if (files === void 0) { files = []; }
-    var list = fs.readdirSync(dir);
-    list.forEach(function (file) {
-        var f = path.join(dir, file);
+function walkDirSync(dir, files = []) {
+    const list = fs.readdirSync(dir);
+    list.forEach((file) => {
+        const f = path.join(dir, file);
         if (fs.statSync(path.join(dir, file)).isDirectory()) {
             walkDirSync(f, files);
         }
@@ -23,7 +22,7 @@ function walkDirSync(dir, files) {
             files.push(f);
         }
     });
-    return files.map(function (f) { return path.relative(dir, f); });
+    return files.map((f) => path.relative(dir, f));
 }
 /**
  * returns a middleware function that checks if path exists in dir.
@@ -31,12 +30,11 @@ function walkDirSync(dir, files) {
  * Files in the directory are prefixed by base_path and compared to
  * req.path
  */
-function skip_path(dir, base_path) {
-    if (base_path === void 0) { base_path = "/"; }
-    var files = walkDirSync(dir);
-    files = files.map(function (file) { return path.join(base_path, file); });
-    console.error("KayveeMiddleware: Skipping successful requests for files in " + dir + " at " + base_path);
-    return function (req, res) { return _(files).contains(req.path) && res.statusCode < 400; };
+function skip_path(dir, base_path = "/") {
+    let files = walkDirSync(dir);
+    files = files.map((file) => path.join(base_path, file));
+    console.error(`KayveeMiddleware: Skipping successful requests for files in ${dir} at ${base_path}`);
+    return (req, res) => _(files).contains(req.path) && res.statusCode < 400;
 }
 /**
  * request path
@@ -52,8 +50,11 @@ function getBaseUrl(req) {
 function getQueryParams(req) {
     var url = req.originalUrl || req.url;
     var parsed = require("url").parse(url, true);
-    var parsedQueryString = require("qs").parse(parsed.search, { allowPrototypes: false, ignoreQueryPrefix: true });
-    return "?" + require("qs").stringify(parsedQueryString);
+    var parsedQueryString = require("qs").parse(parsed.search, {
+        allowPrototypes: false,
+        ignoreQueryPrefix: true,
+    });
+    return `?${require("qs").stringify(parsedQueryString)}`;
 }
 /**
  * response size
@@ -78,8 +79,7 @@ function getResponseTimeNs(req, res) {
         return undefined;
     }
     // calculate diff
-    var ns = (res._startAt[0] - req._startAt[0]) * 1e9
-        + (res._startAt[1] - req._startAt[1]);
+    var ns = (res._startAt[0] - req._startAt[0]) * 1e9 + (res._startAt[1] - req._startAt[1]);
     return ns;
 }
 /**
@@ -95,8 +95,8 @@ function getIp(req) {
  * Log level
  */
 function getLogLevel(req, res) {
-    var statusCode = res.statusCode;
-    var result;
+    const statusCode = res.statusCode;
+    let result;
     if (statusCode >= 499) {
         result = KayveeLogger.Error;
     }
@@ -105,66 +105,50 @@ function getLogLevel(req, res) {
     }
     return result;
 }
-/**
- * Get canary status
- */
-function isCanary() {
-    return (process.env._CANARY === "1") || ("_POD_SHORTNAME" in process.env && process.env._POD_SHORTNAME.includes("-canary"));
-}
 /*
  * Default handlers
  */
 var defaultHandlers = [
     // Request method
-    function (req) { return ({ method: req.method }); },
+    (req) => ({ method: req.method }),
     // Path (URL without query params)
-    function (req) { return ({ path: getBaseUrl(req) }); },
+    (req) => ({ path: getBaseUrl(req) }),
     // Query params
-    function (req) { return ({ params: getQueryParams(req) }); },
+    (req) => ({ params: getQueryParams(req) }),
     // Response size
-    function (req, res) { return ({ "response-size": getResponseSize(res) }); },
+    (req, res) => ({ "response-size": getResponseSize(res) }),
     // Response time (ns)
-    function (req, res) { return ({ "response-time": getResponseTimeNs(req, res) }); },
+    (req, res) => ({ "response-time": getResponseTimeNs(req, res) }),
     // Status code
-    function (req, res) { return ({ "status-code": res.statusCode }); },
+    (req, res) => ({ "status-code": res.statusCode }),
     // Ip address
-    function (req) { return ({ ip: getIp(req) }); },
+    (req) => ({ ip: getIp(req) }),
     // Via -- what library/code produced this log?
-    function () { return ({ via: "kayvee-middleware" }); },
+    () => ({ via: "kayvee-middleware" }),
     // Kayvee's reserved fields
     // Log level
-    function (req, res) { return ({ level: getLogLevel(req, res) }); },
+    (req, res) => ({ level: getLogLevel(req, res) }),
     // Source -- which app emitted this log?
     // -> Gets passed in among `options` during library initialization
     // Title
-    function () { return ({ title: "request-finished" }); },
-    // During the transition to pods, let's keep the canary field accurate
-    // whether it's in the canary pod or a canary container in homepod
-    function () { return ({ canary: isCanary() }); },
+    () => ({ title: "request-finished" }),
 ];
-var defaultContextHandlers = [];
-function handlerData(handlers) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    var data = {};
-    handlers.forEach(function (h) {
+const defaultContextHandlers = [];
+function handlerData(handlers, ...args) {
+    const data = {};
+    handlers.forEach((h) => {
         try {
-            var handler_data = h.apply(void 0, args);
+            const handler_data = h(...args);
             _.extend(data, handler_data);
         }
         catch (e) {
+            // swallow invalid handler
         }
     });
     return data;
 }
-var ContextLogger = (function () {
-    function ContextLogger(logger, handlers) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-        }
+class ContextLogger {
+    constructor(logger, handlers, ...args) {
         this.logger = null;
         this.handlers = [];
         this.args = [];
@@ -172,34 +156,25 @@ var ContextLogger = (function () {
         this.handlers = handlers;
         this.args = args;
     }
-    ContextLogger.prototype._contextualData = function (data) {
-        return _.extend(handlerData.apply(void 0, [this.handlers].concat(this.args)), data);
-    };
-    return ContextLogger;
-}());
-var _loop_1 = function(func) {
+    _contextualData(data) {
+        return _.extend(handlerData(this.handlers, ...this.args), data);
+    }
+}
+for (const func of KayveeLogger.LEVELS) {
     ContextLogger.prototype[func] = function (title) {
-        this[(func + "D")](title, {});
+        this[`${func}D`](title, {});
     };
-    ContextLogger.prototype[(func + "D")] = function (title, data) {
-        this.logger[(func + "D")](title, this._contextualData(data));
+    ContextLogger.prototype[`${func}D`] = function (title, data) {
+        this.logger[`${func}D`](title, this._contextualData(data));
     };
-};
-for (var _i = 0, _a = KayveeLogger.LEVELS; _i < _a.length; _i++) {
-    var func = _a[_i];
-    _loop_1(func);
 }
-var _loop_2 = function(func) {
+for (const func of KayveeLogger.METRICS) {
     ContextLogger.prototype[func] = function (title, value) {
-        this[(func + "D")](title, value, {});
+        this[`${func}D`](title, value, {});
     };
-    ContextLogger.prototype[(func + "D")] = function (title, value, data) {
-        this.logger[(func + "D")](title, value, this._contextualData(data));
+    ContextLogger.prototype[`${func}D`] = function (title, value, data) {
+        this.logger[`${func}D`](title, value, this._contextualData(data));
     };
-};
-for (var _b = 0, _c = KayveeLogger.METRICS; _b < _c.length; _b++) {
-    var func = _c[_b];
-    _loop_2(func);
 }
 /*
  * User configuration is passed via an `options` object.
@@ -224,20 +199,20 @@ for (var _b = 0, _c = KayveeLogger.METRICS; _b < _c.length; _b++) {
  * base_handlers: e.g. [function(request, response) { return {"key":"val"}]
  *
  */
-var formatLine = function (options_arg) {
+var formatLine = (options_arg) => {
     var options = options_arg || {};
     // `source` is the one required field
     if (!options.source) {
-        throw (Error("Missing required config for 'source' in Kayvee middleware 'options'"));
+        throw Error("Missing required config for 'source' in Kayvee middleware 'options'");
     }
-    var router = KayveeLogger.getGlobalRouter();
-    return function (tokens, req, res) {
+    const router = KayveeLogger.getGlobalRouter();
+    return (tokens, req, res) => {
         // Build a dict of data to log
         var data = { _kvmeta: undefined }; // Adding _kvmeta here to make typescript compile happy
         // Add user-configured request headers
         var custom_headers = options.headers || [];
         var header_data = {};
-        custom_headers.forEach(function (h) {
+        custom_headers.forEach((h) => {
             // Header field names are case insensitive, so let's be consistent
             var lc = h.toLowerCase();
             header_data[lc] = req.headers[lc];
@@ -247,9 +222,9 @@ var formatLine = function (options_arg) {
         var custom_handlers = options.handlers || [];
         // Allow user to override `base_handlers`; provide sane default set of handlers
         var base_handlers = options.base_handlers || defaultHandlers;
-        base_handlers = base_handlers.concat([function () { return ({ source: options.source }); }]);
+        base_handlers = base_handlers.concat([() => ({ source: options.source })]);
         // Execute custom-handlers THEN base-handlers
-        var all_handlers = custom_handlers.concat(base_handlers);
+        const all_handlers = custom_handlers.concat(base_handlers);
         _.extend(data, handlerData(all_handlers, req, res));
         if (router) {
             data._kvmeta = router.route(data);
@@ -257,7 +232,7 @@ var formatLine = function (options_arg) {
         return kayvee.format(data);
     };
 };
-var defaultContextLoggerOpts = {
+const defaultContextLoggerOpts = {
     enabled: true,
     handlers: defaultContextHandlers,
 };
@@ -266,8 +241,7 @@ var defaultContextLoggerOpts = {
  * @public
  */
 if (process.env.NODE_ENV === "test") {
-    module.exports = function (clever_options, morgan_options) {
-        if (morgan_options === void 0) { morgan_options = { skip: null }; }
+    module.exports = (clever_options, morgan_options = { skip: null }) => {
         if (clever_options.ignore_dir) {
             morgan_options.skip = skip_path(clever_options.ignore_dir.directory, clever_options.ignore_dir.path);
         }
@@ -276,22 +250,21 @@ if (process.env.NODE_ENV === "test") {
     module.exports.ContextLogger = ContextLogger;
 }
 else {
-    module.exports = function (clever_options, context_logger_options) {
-        if (context_logger_options === void 0) { context_logger_options = defaultContextLoggerOpts; }
+    module.exports = (clever_options, context_logger_options = defaultContextLoggerOpts) => {
         // `source` is the one required field
         if (!clever_options.source) {
             throw new Error("Missing required config for 'source' in Kayvee middleware 'options'");
         }
-        var logger = new KayveeLogger(clever_options.source);
-        var morgan_options = {
+        const logger = new KayveeLogger(clever_options.source);
+        const morgan_options = {
             stream: process.stderr,
             skip: null,
         };
         if (clever_options.ignore_dir) {
             morgan_options.skip = skip_path(clever_options.ignore_dir.directory, clever_options.ignore_dir.path);
         }
-        var morgan_logger = morgan(formatLine(clever_options), morgan_options);
-        return function (req, res, next) {
+        const morgan_logger = morgan(formatLine(clever_options), morgan_options);
+        return (req, res, next) => {
             if (context_logger_options.enabled) {
                 req.log = new ContextLogger(logger, context_logger_options.handlers, req);
             }

package/build/lib/router/index.js

@@ -4,20 +4,20 @@ var schema = require("./schema_definitions");
 var yaml = require("js-yaml");
 var _ = require("underscore");
 var packageJson = require("../../package.json");
-var kvVersion = packageJson.version;
-var teamName = process.env._TEAM_OWNER || "UNSET";
-var reEnvvarTokens = new RegExp("\\$\\{(.+?)\\}", "g");
-var reFieldTokens = new RegExp("%\\{(.+?)\\}", "g");
+const kvVersion = packageJson.version;
+const teamName = process.env._TEAM_OWNER || "UNSET";
+const reEnvvarTokens = new RegExp("\\$\\{(.+?)\\}", "g");
+const reFieldTokens = new RegExp("%\\{(.+?)\\}", "g");
 // For performance reason this code is intentionally redundant and not-inlined.
 // Removing redundancy and inlining this function some how makes performance worst.
 function substituteEnvVars(obj, subber) {
-    var rtn = {};
-    var replacer = function (s) { return s.replace(reEnvvarTokens, function (__, p1) { return subber(p1); }); };
-    for (var key in obj) {
-        var val = obj[key];
+    const rtn = {};
+    const replacer = (s) => s.replace(reEnvvarTokens, (__, p1) => subber(p1));
+    for (const key in obj) {
+        const val = obj[key];
         if (Array.isArray(val)) {
-            var updatedVals = Array(val.length);
-            for (var i = 0; i < val.length; i++) {
+            const updatedVals = Array(val.length);
+            for (let i = 0; i < val.length; i++) {
                 updatedVals[i] = replacer(val[i]);
             }
             rtn[key] = updatedVals;
@@ -29,51 +29,51 @@ function substituteEnvVars(obj, subber) {
     return rtn;
 }
 function deepKey(obj, key) {
-    var path = key.split(".");
-    var idx = 0;
-    var val = obj;
+    const path = key.split(".");
+    let idx = 0;
+    let val = obj;
     do {
         val = val[path[idx++]];
     } while (val && idx < path.length);
     return val;
 }
 function fieldMatches(obj, field, values) {
-    var val = obj[field] || deepKey(obj, field);
+    const val = obj[field] || deepKey(obj, field);
     if (val == null || val === "") {
         return false;
     }
     if (values[0] === "*") {
         return true;
     }
-    for (var i = 0; i < values.length; i++) {
+    for (let i = 0; i < values.length; i++) {
         if (values[i] === val) {
             return true;
         }
     }
     return false;
 }
-var Rule = (function () {
-    function Rule(name, matchers, output) {
+class Rule {
+    constructor(name, matchers, output) {
         this.name = null;
         this.matchers = null;
         this.output = null;
         this.name = name;
         this.matchers = matchers;
-        var envMissing = [];
-        this.output = substituteEnvVars(output, function (k) {
-            var val = process.env[k];
+        const envMissing = [];
+        this.output = substituteEnvVars(output, (k) => {
+            const val = process.env[k];
             if (val == null) {
                 envMissing.push(k);
             }
             return val;
         });
         if (envMissing.length > 0) {
-            throw new Error("Missing env var(s): " + envMissing.join(", "));
+            throw new Error(`Missing env var(s): ${envMissing.join(", ")}`);
         }
-        Object.keys(matchers).forEach(function (field) {
-            var fieldVals = matchers[field];
+        Object.keys(matchers).forEach((field) => {
+            const fieldVals = matchers[field];
             if (fieldVals.indexOf("*") !== -1 && fieldVals.length > 1) {
-                throw new Error(("Invalid matcher values in " + name + "." + field + ".\n") +
+                throw new Error(`Invalid matcher values in ${name}.${field}.\n` +
                     "Wildcard matcher can't co-exist with other matchers.");
             }
         });
@@ -83,24 +83,24 @@ var Rule = (function () {
         this.output.rule = this.name;
     }
     // matches returns true if `msg` matches against this rule
-    Rule.prototype.matches = function (msg) {
-        for (var field in this.matchers) {
+    matches(msg) {
+        for (const field in this.matchers) {
             if (!fieldMatches(msg, field, this.matchers[field])) {
                 return false;
             }
         }
         return true;
-    };
+    }
     // returns the output with kv substitutions performed
-    Rule.prototype.outputFor = function (msg) {
-        var rtn = {};
-        var subst = function (__, k) { return msg[k] || deepKey(msg, k) || "KEY_NOT_FOUND"; };
-        var replacer = function (s) { return s.replace(reFieldTokens, subst); };
-        for (var key in this.output) {
-            var val = this.output[key];
+    outputFor(msg) {
+        const rtn = {};
+        const subst = (__, k) => msg[k] || deepKey(msg, k) || "KEY_NOT_FOUND";
+        const replacer = (s) => s.replace(reFieldTokens, subst);
+        for (const key in this.output) {
+            const val = this.output[key];
             if (Array.isArray(val)) {
-                var updatedVals = Array(val.length);
-                for (var i = 0; i < val.length; i++) {
+                const updatedVals = Array(val.length);
+                for (let i = 0; i < val.length; i++) {
                     updatedVals[i] = replacer(val[i]);
                 }
                 rtn[key] = updatedVals;
@@ -110,9 +110,8 @@ var Rule = (function () {
             }
         }
         return rtn;
-    };
-    return Rule;
-}());
+    }
+}
 // validateKVConfig ensures that `routes` matches the config schema. We have this
 // function instead of just doing a plain jsonschema.validate in order to get
 // better error messages for the "output" object (by default jsonschema would
@@ -120,11 +119,11 @@ var Rule = (function () {
 // formats, but won't tell you what's wrong because it doesn't let you
 // condition on the output.type property).
 function validateKVConfig(config) {
-    var validator = new jsonschema.Validator();
-    var results = validator.validate(config, schema);
+    const validator = new jsonschema.Validator();
+    const results = validator.validate(config, schema);
     return {
         valid: results.valid,
-        errors: results.errors.map(function (err) { return err.stack; }),
+        errors: results.errors.map((err) => err.stack),
     };
 }
 // parseConfig parses and validates the configuration passed as a string. It
@@ -132,53 +131,53 @@ function validateKVConfig(config) {
 // it was successfully parsed, rules is an array of rules, and errors is an
 // array of errors.
 function parseConfig(fileString) {
-    var config;
+    let config;
     try {
         config = yaml.safeLoad(fileString);
     }
     catch (e) {
         return { valid: false, rules: [], errors: [e] };
     }
-    var validateRes = validateKVConfig(config);
+    const validateRes = validateKVConfig(config);
     if (!validateRes.valid) {
         return _.assign(validateRes, { rules: [] });
     }
     try {
-        var rulesObj = _.mapObject(config.routes, function (elem, name) { return new Rule(name, elem.matchers, elem.output); });
-        var rules = _.values(rulesObj);
-        return { valid: true, rules: rules, errors: [] };
+        const rulesObj = _.mapObject(config.routes, (elem, name) => new Rule(name, elem.matchers, elem.output));
+        const rules = _.values(rulesObj);
+        return { valid: true, rules, errors: [] };
     }
     catch (e) {
         return { valid: false, rules: [], errors: [e] };
     }
 }
-var Router = (function () {
-    function Router(rules) {
+class Router {
+    constructor(rules) {
         this.rules = null;
         this.rules = rules || [];
     }
     // loadConfig reads in the config located at `filename` and sets the routing
     // rules to what it finds there. It should be a YAML-formatted file with
     // routing rules placed under the `routes` key on the root object.
-    Router.prototype.loadConfig = function (filename) {
-        var data = fs.readFileSync(filename, "utf8");
+    loadConfig(filename) {
+        const data = fs.readFileSync(filename, "utf8");
         this._loadConfigString(data);
-    };
-    Router.prototype._loadConfigString = function (configStr) {
-        var parsedRules = parseConfig(configStr);
+    }
+    _loadConfigString(configStr) {
+        const parsedRules = parseConfig(configStr);
         if (!parsedRules.valid) {
             throw new Error(parsedRules.errors);
         }
         this.rules = parsedRules.rules;
-    };
+    }
     // route matches the log line `msg` against all loaded rules and returns a
     // metadata object describing the outputs it should be sent to based on that
     // matching. logger.ts will attach this to log lines under the `_kvmeta`
     // property.
-    Router.prototype.route = function (msg) {
-        var outputs = [];
-        for (var i = 0; i < this.rules.length; i++) {
-            var rule = this.rules[i];
+    route(msg) {
+        const outputs = [];
+        for (let i = 0; i < this.rules.length; i++) {
+            const rule = this.rules[i];
             if (rule.matches(msg)) {
                 outputs.push(rule.outputFor(msg));
             }
@@ -189,10 +188,9 @@ var Router = (function () {
             kv_language: "js",
             routes: outputs,
         };
-    };
-    return Router;
-}());
+    }
+}
 module.exports = {
-    Router: Router,
-    Rule: Rule,
+    Router,
+    Rule,
 };

package/build/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kayvee",
   "description": "Write data to key=val pairs, for human and machine readability",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -16,19 +16,27 @@
     "underscore": "^1.8.3"
   },
   "devDependencies": {
+    "@clever/prettier-config": "1.0.0",
+    "@types/mocha": "^8.0.3",
+    "@types/node": "^12.12.68",
+    "@typescript-eslint/eslint-plugin": "^5.2.0",
+    "@typescript-eslint/parser": "^5.2.0",
     "babel-eslint": "^6.0.2",
     "benchmark": "^2.1.1",
-    "eslint": "^2.7.0",
+    "eslint": "^7.11.0",
     "eslint-config-airbnb": "^7.0.0",
-    "eslint-plugin-jsx-a11y": "^0.6.2",
-    "eslint-plugin-react": "^4.3.0",
+    "eslint-config-prettier": "^6.12.0",
+    "eslint-formatter-summary": "^1.1.0",
+    "eslint-plugin-jsx-a11y": "^6.3.1",
+    "eslint-plugin-react": "^7.21.5",
+    "eslint-plugin-react-hooks": "^4.1.2",
     "express": "^4.13.4",
-    "mocha": "^2.5.3",
+    "mocha": "^3.5.3",
+    "prettier": "2.1.2",
     "sinon": "^1.17.4",
     "supertest": "^1.2.0",
-    "ts-node": "^0.7.1",
-    "tslint": "^3.7.4",
-    "typescript": "^1.8.9"
+    "ts-node": "^9.0.0",
+    "typescript": "^3.9.10"
   },
   "scripts": {
     "test": "make -Br test",