kayvee 3.16.0 → 3.18.0

package/build/test/router.js

@@ -1,11 +1,59 @@
 var assert = require("assert");
 var router = require("../lib/router");
-describe("router.Router", function () {
-    describe("constructor", function () {
-        it("parses well formatted configs", function () {
+describe("router.Router", () => {
+    describe("constructor", () => {
+        it("parses well formatted configs", () => {
             process.env.SCHOOL = "Hogwarts";
-            var conf = "\nroutes:\n  rule-one:\n    matchers:\n      title: [\"authorize-app\"]\n    output:\n      type: \"notifications\"\n      channel: \"%{foo.bar}\"\n      icon: \":rocket:\"\n      message: \"authorized %{foo.bar} in ${SCHOOL}\"\n      user: \"@fishman\"\n  rule-two:\n    matchers:\n      foo.bar: [\"multiple\", \"matches\"]\n      baz: [\"whatever\"]\n    output:\n      type: \"alerts\"\n      series: \"other-series\"\n      dimensions: [\"baz\"]\n      stat_type: \"gauge\"\n  rule-three:\n    matchers:\n      foo.bar: [\"multiple\", \"matches\"]\n      baz: [\"whatever\"]\n    output:\n      type: \"alerts\"\n      series: \"other-series\"\n      dimensions: [\"baz\"]\n      stat_type: \"gauge\"\n      value_field: \"hello\"\n  rule-four:\n    matchers:\n      foo.bar: [\"multiple\", \"matches\"]\n      baz: [\"whatever\"]\n    output:\n      type: \"alerts\"\n      series: \"other-series\"\n      dimensions: []\n      stat_type: \"gauge\"\n  rule-five:\n    matchers:\n      foo.bar: [true]\n      baz: [false]\n    output:\n      type: \"alerts\"\n      series: \"other-series\"\n      dimensions: []\n      stat_type: \"gauge\"\n";
-            var expected = [
+            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}",
@@ -42,115 +90,211 @@ describe("router.Router", function () {
                     value_field: "value",
                 }),
             ];
-            var actual = new router.Router();
+            const actual = new router.Router();
             actual._loadConfigString(conf);
             assert.deepEqual(actual.rules, expected);
         });
-        it("rejects specials in matchers", function () {
-            var confTmpl = function (v) { return ("\nroutes:\n  non-string-values:\n    matchers:\n      no-numbers: [" + v + "]\n    output:\n      type: \"analytics\"\n      series: \"fun\"\n"); };
+        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
-            var conf = confTmpl("\"valid\"");
-            var actual = new router.Router();
-            assert.doesNotThrow(function () { return actual._loadConfigString(conf); });
-            var _loop_1 = function(invalidVal) {
-                var invalidConf = confTmpl(invalidVal);
-                assert.throws(function () { return actual._loadConfigString(invalidConf); });
-            };
-            for (var _i = 0, _a = ["5", "[]", "{}"]; _i < _a.length; _i++) {
-                var invalidVal = _a[_i];
-                _loop_1(invalidVal);
+            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(function () { return actual._loadConfigString(confTmpl("\"\"")); });
+            assert.throws(() => actual._loadConfigString(confTmpl('""')));
             return;
         });
-        it("rejects duplicates in matchers", function () {
-            var confTmpl = function (v) { return ("\nroutes:\n  sloppy:\n    matchers:\n      title: [" + v + "]\n    output:\n      type: \"analytics\"\n      series: \"fun\"\n"); };
-            var actual = new router.Router();
-            var validConf = confTmpl("\"non-repeated\", \"name\"");
-            assert.doesNotThrow(function () { return actual._loadConfigString(validConf); });
-            var invalidConf = confTmpl("\"repeated\", \"repeated\", \"name\"");
-            assert.throws(function () { return actual._loadConfigString(invalidConf); });
+        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", function () {
-            var confTmpl = function (series, dimensions) { return ("\nroutes:\n  wrong:\n    matchers:\n      title: [\"test\"]\n    output:\n      type: \"alerts\"\n      series: " + series + "\n      dimensions: " + dimensions + "\n      value_field: \"hihi\"\n      stat_type: \"gauge\"\n"); };
-            var actual = new router.Router();
-            var validConf = confTmpl("\"my-series\"", "[\"dim1\", \"dim2\"]");
-            assert.doesNotThrow(function () { return actual._loadConfigString(validConf); });
-            var invalidConf0 = confTmpl("[\"my-series\"]", "[\"dim1\", \"dim2\"]");
-            assert.throws(function () { return actual._loadConfigString(invalidConf0); });
-            var invalidConf1 = confTmpl("\"my-series\"", "\"dim1\"");
-            assert.throws(function () { return actual._loadConfigString(invalidConf1); });
+        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", function () {
-            var confTmpl = function (v) { return ("\nroutes:\n  wrong:\n    matchers:\n      title: [\"test\"]\n    output:\n      type: \"alerts\"" + v + "\n      dimensions: [\"dim1\", \"dim2\"]\n      stat_type: \"gauge\"\n"); };
-            var actual = new router.Router();
-            var validConf = confTmpl("\n      series: \"whatever\"");
-            assert.doesNotThrow(function () { return actual._loadConfigString(validConf); });
-            var invalidConf = confTmpl("");
-            assert.throws(function () { return actual._loadConfigString(invalidConf); });
+        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", function () {
-            var confTmpl = function (v) { return ("\nroutes:\n  wrong:\n    matchers:\n      title: [\"test\"]\n    output:\n      type: \"metrics\"" + v + "\n      dimensions: [\"dim1\", \"dim2\"]\n"); };
-            var actual = new router.Router();
-            var validConf = confTmpl("\n      series: \"whatever\"");
-            assert.doesNotThrow(function () { return actual._loadConfigString(validConf); });
-            var invalidConf = confTmpl("\n      series: \"whatever\"\n      something-else: \"hi there\"");
-            assert.throws(function () { return 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", function () {
-            var actual = new router.Router();
-            var config;
-            config = "\nroute: # Should be routes (plural)\n  string-values:\n    matchers:\n      errors: [ \"type-o\" ]\n    output:\n      type: \"analytics\"\n      series: \"fun\"\n";
-            assert.throws(function () { return actual._loadConfigString(config); });
-            config = "\nroutes:\n  string-values:\n    matcher: # Should be matchers (plural)\n      errors: [ \"type-o\" ]\n    output:\n      type: \"analytics\"\n      series: \"fun\"\n";
-            assert.throws(function () { return actual._loadConfigString(config); });
-            config = "\nroutes:\n  string-values:\n    matchers:\n      errors: [ \"type-o\" ]\n    outputs: # Should be output (signular)\n      type: \"analytics\"\n      series: \"fun\"\n";
-            assert.throws(function () { return actual._loadConfigString(config); });
-            config = "\nroutes:\n  $invalid-string-values: # Invalid rule name\n    matchers:\n      errors: [ \"type-o\" ]\n    output:\n      type: \"analytics\"\n      series: \"fun\"\n";
-            assert.throws(function () { return actual._loadConfigString(config); });
-            config = "\nroutes:\n  string-values:\n    matchers:\n      errors: [ \"type-o\" ]\n    output:\n      type: \"analytic\" # Should be analytics (plural)p\n      series: \"fun\"\n";
-            assert.throws(function () { return actual._loadConfigString(config); });
-            config = "\nroutes:\n  string-values:\n    matchers:\n      errors: [ \"*\", \"type-o\" ] # A wildcard cannot exist with other matchers\n    output:\n      type: \"analytics\"\n      series: \"fun\"\n";
-            assert.throws(function () { return actual._loadConfigString(config); });
+        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", function () {
-        it("matches one or more rule and returns appropriate outputs", function () {
-            var r = new router.Router([
+    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" }),
             ]);
-            var msg0 = {
+            const msg0 = {
                 title: "hi",
                 foo: "bar",
             };
-            var expected0 = [{
+            const expected0 = [
+                {
                     rule: "rule-one",
                     channel: "#-bar-",
                     dimensions: ["-bar-"],
-                }];
-            var actual0 = r.route(msg0).routes;
+                },
+            ];
+            const actual0 = r.route(msg0).routes;
             assert.deepEqual(expected0, actual0);
-            var msg1 = {
+            const msg1 = {
                 title: "hi",
                 bing: {
                     bong: "buzz",
                 },
             };
-            var expected1 = [{
+            const expected1 = [
+                {
                     rule: "rule-two",
                     series: "x",
-                }];
-            var actual1 = r.route(msg1).routes;
+                },
+            ];
+            const actual1 = r.route(msg1).routes;
             assert.deepEqual(expected1, actual1);
-            var msg2 = {
+            const msg2 = {
                 title: "hello",
                 foo: "baz",
                 bing: {
                     bong: "buzz",
                 },
             };
-            var expected2 = [
+            const expected2 = [
                 {
                     rule: "rule-one",
                     channel: "#-baz-",
@@ -161,15 +305,15 @@ describe("router.Router", function () {
                     series: "x",
                 },
             ];
-            var actual2 = r.route(msg2).routes;
+            const actual2 = r.route(msg2).routes;
             assert.deepEqual(expected2, actual2);
         });
     });
 });
-describe("router.Rule", function () {
-    describe("matches", function () {
-        it("works on simple cases", function () {
-            var r = new router.Rule("test-rule", { title: ["hello", "hi"], foo: ["bar"] }, {});
+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",
@@ -190,8 +334,8 @@ describe("router.Rule", function () {
                 "missing-stuff": "indeed",
             }));
         });
-        it("works on nested messages", function () {
-            var r = new router.Rule("test-rule", { "foo.bar": ["hello", "hi"] }, {});
+        it("works on nested messages", () => {
+            const r = new router.Rule("test-rule", { "foo.bar": ["hello", "hi"] }, {});
             assert(r.matches({
                 title: "greeting",
                 foo: {
@@ -227,8 +371,8 @@ describe("router.Rule", function () {
                 foo: "hi",
             }));
         });
-        it("wild card matching", function () {
-            var r = new router.Rule("test-rule", { any: ["*"] }, {});
+        it("wild card matching", () => {
+            const r = new router.Rule("test-rule", { any: ["*"] }, {});
             assert(r.matches({
                 any: false,
             }));
@@ -259,8 +403,8 @@ describe("router.Rule", function () {
                 },
             }));
         });
-        it("bool matching", function () {
-            var r = new router.Rule("test-rule", { bull: [true] }, {});
+        it("bool matching", () => {
+            const r = new router.Rule("test-rule", { bull: [true] }, {});
             assert(r.matches({
                 bull: true,
             }));
@@ -282,25 +426,25 @@ describe("router.Rule", function () {
             }));
         });
     });
-    describe("outputFor", function () {
-        it("substitutes kv entries", function () {
-            var r = new router.Rule("myrule", {}, {
+    describe("outputFor", () => {
+        it("substitutes kv entries", () => {
+            const r = new router.Rule("myrule", {}, {
                 channel: "#-%{foo}-",
                 dimensions: ["-%{foo}-", "-%{bar.baz}-"],
             });
-            var msg = {
+            const msg = {
                 title: "greeting",
                 foo: "partner",
                 bar: {
                     baz: "nest egg",
                 },
             };
-            var expected = {
+            const expected = {
                 rule: "myrule",
                 channel: "#-partner-",
                 dimensions: ["-partner-", "-nest egg-"],
             };
-            var actual = r.outputFor(msg);
+            const actual = r.outputFor(msg);
             assert.deepEqual(expected, actual);
         });
     });

package/lib/kayvee.ts

@@ -20,12 +20,24 @@ function replaceErrors(key, value) {
 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; }
+    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);
   }
@@ -38,7 +50,7 @@ function formatLog(source = "", level = "", title = "", data = {}) {
   if (!_.isObject(data)) {
     info = {};
   }
-  const reserved = {source, level, title};
+  const reserved = { source, level, title };
 
   // reserved keys overwrite other keys in data
   return format(_.extend({}, info, reserved));