querysub 0.377.0 → 0.379.0

package/src/diagnostics/logs/errorNotifications2/errorNotifications.ts

@@ -0,0 +1,629 @@
+import { cacheLimited, lazy } from "socket-function/src/caching";
+import { nestArchives } from "../../../-a-archives/archives";
+import { getArchivesBackblaze } from "../../../-a-archives/archivesBackBlaze";
+import { archiveJSONT } from "../../../-a-archives/archivesJSONT";
+import { Querysub } from "../../../4-querysub/QuerysubController";
+import { getDomain } from "../../../config";
+import { MachineInfo } from "../../../deployManager/machineSchema";
+import { createMatchesPattern } from "../IndexedLogs/bufferSearchFindMatcher";
+import { LogDatum, getErrorLogs } from "../diskLogger";
+import { watchAllValues } from "./logWatcher";
+import { batchFunction, runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { nextId, sort, throttleFunction, timeInMinute } from "socket-function/src/misc";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { assertIsManagementUser } from "../../managementPages";
+import { getSyncedController } from "../../../library-components/SyncedController";
+import { getControllerNodeId } from "../../../-g-core-values/NodeCapabilities";
+import { t } from "../../../2-proxy/schema2";
+import { sendDiscordMessage } from "../../../email_ims_notifications/discord";
+import { user_data } from "../../../user-implementation/userData";
+import { callOpenRouterJSON } from "./openRouterHelper";
+import { createLink } from "../../../library-components/ATag";
+import { showingManagementURL, managementPageURL } from "../../managementPages";
+import { atomic } from "../../../2-proxy/PathValueProxyWatcher";
+import { magenta } from "socket-function/src/formatting/logColors";
+
+
+type SuppressionEntry = {
+    id: string;
+    notes?: string;
+    pattern: string;
+
+    // After this time, this suppression won't suppress data anymore.
+    timeout: number;
+
+    createdTime: number;
+    lastUpdatedTime: number;
+};
+const suppression = archiveJSONT<SuppressionEntry>(() => nestArchives("logs/error-suppression/", getArchivesBackblaze(getDomain())));
+let suppressionCache: SuppressionEntry[] = [];
+
+// In-memory Discord notification throttling
+const timeInHour = 60 * 60 * 1000;
+const NEW_SUPPRESSION_THROTTLE = timeInHour * 6;
+const EXISTING_SUPPRESSION_THROTTLE = timeInHour * 24;
+
+let isThrottlingNewSuppressions = false;
+let isThrottlingExistingSuppressions = false;
+let pendingDiscordNotifications = new Map<string, {
+    errorCount: number;
+    isNew: boolean;
+}>();
+let ensureWatching = lazy(async () => {
+    await runInfinitePollCallAtStart(timeInMinute * 5, updateNow);
+});
+async function updateNow() {
+    suppressionCache = await suppression.values();
+    // Can't wait, because that will cause a cyclic loop
+    void reapplySuppressions();
+}
+async function getSuppressionEntries(): Promise<SuppressionEntry[]> {
+    await ensureWatching();
+    return suppressionCache;
+}
+
+let getMatcher = cacheLimited(10000, (text: string) => createMatchesPattern(Buffer.from(text), false));
+
+const MAX_UNMATCHED = 10000;
+const MAX_EXAMPLES = 100;
+let unmatchedIndex = 0;
+let unmatchedErrors: LogDatum[] = [];
+export type SuppressionMatch = {
+    id: string;
+    // getHistoryChunk =>
+    history: Map<number, {
+        count: number;
+    }>;
+    exampleIndex: number;
+    examples: LogDatum[];
+};
+let suppressionMatches = new Map<string, SuppressionMatch>();
+const chunkUnit = timeInMinute * 5;
+export function getHistoryChunk(time: number) {
+    return Math.floor(time / chunkUnit) * chunkUnit;
+}
+export function getChunkEndTime(chunk: number) {
+    chunk = getHistoryChunk(chunk);
+    return chunk + chunkUnit;
+}
+
+type SuppressionStatus = "suppressed" | "matched-timeout-passed" | "no-match";
+
+function applySuppression(error: LogDatum, suppressionEntry: SuppressionEntry): SuppressionStatus {
+    let errorBuffer = Buffer.from(JSON.stringify(error));
+    let isMatch = getMatcher(suppressionEntry.pattern);
+    if (!isMatch(errorBuffer)) return "no-match";
+
+    let history = suppressionMatches.get(suppressionEntry.id);
+    if (!history) {
+        history = {
+            id: suppressionEntry.id,
+            history: new Map(),
+            exampleIndex: 0,
+            examples: [],
+        };
+        suppressionMatches.set(suppressionEntry.id, history);
+    }
+
+    if (history.examples.length > MAX_EXAMPLES) {
+        history.examples[history.exampleIndex] = error;
+        history.exampleIndex = (history.exampleIndex + 1) % MAX_EXAMPLES;
+    } else {
+        history.examples.push(error);
+    }
+
+    let historyChunk = getHistoryChunk(error.time);
+    let historyEntry = history.history.get(historyChunk);
+    if (!historyEntry) {
+        historyEntry = { count: 0 };
+        history.history.set(historyChunk, historyEntry);
+    }
+    historyEntry.count++;
+
+    if (error.time > suppressionEntry.timeout) {
+        return "matched-timeout-passed";
+    }
+
+    return "suppressed";
+}
+
+async function reapplySuppressions() {
+    let suppressionEntries = await getSuppressionEntries();
+    let newUnmatchedErrors: LogDatum[] = [];
+    let changedSuppressionIds = new Set<string>();
+
+    for (let error of unmatchedErrors) {
+        let suppressed = false;
+        for (let suppressionEntry of suppressionEntries) {
+            let status = applySuppression(error, suppressionEntry);
+            if (status === "suppressed" || status === "matched-timeout-passed") {
+                changedSuppressionIds.add(suppressionEntry.id);
+            }
+            if (status === "suppressed") {
+                suppressed = true;
+            }
+        }
+        if (!suppressed) {
+            newUnmatchedErrors.push(error);
+        }
+    }
+
+    unmatchedErrors = newUnmatchedErrors;
+    unmatchedIndex = unmatchedErrors.length % MAX_UNMATCHED;
+
+    for (let id of changedSuppressionIds) {
+        void ErrorNotificationService.triggerSuppressionUpdate(id);
+    }
+}
+
+async function onSuppressionsChanged() {
+    // NOTE: Update Now also reapplies suppression internally. after it finishes the update. 
+    void updateNow();
+    await reapplySuppressions();
+}
+
+type PatternResponse = {
+    pattern: string;
+};
+
+const PATTERN_GENERATION_LIMIT = 100;
+const PATTERN_GENERATION_WINDOW = 15 * 60 * 1000;
+let patternGenerationTimes: number[] = [];
+
+async function generatePatternForError(error: LogDatum): Promise<string> {
+    const now = Date.now();
+    const windowStart = now - PATTERN_GENERATION_WINDOW;
+
+    patternGenerationTimes = patternGenerationTimes.filter(time => time > windowStart);
+
+    if (patternGenerationTimes.length >= PATTERN_GENERATION_LIMIT) {
+        console.log(magenta(`Rate limit exceeded for pattern generation (${patternGenerationTimes.length}/${PATTERN_GENERATION_LIMIT} in last 15 minutes)`));
+        return "";
+    }
+
+    patternGenerationTimes.push(now);
+    const openRouterAPIKey = await Querysub.commitAsync(() => atomic(user_data().secure.openRouterAPIKey));
+    if (!openRouterAPIKey) {
+        throw new Error("OpenRouter API key not set");
+    }
+
+    console.log(magenta(`Createing pattern for error: ${error.param0}`));
+
+    const param0 = error.param0 && String(error.param0) || "(no message)";
+
+    const prompt = `You are helping to categorize error messages. We categorize them by finding specific unique text inside of the error message which will be the same even if the variables and the instance changes.
+
+Here is an error message:
+${param0}
+
+Please provide a SHORT search string that would match this type of error. The string should:
+- Be specific enough to identify this error type
+- Be generic enough to match similar errors (avoid dynamic values like timestamps, IDs, or specific numbers)
+- Be a simple substring (no special operators)
+
+Respond with a JSON object with a "pattern" field containing the search string.`;
+
+    const response = await callOpenRouterJSON<PatternResponse>(openRouterAPIKey, prompt);
+
+    const pattern = response.pattern && response.pattern.trim();
+
+    if (!pattern) {
+        throw new Error("AI returned an empty pattern");
+    }
+
+    return pattern;
+}
+
+function queueDiscordNotification(suppressionId: string, errorCount: number, isNew: boolean) {
+    const existing = pendingDiscordNotifications.get(suppressionId);
+    if (existing) {
+        existing.errorCount += errorCount;
+    } else {
+        pendingDiscordNotifications.set(suppressionId, { errorCount, isNew });
+    }
+    void trySendDiscordNotifications(isNew);
+}
+
+function trySendDiscordNotifications(isNew: boolean) {
+    if (isNew && isThrottlingNewSuppressions) return;
+    if (isThrottlingExistingSuppressions) return;
+    if (pendingDiscordNotifications.size === 0) return;
+    void trySendDiscordNotificationsBase();
+}
+
+const trySendDiscordNotificationsBase = batchFunction({ delay: 1000 * 3 }, async function trySendDiscordNotificationsBase(nothing: void[]) {
+    if (pendingDiscordNotifications.size === 0) return;
+
+    const webhookURL = await Querysub.commitAsync(() => atomic(user_data().secure.notifyDiscordWebhookURL));
+    if (!webhookURL) {
+        return;
+    }
+
+
+    const newSuppressions: Array<{ id: string; count: number; pattern: string }> = [];
+    const existingSuppressions: Array<{ id: string; count: number; pattern: string }> = [];
+
+    for (const [suppressionId, data] of pendingDiscordNotifications.entries()) {
+        const suppressionEntry = suppressionCache.find(e => e.id === suppressionId);
+        if (!suppressionEntry) continue;
+
+        if (data.isNew) {
+            newSuppressions.push({ id: suppressionId, count: data.errorCount, pattern: suppressionEntry.pattern });
+        } else {
+            existingSuppressions.push({ id: suppressionId, count: data.errorCount, pattern: suppressionEntry.pattern });
+        }
+    }
+
+    let messageLines: string[] = [];
+
+    for (const sup of newSuppressions) {
+        const line = `(${sup.count}) "${sup.pattern.slice(0, 50)}" [NEW]`;
+        if (messageLines.join("\n").length + line.length < 400) {
+            messageLines.push(line);
+        }
+    }
+
+    for (const sup of existingSuppressions) {
+        const line = `(${sup.count}) "${sup.pattern.slice(0, 50)}" [EXISTING]`;
+        if (messageLines.join("\n").length + line.length < 400) {
+            messageLines.push(line);
+        }
+    }
+
+    const link = createLink([
+        { param: showingManagementURL, value: true },
+        { param: managementPageURL, value: "ErrorNotificationPage" },
+    ]);
+    const messageText = messageLines.join("\n");
+    const message = `[${messageText}](${link})`;
+
+    try {
+        await sendDiscordMessage({ webhookURL, message });
+
+        isThrottlingNewSuppressions = true;
+        isThrottlingExistingSuppressions = true;
+        setTimeout(() => {
+            isThrottlingNewSuppressions = false;
+            let anyNew = Array.from(pendingDiscordNotifications.values()).some(data => data.isNew);
+            void trySendDiscordNotifications(anyNew);
+        }, NEW_SUPPRESSION_THROTTLE);
+        setTimeout(() => {
+            isThrottlingExistingSuppressions = false;
+            void trySendDiscordNotifications(false);
+        }, EXISTING_SUPPRESSION_THROTTLE);
+
+        pendingDiscordNotifications.clear();
+    } catch (error) {
+        console.error("Failed to send Discord notification:", error);
+    }
+});
+
+export async function exposeErrorWatchService() {
+    SocketFunction.expose(ErrorNotificationServiceBase);
+
+    let errorLogs = await getErrorLogs();
+    for await (let error of watchAllValues(errorLogs)) {
+        let suppressionEntries = await getSuppressionEntries();
+        let suppressed = false;
+        let matchedSuppressionId: string | undefined = undefined;
+
+        for (let suppressionEntry of suppressionEntries) {
+            let status = applySuppression(error, suppressionEntry);
+            if (status === "suppressed" || status === "matched-timeout-passed") {
+                void ErrorNotificationService.triggerSuppressionUpdate(suppressionEntry.id);
+            }
+            if (status === "suppressed") {
+                suppressed = true;
+                matchedSuppressionId = suppressionEntry.id;
+            }
+        }
+
+        if (suppressed && matchedSuppressionId) {
+            queueDiscordNotification(matchedSuppressionId, 1, false);
+        } else if (!suppressed) {
+            if (unmatchedErrors.length > unmatchedIndex) {
+                unmatchedErrors[unmatchedIndex] = error;
+                unmatchedIndex = (unmatchedIndex + 1) % MAX_UNMATCHED;
+            } else {
+                unmatchedErrors.push(error);
+            }
+
+            const pattern = await generatePatternForError(error);
+            if (pattern) {
+                const newEntry: SuppressionEntry = {
+                    id: nextId(),
+                    pattern,
+                    timeout: 0,
+                    createdTime: Date.now(),
+                    lastUpdatedTime: Date.now(),
+                };
+
+                suppressionCache.push(newEntry);
+                void suppression.set(newEntry.id, newEntry);
+                applySuppression(error, newEntry);
+                queueDiscordNotification(newEntry.id, 1, true);
+
+                void ErrorNotificationService.triggerSuppressionUpdate(newEntry.id);
+            }
+
+            void ErrorNotificationService.triggerUnmatchedError(error);
+        }
+    }
+}
+
+class ErrorNotificationService {
+    public async getData() {
+        return {
+            unmatchedErrors,
+            suppressionMatches,
+        };
+    }
+
+    public async getUnmatchedErrorsLimited() {
+        // Oldest first, otherwise, while you're trying to deal with one match, it might keep changing, which is annoying
+        sort(unmatchedErrors, x => x.time);
+        // We have to sort from oldest to first, otherwise the way we write it will be weird, as we write it in the order from oldest to first already. However, we don't want to clobber the ones we're returning, so we start right after them. So we're going to keep the oldest ones for a little bit longer after we call this function.
+        unmatchedIndex = 5;
+        return unmatchedErrors.slice(0, 5);
+    }
+
+    private static watchersSERVICE = new Set<string>();
+    public async watchUnmatchedErrorsSERVICE(): Promise<void> {
+        let caller = SocketFunction.getCaller();
+        ErrorNotificationService.watchersSERVICE.add(caller.nodeId);
+    }
+
+    public static triggerUnmatchedError = batchFunction({ delay: 100 }, (datums: LogDatum[]) => {
+        for (let nodeId of ErrorNotificationService.watchersSERVICE) {
+            void (async () => {
+                try {
+                    await ErrorNotificationDataBase.nodes[nodeId].receiveErrorHTTP(datums);
+                } catch {
+                    ErrorNotificationService.watchersSERVICE.delete(nodeId);
+                }
+            })();
+        }
+    });
+
+    public static triggerSuppressionUpdate = batchFunction({ delay: 100 }, (ids: string[]) => {
+        let uniqueIds = new Set(ids);
+        let matches: SuppressionMatch[] = [];
+        for (let id of uniqueIds) {
+            let match = suppressionMatches.get(id);
+            if (match) {
+                matches.push(match);
+            }
+        }
+
+        for (let nodeId of ErrorNotificationService.watchersSERVICE) {
+            void (async () => {
+                try {
+                    await ErrorNotificationDataBase.nodes[nodeId].receiveSuppressionHTTP(matches);
+                } catch {
+                    ErrorNotificationService.watchersSERVICE.delete(nodeId);
+                }
+            })();
+        }
+    });
+
+    public async getSuppressionEntries() {
+        return await getSuppressionEntries();
+    }
+
+    public async setSuppressionEntry(entry: SuppressionEntry) {
+        let suppressionPromise = suppression.set(entry.id, entry);
+        let prevEntry = suppressionCache.findIndex(e => e.id === entry.id);
+        if (prevEntry !== -1) {
+            suppressionCache[prevEntry] = entry;
+        } else {
+            suppressionCache.push(entry);
+        }
+        await onSuppressionsChanged();
+        void suppressionPromise.finally(() => {
+            void onSuppressionsChanged();
+        });
+    }
+
+    public async deleteSuppressionEntry(id: string) {
+        let suppressionPromise = suppression.delete(id);
+        let prevEntry = suppressionCache.findIndex(e => e.id === id);
+        if (prevEntry !== -1) {
+            suppressionCache.splice(prevEntry, 1);
+        }
+        await onSuppressionsChanged();
+        void suppressionPromise.finally(() => {
+            void onSuppressionsChanged();
+        });
+    }
+
+    public async updateSuppressionNotes(id: string, notes: string | undefined) {
+        let entry = suppressionCache.find(e => e.id === id);
+        if (!entry) {
+            throw new Error(`Suppression entry ${id} not found`);
+        }
+        let updatedEntry = { ...entry, notes, lastUpdatedTime: Date.now() };
+        suppressionCache[suppressionCache.findIndex(e => e.id === id)] = updatedEntry;
+        void suppression.set(id, updatedEntry);
+    }
+}
+
+const ErrorNotificationServiceBase = SocketFunction.register(
+    "ErrorNotificationService-019c9cae-8333-7708-a4e7-500f5fc23175",
+    new ErrorNotificationService(),
+    () => ({
+        getData: {},
+        getUnmatchedErrorsLimited: {},
+        watchUnmatchedErrorsSERVICE: {},
+        getSuppressionEntries: {},
+        setSuppressionEntry: {},
+        deleteSuppressionEntry: {},
+        updateSuppressionNotes: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        noAutoExpose: true,
+    }
+);
+
+class ErrorNotificationData {
+    public async getData() {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        return await ErrorNotificationServiceBase.nodes[controllerNodeId].getData();
+    }
+
+    public async getUnmatchedErrorsLimited() {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        return await ErrorNotificationServiceBase.nodes[controllerNodeId].getUnmatchedErrorsLimited();
+    }
+
+    static browserErrorCallbacks = new Set<(datum: LogDatum[]) => void>();
+    static browserSuppressionCallbacks = new Set<(matches: SuppressionMatch[]) => void>();
+    public static async watchUnmatchedErrors(config: {
+        errorCallback: (datum: LogDatum[]) => void;
+        suppressionCallback: (matches: SuppressionMatch[]) => void;
+    }) {
+        ErrorNotificationData.browserErrorCallbacks.add(config.errorCallback);
+        ErrorNotificationData.browserSuppressionCallbacks.add(config.suppressionCallback);
+        await ErrorNotificationData.ensureWatchingErrorsBrowser();
+        return () => {
+            ErrorNotificationData.browserErrorCallbacks.delete(config.errorCallback);
+            ErrorNotificationData.browserSuppressionCallbacks.delete(config.suppressionCallback);
+        };
+    }
+
+    private static ensureWatchingErrorsBrowser = lazy(async () => {
+        await ErrorNotificationDataBase.nodes[SocketFunction.getBrowserNodeId()].watchUnmatchedErrorsHTTP();
+    });
+
+    public async receiveErrorBrowser(datums: LogDatum[]) {
+        for (let callback of ErrorNotificationData.browserErrorCallbacks) {
+            callback(datums);
+        }
+    }
+
+    public async receiveSuppressionBrowser(matches: SuppressionMatch[]) {
+        for (let callback of ErrorNotificationData.browserSuppressionCallbacks) {
+            callback(matches);
+        }
+    }
+
+    private watchersHTTP = new Set<string>();
+    public async watchUnmatchedErrorsHTTP() {
+        let caller = SocketFunction.getCaller();
+        this.watchersHTTP.add(caller.nodeId);
+        await ErrorNotificationData.ensureWatchingErrorsHTTP();
+    }
+
+    private static ensureWatchingErrorsHTTP = lazy(async () => {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            ErrorNotificationData.ensureWatchingErrorsHTTP.reset();
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        SocketFunction.onNextDisconnect(controllerNodeId, () => {
+            ErrorNotificationData.ensureWatchingErrorsHTTP.reset();
+        });
+        await ErrorNotificationServiceBase.nodes[controllerNodeId].watchUnmatchedErrorsSERVICE();
+    });
+
+    public async receiveErrorHTTP(datums: LogDatum[]) {
+        for (let nodeId of this.watchersHTTP) {
+            void (async () => {
+                try {
+                    await ErrorNotificationDataBase.nodes[nodeId].receiveErrorBrowser(datums);
+                } catch {
+                    this.watchersHTTP.delete(nodeId);
+                }
+            })();
+        }
+    }
+
+    public async receiveSuppressionHTTP(matches: SuppressionMatch[]) {
+        for (let nodeId of this.watchersHTTP) {
+            void (async () => {
+                try {
+                    await ErrorNotificationDataBase.nodes[nodeId].receiveSuppressionBrowser(matches);
+                } catch {
+                    this.watchersHTTP.delete(nodeId);
+                }
+            })();
+        }
+    }
+
+    public async getSuppressionEntries() {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        return await ErrorNotificationServiceBase.nodes[controllerNodeId].getSuppressionEntries();
+    }
+
+    public async setSuppressionEntry(entry: SuppressionEntry) {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        await ErrorNotificationServiceBase.nodes[controllerNodeId].setSuppressionEntry(entry);
+    }
+
+    public async deleteSuppressionEntry(id: string) {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        await ErrorNotificationServiceBase.nodes[controllerNodeId].deleteSuppressionEntry(id);
+    }
+
+    public async logTestError(errorMessage: string) {
+        console.error(errorMessage);
+    }
+
+    public async updateSuppressionNotes(id: string, notes: string | undefined) {
+        let controllerNodeId = await getControllerNodeId(ErrorNotificationServiceBase);
+        if (!controllerNodeId) {
+            throw new Error(`Could not find node exposing controller ErrorNotificationServiceBase`);
+        }
+        await ErrorNotificationServiceBase.nodes[controllerNodeId].updateSuppressionNotes(id, notes);
+    }
+}
+
+const ErrorNotificationDataBase = SocketFunction.register(
+    "ErrorNotificationData-019c9cae-8333-7708-a4e7-500f5fc23174",
+    new ErrorNotificationData(),
+    () => ({
+        getData: {},
+        getUnmatchedErrorsLimited: {},
+        receiveErrorBrowser: {},
+        receiveSuppressionBrowser: {},
+        receiveErrorHTTP: {},
+        receiveSuppressionHTTP: {},
+        watchUnmatchedErrorsHTTP: {},
+        getSuppressionEntries: {},
+        setSuppressionEntry: {},
+        deleteSuppressionEntry: {},
+        logTestError: {},
+        updateSuppressionNotes: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    })
+);
+export const ErrorNotificationsController = getSyncedController(ErrorNotificationDataBase);
+
+export function watchUnmatchedErrors(config: {
+    errorCallback: (datum: LogDatum[]) => void;
+    suppressionCallback: (matches: SuppressionMatch[]) => void;
+}) {
+    return ErrorNotificationData.watchUnmatchedErrors({
+        errorCallback: config.errorCallback,
+        suppressionCallback: config.suppressionCallback,
+    });
+}

package/src/diagnostics/logs/errorNotifications2/errorWatchEntry.ts

@@ -0,0 +1,13 @@
+import "../../../forceProduction";
+import "../../../inject";
+
+import { logErrors } from "../../../errors";
+import { Querysub } from "../../../4-querysub/QuerysubController";
+import { exposeErrorWatchService } from "./errorNotifications";
+
+logErrors(main());
+
+async function main() {
+    await Querysub.hostService("ErrorWatch");
+    await exposeErrorWatchService();
+}