🐛 fixing bugs with mysql evaluator + made slack calls retry

Rohland · Nov 12, 2023 · 466dd19 · 466dd19
1 parent 6785372
commit 466dd19
Show file tree

Hide file tree

Showing 11 changed files with 234 additions and 123 deletions.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "barky",
-  "version": "1.0.54",
+  "version": "1.0.55",
   "description": "A simple cloud services watchdog with digest notification support & no external dependencies",
   "homepage": "https://github.com/Rohland/barky#readme",
   "main": "dist/cli.js",

diff --git a/src/evaluators/base.spec.ts b/src/evaluators/base.spec.ts
@@ -39,6 +39,46 @@ describe("base evaluator", () => {
                 });
             });
         });
+        describe("when app is missing name", () => {
+            it("should use inferred name by key", async () => {
+                // arrange
+                const myApp = {};
+                const config = {
+                    ["web"]: {
+                        myApp
+                    }
+                };
+                const e = new WebEvaluator(config);
+
+                // act
+                const apps = e.getAppsToEvaluate()
+
+                // assert
+                expect(apps.length).toEqual(1);
+                expect(apps[0].name).toEqual("myApp");
+            });
+        });
+        describe("when app is not missing name", () => {
+            it("should use name", async () => {
+                // arrange
+                const myApp = {
+                    name: "test"
+                };
+                const config = {
+                    ["web"]: {
+                        myApp
+                    }
+                };
+                const e = new WebEvaluator(config);
+
+                // act
+                const apps = e.getAppsToEvaluate()
+
+                // assert
+                expect(apps.length).toEqual(1);
+                expect(apps[0].name).toEqual("test");
+            });
+        });
     });
 
     describe("given an evaluator", () => {
@@ -57,9 +97,9 @@ describe("base evaluator", () => {
                 const apps3 = evaluator.getAppsToEvaluate();
 
                 // assert
-                expect(apps1).toEqual([{ type: "custom" }]);
-                expect(apps2).toEqual([{ type: "custom" }]);
-                expect(apps3).toEqual([{ type: "custom" }]);
+                expect(apps1).toEqual([{ type: "custom", name: "app1" }]);
+                expect(apps2).toEqual([{ type: "custom", name: "app1" }]);
+                expect(apps3).toEqual([{ type: "custom", name: "app1" }]);
                 expect(evaluator.skippedApps).toEqual([]);
             });
         });
@@ -351,7 +391,7 @@ describe("base evaluator", () => {
                 this.results.push(result);
             }
 
-            configureAndExpandApp(_app: IApp, _name: string): IApp[] {
+            configureAndExpandApp(_app: IApp): IApp[] {
                 return [];
             }
 
@@ -469,7 +509,7 @@ class CustomEvaluator extends BaseEvaluator {
         super(config);
     }
 
-    configureAndExpandApp(app: IApp, _name: string): IApp[] {
+    configureAndExpandApp(app: IApp): IApp[] {
         return [app];
     }
 

diff --git a/src/evaluators/base.ts b/src/evaluators/base.ts
@@ -98,7 +98,7 @@ export abstract class BaseEvaluator {
 
     protected abstract dispose(): Promise<void>;
 
-    abstract configureAndExpandApp(app: IApp, name: string): IApp[];
+    abstract configureAndExpandApp(app: IApp): IApp[];
 
     abstract get type(): EvaluatorType;
 
@@ -115,10 +115,11 @@ export abstract class BaseEvaluator {
         const apps = [];
         for (let name of appNames) {
             const app = this.config[name];
-            const expanded = this.configureAndExpandApp(app, name);
+            app.name ??= name;
+            const expanded = this.configureAndExpandApp(app);
             expanded.forEach(x => {
                 x.type = this.type;
-                if (this.shouldEvaluateApp(x, name)) {
+                if (this.shouldEvaluateApp(x)) {
                     apps.push(x);
                 }
             });
@@ -128,23 +129,21 @@ export abstract class BaseEvaluator {
         return expanded;
     }
 
-    private shouldEvaluateApp(
-        app: IApp,
-        name: string): boolean {
+    private shouldEvaluateApp(app: IApp): boolean {
         if (!app.every) {
             return true;
         }
         const durationMs = parsePeriodToSeconds(app.every) * 1000;
         const everyCount = Math.round(durationMs / LoopMs);
-        const key = `${ this.type }-${ name }`;
+        const key = `${ this.type }-${ app.name }`;
         const count = executionCounter.get(key) ?? 0;
         const shouldEvaluate = count % everyCount === 0;
         executionCounter.set(key, count + 1);
         if (!shouldEvaluate) {
-            log(`skipping ${ this.type } check for '${ name }' - every set to: ${ app.every }`);
+            log(`skipping ${ this.type } check for '${ app.name }' - every set to: ${ app.every }`);
             this.skippedApps.push({
                 ...app,
-                ...this.generateSkippedAppUniqueKey(name)
+                ...this.generateSkippedAppUniqueKey(app.name)
             });
         }
         return shouldEvaluate;

diff --git a/src/evaluators/mysql.ts b/src/evaluators/mysql.ts
@@ -17,8 +17,8 @@ export class MySqlEvaluator extends BaseEvaluator {
         return EvaluatorType.mysql;
     }
 
-    configureAndExpandApp(app: IApp, name: string): IApp[] {
-        return getAppVariations(app, name).map(variant => {
+    configureAndExpandApp(app: IApp): IApp[] {
+        return getAppVariations(app).map(variant => {
             return {
                 timeout: 15000,
                 ...app,
@@ -54,7 +54,17 @@ async function tryEvaluate(app: IApp): Promise<Result | Result[]> {
         const timer = startClock();
         const results = await runQuery(connection, app);
         app.timeTaken = stopClock(timer);
-        return validateResults(app, results);
+        const finalResults = validateResults(app, results);
+        return finalResults.length > 0
+            ? finalResults
+            : new MySqlResult( // no results from mysql means OK for all identifiers!
+                app.name,
+                "*",
+                "inferred",
+                "OK",
+                app.timeTaken,
+                true,
+                app);
     } catch (err) {
         log(`Error evaluating app ${ app.name }: ${ err.message }`, err);
         return new MonitorFailureResult(
@@ -65,15 +75,15 @@ async function tryEvaluate(app: IApp): Promise<Result | Result[]> {
     }
 }
 
-export function validateResults(app, results): Result[] {
+export function validateResults(app: IApp, results: Result[]): Result[] {
     return results.map(row => {
         const identifier = row[app.identifier] ?? app.identifier;
         const rules = findTriggerRulesFor(identifier, app);
         return validateRow(app, identifier, row, rules);
     });
 }
 
-function generateVariablesAndValues(row, app) {
+function generateVariablesAndValues(row, app: IApp) {
     const variables = Object.keys(row).filter(x => x !== app.identifier);
     const values = {};
     const emit: Array<string> = app.emit ?? [];
@@ -87,8 +97,8 @@ function generateVariablesAndValues(row, app) {
 }
 
 export function validateRow(
-    app,
-    identifier,
+    app: IApp,
+    identifier: string,
     row,
     rules: IRule[]): MySqlResult {
     if (!rules || rules.length === 0) {

diff --git a/src/evaluators/sumo.ts b/src/evaluators/sumo.ts
@@ -22,8 +22,8 @@ export class SumoEvaluator extends BaseEvaluator {
         return EvaluatorType.sumo;
     }
 
-    configureAndExpandApp(app: IApp, name: string): IApp[] {
-        return getAppVariations(app, name).map(variant => {
+    configureAndExpandApp(app: IApp): IApp[] {
+        return getAppVariations(app).map(variant => {
             return {
                 timeout: 10000,
                 ...app,

diff --git a/src/evaluators/web.ts b/src/evaluators/web.ts
@@ -19,8 +19,8 @@ export class WebEvaluator extends BaseEvaluator {
         return await tryEvaluate(app);
     }
 
-    configureAndExpandApp(app: IApp, name: string): IApp[] {
-        return getAppVariations(app, name).map(variant => {
+    configureAndExpandApp(app: IApp): IApp[] {
+        return getAppVariations(app).map(variant => {
             return {
                 ...app,
                 ...variant

diff --git a/src/lib/utility.spec.ts b/src/lib/utility.spec.ts
@@ -1,4 +1,12 @@
-import { flatten, hash, initLocaleAndTimezone, isToday, shortHash, toLocalTimeString } from "./utility";
+import {
+    flatten,
+    hash,
+    initLocaleAndTimezone,
+    isToday,
+    shortHash,
+    toLocalTimeString,
+    tryExecuteTimes
+} from "./utility";
 
 describe("utility functions", () => {
     describe("flatten", () => {
@@ -197,4 +205,57 @@ describe("utility functions", () => {
             });
         });
     });
+
+    describe("tryExecuteTimes", () => {
+        describe("on success", () => {
+            it("should return", async () => {
+                // arrange
+                const func = jest.fn().mockResolvedValue("ok");
+
+                // act
+                const result = await tryExecuteTimes("test", 3, func);
+
+                // assert
+                expect(func).toHaveBeenCalledTimes(1);
+                expect(result).toEqual("ok");
+            });
+        });
+        describe("on failure but then success", () => {
+            it("should return success", async () => {
+                // arrange
+                const func = jest.fn().mockRejectedValueOnce(new Error("test")).mockResolvedValue("ok");
+
+                // act
+                const result = await tryExecuteTimes("test", 3, func);
+
+                // assert
+                expect(func).toHaveBeenCalledTimes(2);
+                expect(result).toEqual("ok");
+            });
+        });
+        describe("on successive failure", () => {
+            it("should retry the number of times and throw", async () => {
+                // arrange
+                const func = jest.fn().mockRejectedValue(new Error("test"));
+
+                // act
+                await expect(tryExecuteTimes("test", 3, func)).rejects.toThrow("test");
+
+                // assert
+                expect(func).toHaveBeenCalledTimes(3);
+            });
+            describe("with throw set to false", () => {
+                it("should not throw", async () => {
+                    // arrange
+                    const func = jest.fn().mockRejectedValue(new Error("test"));
+
+                    // act
+                    await tryExecuteTimes("test", 3, func, false, 0);
+
+                    // assert
+                    expect(func).toHaveBeenCalledTimes(3);
+                });
+            });
+        });
+    });
 });
diff --git a/src/lib/utility.ts b/src/lib/utility.ts
@@ -1,4 +1,6 @@
 import * as crypto from "crypto";
+import { log } from "../models/logger";
+import { sleepMs } from "./sleep";
 
 Error.stackTraceLimit = Infinity;
 
@@ -95,3 +97,27 @@ export function shortHash(key: string) {
         .update(key ?? "")
         .digest("hex");
 }
+
+export async function tryExecuteTimes<T>(
+    label: string,
+    times: number,
+    func: () => Promise<T>,
+    throwOnEventualFailure: boolean = true,
+    delayBetweenAttempts: number = 500): Promise<T> {
+    let counter = 0;
+    let lastError = null;
+    while(counter++ < times) {
+        try {
+            return await func();
+        } catch(err) {
+            const msg = `Error ${ label }: ${ err.message }`;
+            log(msg, err);
+            lastError = err;
+        }
+        await sleepMs(delayBetweenAttempts);
+    }
+    if (throwOnEventualFailure && lastError) {
+        throw lastError;
+    }
+    return null;
+}