kayvee 3.18.0 → 4.0.0

package/lib/router/index.ts

@@ -1,234 +0,0 @@
-var fs = require("fs");
-var jsonschema = require("jsonschema");
-var schema = require("./schema_definitions");
-var yaml = require("js-yaml");
-var _ = require("underscore");
-
-var packageJson = require("../../package.json");
-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) {
-  const rtn = {};
-  const replacer = (s) => s.replace(reEnvvarTokens, (__, p1) => subber(p1));
-
-  for (const key in obj) {
-    const val = obj[key];
-
-    if (Array.isArray(val)) {
-      const updatedVals = Array(val.length);
-      for (let i = 0; i < val.length; i++) {
-        updatedVals[i] = replacer(val[i]);
-      }
-      rtn[key] = updatedVals;
-    } else {
-      rtn[key] = replacer(val);
-    }
-  }
-
-  return rtn;
-}
-
-function deepKey(obj, key) {
-  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) {
-  const val = obj[field] || deepKey(obj, field);
-
-  if (val == null || val === "") {
-    return false;
-  }
-
-  if (values[0] === "*") {
-    return true;
-  }
-
-  for (let i = 0; i < values.length; i++) {
-    if (values[i] === val) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-class Rule {
-  name = null;
-  matchers = null;
-  output = null;
-
-  constructor(name, matchers, output) {
-    this.name = name;
-    this.matchers = matchers;
-
-    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(", ")}`);
-    }
-
-    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` +
-            "Wildcard matcher can't co-exist with other matchers.",
-        );
-      }
-    });
-
-    if (this.output.type === "alerts" || this.output.type === "metrics") {
-      this.output.value_field = this.output.value_field || "value";
-    }
-
-    this.output.rule = this.name;
-  }
-
-  // matches returns true if `msg` matches against this rule
-  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
-  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)) {
-        const updatedVals = Array(val.length);
-        for (let i = 0; i < val.length; i++) {
-          updatedVals[i] = replacer(val[i]);
-        }
-        rtn[key] = updatedVals;
-      } else {
-        rtn[key] = replacer(val);
-      }
-    }
-
-    return rtn;
-  }
-}
-
-// 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
-// just tell you that the output block doesn't match any of the known output
-// formats, but won't tell you what's wrong because it doesn't let you
-// condition on the output.type property).
-function validateKVConfig(config) {
-  const validator = new jsonschema.Validator();
-  const results = validator.validate(config, schema);
-
-  return {
-    valid: results.valid,
-    errors: results.errors.map((err) => err.stack),
-  };
-}
-
-// parseConfig parses and validates the configuration passed as a string. It
-// returns an object of the form {valid, rules, errors}, where valid is true if
-// it was successfully parsed, rules is an array of rules, and errors is an
-// array of errors.
-function parseConfig(fileString) {
-  let config;
-  try {
-    config = yaml.safeLoad(fileString);
-  } catch (e) {
-    return { valid: false, rules: [], errors: [e] };
-  }
-  const validateRes = validateKVConfig(config);
-  if (!validateRes.valid) {
-    return _.assign(validateRes, { rules: [] });
-  }
-  try {
-    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] };
-  }
-}
-
-class Router {
-  rules = null;
-
-  constructor(rules) {
-    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.
-  loadConfig(filename) {
-    const data = fs.readFileSync(filename, "utf8");
-    this._loadConfigString(data);
-  }
-
-  _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.
-  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));
-      }
-    }
-
-    return {
-      team: teamName,
-      kv_version: kvVersion,
-      kv_language: "js",
-      routes: outputs,
-    };
-  }
-}
-
-module.exports = {
-  Router,
-  Rule,
-};

package/lib/router/schema_definitions.json

@@ -1,158 +0,0 @@
-{
-  "description": "Last modified: 02/08/2017",
-  "required": ["routes"],
-  "properties": {
-    "routes": { "$ref": "#/definitions/routes" }
-  },
-  "definitions": {
-    "routes": {
-      "type": "object",
-      "additionalProperties": false,
-      "patternProperties": {
-        "^[a-zA-Z0-9-_]+$": { "$ref": "#/definitions/rule" }
-      }
-    },
-    "rule": {
-      "title": "Rule",
-      "type": "object",
-      "required": ["matchers", "output"],
-      "additionalProperties": false,
-      "properties": {
-        "matchers": { "$ref": "#/definitions/matchers" },
-        "output": { "$ref": "#/definitions/output" }
-      }
-    },
-    "matchers": {
-      "type": "object",
-      "minProperties": 1,
-      "additionalProperties": false,
-      "patternProperties": {
-        "^[^%\\${}]+$": { "$ref": "#/definitions/matcherArr" }
-      }
-    },
-    "output": {
-      "type": "object",
-      "oneOf": [
-        { "$ref": "#/definitions/metricsOutput" },
-        { "$ref": "#/definitions/alertsOutput" },
-        { "$ref": "#/definitions/analyticsOutput" },
-        { "$ref": "#/definitions/notificationsOutput" }
-      ]
-    },
-    "metricsOutput": {
-      "title": "Metrics Output",
-      "type": "object",
-      "oneOf": [
-        {
-          "additionalProperties": false,
-          "required": ["type", "series", "dimensions"],
-          "properties": {
-            "type": { "type": "string", "pattern": "^metrics$" },
-            "series": { "$ref": "#/definitions/envVarSubstValue" },
-            "dimensions": { "$ref": "#/definitions/flatValueArr" }
-          }
-        },
-        {
-          "additionalProperties": false,
-          "required": ["type", "series", "dimensions", "value_field"],
-          "properties": {
-            "type": { "type": "string", "pattern": "^metrics$" },
-            "series": { "$ref": "#/definitions/envVarSubstValue" },
-            "dimensions": { "$ref": "#/definitions/flatValueArr" },
-            "value_field": { "$ref": "#/definitions/flatValue" }
-          }
-        }
-      ]
-    },
-    "alertsOutput": {
-      "type": "object",
-      "oneOf": [
-        {
-          "additionalProperties": false,
-          "required": ["type", "series", "dimensions", "stat_type"],
-          "properties": {
-            "type": { "type": "string", "pattern": "^alerts$" },
-            "series": { "$ref": "#/definitions/envVarSubstValue" },
-            "dimensions": {
-              "type": "array",
-              "uniqueItems": true,
-              "items": { "$ref": "#/definitions/flatValue" }
-            },
-            "stat_type": { "type": "string", "enum": ["counter", "gauge"] }
-          }
-        },
-        {
-          "additionalProperties": false,
-          "required": ["type", "series", "dimensions", "stat_type", "value_field"],
-          "properties": {
-            "type": { "type": "string", "pattern": "^alerts$" },
-            "series": { "$ref": "#/definitions/envVarSubstValue" },
-            "dimensions": {
-              "type": "array",
-              "uniqueItems": true,
-              "items": { "$ref": "#/definitions/flatValue" }
-            },
-            "stat_type": { "type": "string", "enum": ["counter", "gauge"] },
-            "value_field": { "$ref": "#/definitions/flatValue" }
-          }
-        }
-      ]
-    },
-    "analyticsOutput": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["type", "series"],
-      "properties": {
-        "type": {
-          "type": "string",
-          "pattern": "^analytics$"
-        },
-        "series": { "$ref": "#/definitions/envVarSubstValue" }
-      }
-    },
-    "notificationsOutput": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["type", "channel", "icon", "message", "user"],
-      "properties": {
-        "type": {
-          "type": "string",
-          "pattern": "^notifications$"
-        },
-        "channel": { "$ref": "#/definitions/kvSubstValue" },
-        "icon": { "$ref": "#/definitions/envVarSubstValue" },
-        "message": { "$ref": "#/definitions/kvSubstValue" },
-        "user": { "$ref": "#/definitions/envVarSubstValue" }
-      }
-    },
-    "flatValue": {
-      "type": "string",
-      "pattern": "^[^%\\${}]+$"
-    },
-    "flatValueArr": {
-      "type": "array",
-      "minItems": 1,
-      "uniqueItems": true,
-      "items": { "$ref": "#/definitions/flatValue" }
-    },
-    "matcherArr": {
-      "type": "array",
-      "minItems": 1,
-      "uniqueItems": true,
-      "items": {
-        "oneOf": [
-          { "$ref": "#/definitions/flatValue" },
-          { "type": "boolean" }
-        ]
-      }
-    },
-    "envVarSubstValue": {
-      "type": "string",
-      "pattern": "^([^\\$%{}]|\\$\\{[^%\\${}]+\\})+$"
-    },
-    "kvSubstValue": {
-      "type": "string",
-      "pattern": "^([^\\$%{}]|\\$\\{[^%\\${}]+\\}|%\\{[^%\\${}]+\\})+$"
-    }
-  }
-}

package/test/context_logger.ts

@@ -1,76 +0,0 @@
-var assert = require("assert");
-var sinon = require("sinon");
-
-var middleware = require("../lib/middleware");
-var KayveeLogger = require("../lib/logger/logger");
-
-describe("ContextLogger", () => {
-  const fake_req = { key1: "val1" };
-  const fake_handler = (req) => ({ log_key1: req.key1, key2: "val2" });
-
-  for (const level of KayveeLogger.LEVELS) {
-    it(`correctly adds context to ${level} calls`, () => {
-      const spy = sinon.spy();
-      const stub_logger = {};
-      stub_logger[`${level}D`] = spy;
-      const log = new middleware.ContextLogger(stub_logger, [fake_handler], fake_req);
-      log[level]("test_title");
-      const expected_context = { log_key1: "val1", key2: "val2" };
-      assert(spy.calledWithExactly("test_title", expected_context));
-      assert.equal(spy.callCount, 1);
-    });
-
-    it(`correctly adds context to ${level}D calls`, () => {
-      const spy = sinon.spy();
-      const stub_logger = {};
-      stub_logger[`${level}D`] = spy;
-      const log = new middleware.ContextLogger(stub_logger, [fake_handler], fake_req);
-      log[`${level}D`]("test_title", { key2: "new_value", key3: "val3" });
-      const expected_data = {
-        log_key1: "val1",
-        key2: "new_value",
-        key3: "val3",
-      };
-      assert(spy.calledWithExactly("test_title", expected_data));
-      assert.equal(spy.callCount, 1);
-    });
-  }
-
-  for (const metric of KayveeLogger.METRICS) {
-    it(`correctly adds context to ${metric} calls`, () => {
-      const spy = sinon.spy();
-      const stub_logger = {};
-      stub_logger[`${metric}D`] = spy;
-      const log = new middleware.ContextLogger(stub_logger, [fake_handler], fake_req);
-      log[metric]("test_title", 3);
-      const expected_context = { log_key1: "val1", key2: "val2" };
-      assert(spy.calledWithExactly("test_title", 3, expected_context));
-      assert.equal(spy.callCount, 1);
-    });
-
-    it(`correctly adds context to ${metric}D calls`, () => {
-      const spy = sinon.spy();
-      const stub_logger = {};
-      stub_logger[`${metric}D`] = spy;
-      const log = new middleware.ContextLogger(stub_logger, [fake_handler], fake_req);
-      log[`${metric}D`]("test_title", 3, { key2: "new_value", key3: "val3" });
-      const expected_data = {
-        log_key1: "val1",
-        key2: "new_value",
-        key3: "val3",
-      };
-      assert(spy.calledWithExactly("test_title", 3, expected_data));
-      assert.equal(spy.callCount, 1);
-    });
-  }
-
-  it("correctly handles being instantiated with empty list of handlers", () => {
-    const spy = sinon.spy();
-    const stub_logger = { infoD: spy };
-    const log = new middleware.ContextLogger(stub_logger, [], fake_req);
-    log.info("test_title");
-    const expected_context = {};
-    assert(spy.calledWithExactly("test_title", expected_context));
-    assert.equal(spy.callCount, 1);
-  });
-});

package/test/kayvee.ts

@@ -1,50 +0,0 @@
-var kv = require("../lib/kayvee");
-var assert = require("assert");
-var _ = require("underscore");
-var fs = require("fs");
-
-describe("kayvee", () => {
-  const tests = JSON.parse(fs.readFileSync("test/tests.json"));
-  describe(".format", () => {
-    _.each(tests.format, (spec) => {
-      it(spec.title, () => {
-        const actual = kv.format(spec.input.data);
-        const expected = spec.output;
-        assert.deepEqual(
-          JSON.parse(actual),
-          _.extend({ deploy_env: "testing", wf_id: "abc" }, JSON.parse(expected)),
-        );
-      });
-    });
-  });
-
-  describe(".format with Errors", () => {
-    it("encodes Error objects", () => {
-      const actual = kv.format({ err: Error("An Error Message") });
-      const expected = {
-        deploy_env: "testing",
-        wf_id: "abc",
-        err: "Error: An Error Message",
-      };
-      assert.deepEqual(JSON.parse(actual), expected);
-    });
-  });
-
-  describe(".formatLog", () => {
-    _.each(tests.formatLog, (spec) => {
-      it(spec.title, () => {
-        const actual = kv.formatLog(
-          spec.input.source,
-          spec.input.level,
-          spec.input.title,
-          spec.input.data,
-        );
-        const expected = spec.output;
-        assert.deepEqual(
-          JSON.parse(actual),
-          _.extend({ deploy_env: "testing", wf_id: "abc" }, JSON.parse(expected)),
-        );
-      });
-    });
-  });
-});

package/test/kvconfig.yml

@@ -1,14 +0,0 @@
-routes:
-  all-kv_middleware:
-    matchers:
-      via: [ "kayvee-middleware" ]
-    output:
-      type: "analytics"
-      series: "requests.everything"
-  rule-two:
-    matchers:
-      title: [ "foo-title" ]
-      deploy_env: [ "testing" ]
-    output:
-      type: "analytics"
-      series: "requests.everything"