kayvee 3.18.0 → 4.0.0

package/build/test/router.js

@@ -1,451 +0,0 @@
-var assert = require("assert");
-var router = require("../lib/router");
-describe("router.Router", () => {
-    describe("constructor", () => {
-        it("parses well formatted configs", () => {
-            process.env.SCHOOL = "Hogwarts";
-            const conf = `
-routes:
-  rule-one:
-    matchers:
-      title: ["authorize-app"]
-    output:
-      type: "notifications"
-      channel: "%{foo.bar}"
-      icon: ":rocket:"
-      message: "authorized %{foo.bar} in \${SCHOOL}"
-      user: "@fishman"
-  rule-two:
-    matchers:
-      foo.bar: ["multiple", "matches"]
-      baz: ["whatever"]
-    output:
-      type: "alerts"
-      series: "other-series"
-      dimensions: ["baz"]
-      stat_type: "gauge"
-  rule-three:
-    matchers:
-      foo.bar: ["multiple", "matches"]
-      baz: ["whatever"]
-    output:
-      type: "alerts"
-      series: "other-series"
-      dimensions: ["baz"]
-      stat_type: "gauge"
-      value_field: "hello"
-  rule-four:
-    matchers:
-      foo.bar: ["multiple", "matches"]
-      baz: ["whatever"]
-    output:
-      type: "alerts"
-      series: "other-series"
-      dimensions: []
-      stat_type: "gauge"
-  rule-five:
-    matchers:
-      foo.bar: [true]
-      baz: [false]
-    output:
-      type: "alerts"
-      series: "other-series"
-      dimensions: []
-      stat_type: "gauge"
-`;
-            const expected = [
-                new router.Rule("rule-one", { title: ["authorize-app"] }, {
-                    type: "notifications",
-                    channel: "%{foo.bar}",
-                    icon: ":rocket:",
-                    message: "authorized %{foo.bar} in Hogwarts",
-                    user: "@fishman",
-                }),
-                new router.Rule("rule-two", { "foo.bar": ["multiple", "matches"], baz: ["whatever"] }, {
-                    type: "alerts",
-                    series: "other-series",
-                    dimensions: ["baz"],
-                    stat_type: "gauge",
-                    value_field: "value",
-                }),
-                new router.Rule("rule-three", { "foo.bar": ["multiple", "matches"], baz: ["whatever"] }, {
-                    type: "alerts",
-                    series: "other-series",
-                    dimensions: ["baz"],
-                    stat_type: "gauge",
-                    value_field: "hello",
-                }),
-                new router.Rule("rule-four", { "foo.bar": ["multiple", "matches"], baz: ["whatever"] }, {
-                    type: "alerts",
-                    series: "other-series",
-                    dimensions: [],
-                    stat_type: "gauge",
-                    value_field: "value",
-                }),
-                new router.Rule("rule-five", { "foo.bar": [true], baz: [false] }, {
-                    type: "alerts",
-                    series: "other-series",
-                    dimensions: [],
-                    stat_type: "gauge",
-                    value_field: "value",
-                }),
-            ];
-            const actual = new router.Router();
-            actual._loadConfigString(conf);
-            assert.deepEqual(actual.rules, expected);
-        });
-        it("rejects specials in matchers", () => {
-            const confTmpl = (v) => `
-routes:
-  non-string-values:
-    matchers:
-      no-numbers: [${v}]
-    output:
-      type: "analytics"
-      series: "fun"
-`;
-            // Make sure the template works
-            const conf = confTmpl('"valid"');
-            const actual = new router.Router();
-            assert.doesNotThrow(() => actual._loadConfigString(conf));
-            for (const invalidVal of ["5", "[]", "{}"]) {
-                const invalidConf = confTmpl(invalidVal);
-                assert.throws(() => actual._loadConfigString(invalidConf));
-            }
-            assert.throws(() => actual._loadConfigString(confTmpl('""')));
-            return;
-        });
-        it("rejects duplicates in matchers", () => {
-            const confTmpl = (v) => `
-routes:
-  sloppy:
-    matchers:
-      title: [${v}]
-    output:
-      type: "analytics"
-      series: "fun"
-`;
-            const actual = new router.Router();
-            const validConf = confTmpl('"non-repeated", "name"');
-            assert.doesNotThrow(() => actual._loadConfigString(validConf));
-            const invalidConf = confTmpl('"repeated", "repeated", "name"');
-            assert.throws(() => actual._loadConfigString(invalidConf));
-        });
-        it("requires correct types in outputs", () => {
-            const confTmpl = (series, dimensions) => `
-routes:
-  wrong:
-    matchers:
-      title: ["test"]
-    output:
-      type: "alerts"
-      series: ${series}
-      dimensions: ${dimensions}
-      value_field: "hihi"
-      stat_type: "gauge"
-`;
-            const actual = new router.Router();
-            const validConf = confTmpl('"my-series"', '["dim1", "dim2"]');
-            assert.doesNotThrow(() => actual._loadConfigString(validConf));
-            const invalidConf0 = confTmpl('["my-series"]', '["dim1", "dim2"]');
-            assert.throws(() => actual._loadConfigString(invalidConf0));
-            const invalidConf1 = confTmpl('"my-series"', '"dim1"');
-            assert.throws(() => actual._loadConfigString(invalidConf1));
-        });
-        it("requires all keys in outputs", () => {
-            const confTmpl = (v) => `
-routes:
-  wrong:
-    matchers:
-      title: ["test"]
-    output:
-      type: "alerts"${v}
-      dimensions: ["dim1", "dim2"]
-      stat_type: "gauge"
-`;
-            const actual = new router.Router();
-            const validConf = confTmpl(`
-      series: "whatever"`);
-            assert.doesNotThrow(() => actual._loadConfigString(validConf));
-            const invalidConf = confTmpl("");
-            assert.throws(() => actual._loadConfigString(invalidConf));
-        });
-        it("doesn't allow extra keys", () => {
-            const confTmpl = (v) => `
-routes:
-  wrong:
-    matchers:
-      title: ["test"]
-    output:
-      type: "metrics"${v}
-      dimensions: ["dim1", "dim2"]
-`;
-            const actual = new router.Router();
-            const validConf = confTmpl(`
-      series: "whatever"`);
-            assert.doesNotThrow(() => actual._loadConfigString(validConf));
-            const invalidConf = confTmpl(`
-      series: "whatever"
-      something-else: "hi there"`);
-            assert.throws(() => actual._loadConfigString(invalidConf));
-        });
-        it("errors on type-os", () => {
-            const actual = new router.Router();
-            let config;
-            config = `
-route: # Should be routes (plural)
-  string-values:
-    matchers:
-      errors: [ "type-o" ]
-    output:
-      type: "analytics"
-      series: "fun"
-`;
-            assert.throws(() => actual._loadConfigString(config));
-            config = `
-routes:
-  string-values:
-    matcher: # Should be matchers (plural)
-      errors: [ "type-o" ]
-    output:
-      type: "analytics"
-      series: "fun"
-`;
-            assert.throws(() => actual._loadConfigString(config));
-            config = `
-routes:
-  string-values:
-    matchers:
-      errors: [ "type-o" ]
-    outputs: # Should be output (signular)
-      type: "analytics"
-      series: "fun"
-`;
-            assert.throws(() => actual._loadConfigString(config));
-            config = `
-routes:
-  $invalid-string-values: # Invalid rule name
-    matchers:
-      errors: [ "type-o" ]
-    output:
-      type: "analytics"
-      series: "fun"
-`;
-            assert.throws(() => actual._loadConfigString(config));
-            config = `
-routes:
-  string-values:
-    matchers:
-      errors: [ "type-o" ]
-    output:
-      type: "analytic" # Should be analytics (plural)p
-      series: "fun"
-`;
-            assert.throws(() => actual._loadConfigString(config));
-            config = `
-routes:
-  string-values:
-    matchers:
-      errors: [ "*", "type-o" ] # A wildcard cannot exist with other matchers
-    output:
-      type: "analytics"
-      series: "fun"
-`;
-            assert.throws(() => actual._loadConfigString(config));
-        });
-    });
-    describe("route", () => {
-        it("matches one or more rule and returns appropriate outputs", () => {
-            const r = new router.Router([
-                new router.Rule("rule-one", { title: ["hello", "hi"], foo: ["bar", "baz"] }, { channel: "#-%{foo}-", dimensions: ["-%{foo}-"] }),
-                new router.Rule("rule-two", { "bing.bong": ["buzz"] }, { series: "x" }),
-            ]);
-            const msg0 = {
-                title: "hi",
-                foo: "bar",
-            };
-            const expected0 = [
-                {
-                    rule: "rule-one",
-                    channel: "#-bar-",
-                    dimensions: ["-bar-"],
-                },
-            ];
-            const actual0 = r.route(msg0).routes;
-            assert.deepEqual(expected0, actual0);
-            const msg1 = {
-                title: "hi",
-                bing: {
-                    bong: "buzz",
-                },
-            };
-            const expected1 = [
-                {
-                    rule: "rule-two",
-                    series: "x",
-                },
-            ];
-            const actual1 = r.route(msg1).routes;
-            assert.deepEqual(expected1, actual1);
-            const msg2 = {
-                title: "hello",
-                foo: "baz",
-                bing: {
-                    bong: "buzz",
-                },
-            };
-            const expected2 = [
-                {
-                    rule: "rule-one",
-                    channel: "#-baz-",
-                    dimensions: ["-baz-"],
-                },
-                {
-                    rule: "rule-two",
-                    series: "x",
-                },
-            ];
-            const actual2 = r.route(msg2).routes;
-            assert.deepEqual(expected2, actual2);
-        });
-    });
-});
-describe("router.Rule", () => {
-    describe("matches", () => {
-        it("works on simple cases", () => {
-            const r = new router.Rule("test-rule", { title: ["hello", "hi"], foo: ["bar"] }, {});
-            assert(r.matches({
-                title: "hello",
-                foo: "bar",
-            }));
-            assert(r.matches({
-                title: "hi",
-                foo: "bar",
-            }));
-            assert(!r.matches({
-                title: "hi",
-                foo: "fighters",
-            }));
-            assert(!r.matches({
-                title: "howdy",
-                foo: "bar",
-            }));
-            assert(!r.matches({
-                "missing-stuff": "indeed",
-            }));
-        });
-        it("works on nested messages", () => {
-            const r = new router.Rule("test-rule", { "foo.bar": ["hello", "hi"] }, {});
-            assert(r.matches({
-                title: "greeting",
-                foo: {
-                    bar: "hello",
-                },
-            }));
-            assert(r.matches({
-                title: "greeting",
-                foo: {
-                    bar: "hi",
-                },
-            }));
-            assert(!r.matches({
-                title: "greeting",
-                foo: {
-                    bar: "howdy",
-                },
-            }));
-            assert(!r.matches({
-                title: "greeting",
-                foo: {
-                    baz: "howdy",
-                },
-            }));
-            assert(!r.matches({
-                title: "greeting",
-                boo: {
-                    bar: "howdy",
-                },
-            }));
-            assert(!r.matches({
-                title: "greeting",
-                foo: "hi",
-            }));
-        });
-        it("wild card matching", () => {
-            const r = new router.Rule("test-rule", { any: ["*"] }, {});
-            assert(r.matches({
-                any: false,
-            }));
-            assert(r.matches({
-                any: 5,
-            }));
-            assert(r.matches({
-                any: "hello",
-            }));
-            assert(r.matches({
-                any: {
-                    bar: "hi",
-                },
-            }));
-            assert(!r.matches({
-                any: "",
-            }));
-            assert(!r.matches({
-                any: null,
-            }));
-            assert(!r.matches({
-                any: undefined,
-            }));
-            assert(!r.matches({
-                title: "greeting",
-                foo: {
-                    bar: "howdy",
-                },
-            }));
-        });
-        it("bool matching", () => {
-            const r = new router.Rule("test-rule", { bull: [true] }, {});
-            assert(r.matches({
-                bull: true,
-            }));
-            assert(r.matches({
-                any: false,
-                bull: true,
-            }));
-            assert(!r.matches({
-                bull: false,
-            }));
-            assert(!r.matches({
-                bull: "false",
-            }));
-            assert(!r.matches({
-                title: "greeting",
-                foo: {
-                    bar: "howdy",
-                },
-            }));
-        });
-    });
-    describe("outputFor", () => {
-        it("substitutes kv entries", () => {
-            const r = new router.Rule("myrule", {}, {
-                channel: "#-%{foo}-",
-                dimensions: ["-%{foo}-", "-%{bar.baz}-"],
-            });
-            const msg = {
-                title: "greeting",
-                foo: "partner",
-                bar: {
-                    baz: "nest egg",
-                },
-            };
-            const expected = {
-                rule: "myrule",
-                channel: "#-partner-",
-                dimensions: ["-partner-", "-nest egg-"],
-            };
-            const actual = r.outputFor(msg);
-            assert.deepEqual(expected, actual);
-        });
-    });
-});

package/index.js

@@ -1,7 +0,0 @@
-module.exports = require("./build/lib/kayvee");
-// export logger capitalized to fix lint errors, lowercased to support legacy usage
-module.exports.logger = module.exports.Logger = require("./build/lib/logger/logger");
-module.exports.router = require("./build/lib/router");
-module.exports.middleware = require("./build/lib/middleware");
-module.exports.setGlobalRouting = module.exports.logger.setGlobalRouting;
-module.exports.mockRouting = module.exports.logger.mockRouting;

package/lib/kayvee.ts

@@ -1,73 +0,0 @@
-var _ = require("underscore");
-
-const deploy_env = process.env._DEPLOY_ENV;
-const workflow_id = process.env._EXECUTION_NAME;
-const pod_id = process.env._POD_ID;
-const pod_shortname = process.env._POD_SHORTNAME;
-const pod_region = process.env._POD_REGION;
-const pod_account = process.env._POD_ACCOUNT;
-
-// Encode errors to strings instead of toJSON()
-function replaceErrors(key, value) {
-  if (value instanceof Error) {
-    return value.toString();
-  }
-
-  return value;
-}
-
-// Converts a map to a string space-delimited key=val pairs
-function format(data) {
-  if (deploy_env || workflow_id || pod_id || pod_shortname || pod_account || pod_region) {
-    const extras: any = {};
-    if (deploy_env) {
-      extras.deploy_env = deploy_env;
-    }
-    if (workflow_id) {
-      extras.wf_id = workflow_id;
-    }
-    if (pod_id) {
-      extras["pod-id"] = pod_id;
-    }
-    if (pod_shortname) {
-      extras["pod-shortname"] = pod_shortname;
-    }
-    if (pod_region) {
-      extras["pod-region"] = pod_region;
-    }
-    if (pod_account) {
-      extras["pod-account"] = pod_account;
-    }
-
-    return JSON.stringify(_.extend(extras, data), replaceErrors);
-  }
-  return JSON.stringify(data, replaceErrors);
-}
-
-// Similar to format, but takes additional reserved params to promote logging best-practices
-function formatLog(source = "", level = "", title = "", data = {}) {
-  let info = data;
-  if (!_.isObject(data)) {
-    info = {};
-  }
-  const reserved = { source, level, title };
-
-  // reserved keys overwrite other keys in data
-  return format(_.extend({}, info, reserved));
-}
-
-module.exports = {
-  format,
-  formatLog,
-};
-
-const LOG_LEVELS = {
-  UNKNOWN: "unknown",
-  CRITICAL: "critical",
-  ERROR: "error",
-  WARNING: "warning",
-  INFO: "info",
-  TRACE: "trace",
-};
-
-_.extend(module.exports, LOG_LEVELS);