querysub 0.326.0 → 0.328.0

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

@@ -2,7 +2,7 @@ import { isNode } from "typesafecss";
 import { getArchives } from "../../../-a-archives/archives";
 import { SizeLimiter } from "../../SizeLimiter";
 import { FastArchiveAppendable, createLogScanner, objectDelimitterBuffer } from "../FastArchiveAppendable";
-import { LogDatum, getLoggers } from "../diskLogger";
+import { LogDatum, getLogHash, getLoggers } from "../diskLogger";
 import os from "os";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { cache, cacheLimited, lazy } from "socket-function/src/caching";
@@ -21,6 +21,8 @@ import { qreact } from "../../../4-dom/qreact";
 import { requiresNetworkTrustHook } from "../../../-d-trust/NetworkTrust2";
 import { assertIsManagementUser } from "../../managementPages";
 import { streamToIteratable } from "../../../misc";
+import { fsExistsAsync } from "../../../fs";
+import { getPathStr2 } from "../../../path";
 
 export const MAX_RECENT_ERRORS = 20;
 const MAX_RECENT_ERRORS_PER_FILE = 3;
@@ -151,18 +153,17 @@ export const getSuppressionFull = measureWrap(function getSuppressionFull(config
 
         // Handle definitelyExpired - these are outdated suppressions
         let mostRecentOutdatedSuppressionKey: string | undefined = undefined;
+        let mostRecentOutdatedSuppressionTime = 0;
 
         // Handle maybeExpired - need to parse timestamp to check if suppression was active
         if (maybeExpired.length > 0 && (suppressionCounts || expiredSuppressionCounts || obj)) {
-            const getLogTime = () => {
-                try {
-                    let logEntry = JSON.parse(data.slice(posStart, posEnd).toString()) as LogDatum;
-                    return typeof logEntry.time === "number" ? logEntry.time : 0;
-                } catch {
-                    return 0;
+            let logTime = 0;
+            try {
+                let logEntry = JSON.parse(data.slice(posStart, posEnd).toString()) as LogDatum;
+                if (typeof logEntry.time === "number") {
+                    logTime = logEntry.time;
                 }
-            };
-            let logTime = getLogTime();
+            } catch { }
 
             for (let checker of maybeExpired) {
                 if (checker.fnc(data, posStart, posEnd)) {
@@ -174,8 +175,10 @@ export const getSuppressionFull = measureWrap(function getSuppressionFull(config
                             suppressionCounts.set(checker.entry.key, count);
                         }
                     } else {
-                        if (!mostRecentOutdatedSuppressionKey) {
+
+                        if (checker.entry.expiresAt > mostRecentOutdatedSuppressionTime) {
                             mostRecentOutdatedSuppressionKey = checker.entry.key;
+                            mostRecentOutdatedSuppressionTime = checker.entry.expiresAt;
                         }
                         // Even if we don't want the expired suppression counts, we might want the normal suppression counts, so we have to keep going. 
                         if (expiredSuppressionCounts) {
@@ -192,7 +195,7 @@ export const getSuppressionFull = measureWrap(function getSuppressionFull(config
             for (let checker of definitelyExpired) {
                 if (checker.fnc(data, posStart, posEnd)) {
                     // First match is the most recent (entries are sorted by lastUpdateTime desc)
-                    if (!mostRecentOutdatedSuppressionKey) {
+                    if (checker.entry.expiresAt > mostRecentOutdatedSuppressionTime) {
                         mostRecentOutdatedSuppressionKey = checker.entry.key;
                     }
                     if (!expiredSuppressionCounts) break;
@@ -204,7 +207,7 @@ export const getSuppressionFull = measureWrap(function getSuppressionFull(config
         }
 
         // Set the most recent outdated suppression key if we found any and weren't suppressed
-        if (obj && mostRecentOutdatedSuppressionKey && !suppressed) {
+        if (obj && mostRecentOutdatedSuppressionKey) {
             obj.outdatedSuppressionKey = mostRecentOutdatedSuppressionKey;
         }
 
@@ -221,25 +224,30 @@ const suppressionUpdatedChannel = new SocketChannel<boolean>("suppression-update
 
 class SuppressionList {
     private init = lazy(async () => {
-        suppressionUpdatedChannel.watch(() => {
-            void this.updateEntriesNow();
+        suppressionUpdatedChannel.watch(async () => {
+            await this.updateEntriesNow();
+            await recentErrors.onSuppressionChanged();
+        });
+        await runInfinitePollCallAtStart(SUPPRESSION_POLL_INTERVAL, async () => {
+            await this.updateEntriesNow();
         });
     });
+    private cacheEntries: SuppressionListBase | undefined = undefined;
     private updateEntriesNow = async () => {
         let entries = await suppressionListArchive.get(suppressionListKey);
         if (!entries) {
             entries = { entries: {} };
         }
-        this.getEntries.set(Promise.resolve(entries));
+        this.cacheEntries = entries;
     };
-    private getEntries = lazy(async (): Promise<SuppressionListBase> => {
+    private async getEntries(): Promise<SuppressionListBase> {
         await this.init();
-        await runInfinitePollCallAtStart(SUPPRESSION_POLL_INTERVAL, async () => {
-            await this.updateEntriesNow();
-        });
+        if (!this.cacheEntries) {
+            throw new Error("Cache entries not set? Should be impossible.");
+        }
         // Infinite poll will have set this, so we don't infinitely loop
-        return await this.getEntries();
-    });
+        return this.cacheEntries;
+    }
 
     public async filterObjsToNonSuppressed(objs: LogDatum[]): Promise<LogDatum[]> {
         // NOTE: Streamed data should be rare enough, that handling this inefficiently is okay.
@@ -259,6 +267,7 @@ class SuppressionList {
         }
         let buffer = Buffer.concat(parts);
         let scanner = await this.scanForRecentErrors({
+            debugName: "filterObjsToNonSuppressed",
             startTime,
             endTime,
         });
@@ -266,6 +275,7 @@ class SuppressionList {
         return await scanner.finish();
     }
     public async scanForRecentErrors(config: {
+        debugName: string;
         startTime: number;
         endTime: number;
     }): Promise<{
@@ -285,6 +295,7 @@ class SuppressionList {
         // for the suppression key. 
         let obj: { outdatedSuppressionKey?: string } = {};
         let callback = createLogScanner({
+            debugName: config.debugName,
             onParsedData: (posStart, posEnd, buffer) => {
                 if (buffer === "done") {
                     return;
@@ -297,7 +308,7 @@ class SuppressionList {
                 try {
                     datum = JSON.parse(buffer.slice(posStart, posEnd).toString()) as LogDatum;
                 } catch (e: any) {
-                    process.stderr.write(`Failed to parse log datum in around ${buffer.slice(posStart, posEnd).slice(0, 100).toString("hex")}, error is:\n${e.stack}`);
+                    process.stderr.write(`Failed to parse log datum in around ${buffer.slice(posStart, posEnd).slice(0, 100).toString("hex")}, in source ${config.debugName}, error is:\n${e.stack}`);
                     return;
                 }
                 if (obj.outdatedSuppressionKey) {
@@ -307,18 +318,19 @@ class SuppressionList {
             },
         });
         let lastWaitTime = Date.now();
+        const stream = runInSerial(async (buffer: Buffer | "done") => {
+            // TODO: Maybe we should add this pattern to batching.ts? Basically, if we get called fast, we allow the calls through. BUT, if we called slowly OR we are doing a lot of processing (and so we are working for all of SELF_THROTTLE_INTERVAL), then we wait. This prevents this from taking over the machine. The back off is steep though, and if the machine is lagging we might reduce to a trickle, just getting 1 call in per SELF_THROTTLE_DELAY + synchronous lag from work in other parts of the program.
+            let now = Date.now();
+            if (now - lastWaitTime > SELF_THROTTLE_INTERVAL) {
+                await delay(SELF_THROTTLE_DELAY);
+                lastWaitTime = now;
+            }
+            await callback(buffer);
+        });
         return {
-            onData: runInSerial(async (buffer) => {
-                // TODO: Maybe we should add this pattern to batching.ts? Basically, if we get called fast, we allow the calls through. BUT, if we called slowly OR we are doing a lot of processing (and so we are working for all of SELF_THROTTLE_INTERVAL), then we wait. This prevents this from taking over the machine. The back off is steep though, and if the machine is lagging we might reduce to a trickle, just getting 1 call in per SELF_THROTTLE_DELAY + synchronous lag from work in other parts of the program.
-                let now = Date.now();
-                if (now - lastWaitTime > SELF_THROTTLE_INTERVAL) {
-                    await delay(SELF_THROTTLE_DELAY);
-                    lastWaitTime = now;
-                }
-                await callback(buffer);
-            }),
+            onData: stream,
             finish: async () => {
-                await callback("done");
+                await stream("done");
                 // NOTE: We COULD limit as we run, however... how many errors are we really going to encounter that AREN'T suppressed? Suppression is supposed to prevent overload anyways. I guess worst case scenario, yes, we could get overloaded, but... if we are logging more NEW errors than we can store in memory, we have bigger problems...
                 return limitRecentErrors(datums);
             },
@@ -328,23 +340,24 @@ class SuppressionList {
         let entries = await this.getEntries();
         entry.lastUpdateTime = Date.now();
         entries.entries[entry.key] = entry;
-        void suppressionListArchive.set(suppressionListKey, entries);
+        await suppressionListArchive.set(suppressionListKey, entries);
         suppressionUpdatedChannel.broadcast(true);
         await recentErrors.onSuppressionChanged();
     }
     public async removeSuppressionEntry(key: string) {
         let entries = await this.getEntries();
         delete entries.entries[key];
-        void suppressionListArchive.set(suppressionListKey, entries);
+        await suppressionListArchive.set(suppressionListKey, entries);
         suppressionUpdatedChannel.broadcast(true);
         await recentErrors.onSuppressionChanged();
     }
 
     public async getSuppressionList(): Promise<SuppressionEntry[]> {
-        return Object.values((await this.getEntries()).entries);
+        let entries = Object.values((await this.getEntries()).entries);
+        return entries;
     }
 }
-const suppressionList = new SuppressionList();
+export const suppressionList = new SuppressionList();
 export const SuppressionListController = getSyncedController(SocketFunction.register(
     "SuppressionListController-08f985d8-8d06-4041-ac4b-44566c54615d",
     suppressionList,
@@ -388,7 +401,7 @@ class URLCache {
         if (!isNode()) return undefined;
 
         // Create cache directory if it doesn't exist
-        if (!fs.existsSync(this.root)) {
+        if (!await fsExistsAsync(this.root)) {
             await fs.promises.mkdir(this.root, { recursive: true });
         }
 
@@ -489,13 +502,18 @@ const urlCache = new URLCache();
 const limitRecentErrors = measureWrap(function limitRecentErrors(objs: LogDatum[]) {
     sort(objs, x => x.time);
     let recent: LogDatum[] = [];
+    let foundHashes = new Set<string>();
     let countByFile = new Map<string, number>();
     // NOTE: We iterate backwards, because... usually new logs come in at the end, and are pushed, so we want to sort by time (that way we often don't have to resort by much). And if we sort by time, the newest at at the end!
     for (let i = objs.length - 1; i >= 0; i--) {
         let obj = objs[i];
         let file = String(obj.__FILE__) || "";
         let count = countByFile.get(file) || 0;
+        if (count > MAX_RECENT_ERRORS_PER_FILE) continue;
         count++;
+        let hash = getLogHash(obj);
+        if (foundHashes.has(hash)) continue;
+        foundHashes.add(hash);
         if (count > MAX_RECENT_ERRORS_PER_FILE) continue;
         countByFile.set(file, count);
         recent.push(obj);
@@ -504,8 +522,13 @@ const limitRecentErrors = measureWrap(function limitRecentErrors(objs: LogDatum[
     return recent;
 });
 
-class RecentErrors {
+export class RecentErrors {
+
+    constructor(private addErrorsCallback?: (objs: LogDatum[]) => void | Promise<void>) {
+        this.addErrorsCallback = addErrorsCallback;
+    }
 
+    // TODO: Uninitialize (stopping the infinite polling), if all of our recent errors watchers go away.
     private initialize = lazy(async () => {
         errorWatcherBase.watch(x => {
             void this.addErrors(x);
@@ -517,7 +540,7 @@ class RecentErrors {
     });
 
     private _recentErrors: LogDatum[] = [];
-    private updateRecentErrors = async (objs: LogDatum[]) => {
+    private updateRecentErrors = runInSerial(async (objs: LogDatum[]) => {
         objs = await suppressionList.filterObjsToNonSuppressed(objs);
         let newRecentErrors = limitRecentErrors(objs);
         // If any changed
@@ -540,27 +563,59 @@ class RecentErrors {
             this._recentErrors = newRecentErrors;
             void this.broadcastUpdate(undefined);
         }
-    };
+    });
     private broadcastUpdate = batchFunction({ delay: NOTIFICATION_BROADCAST_BATCH }, () => {
         recentErrorsChannel.broadcast(true);
     });
 
-    private async addErrors(objs: LogDatum[]) {
+    private addErrors = runInSerial(async (objs: LogDatum[]) => {
         if (objs.length === 0) return;
+
+        if (this.addErrorsCallback) {
+            await this.addErrorsCallback(objs);
+            return;
+        }
         for (let obj of objs) {
             this._recentErrors.push(obj);
         }
         await this.updateRecentErrors(this._recentErrors);
-    }
+    });
 
-    public async onSuppressionChanged() {
+    private lastSuppressionList = new Map<string, SuppressionEntry>();
+    public onSuppressionChanged = runInSerial(async () => {
+        let newSuppressionList = new Map((await suppressionList.getSuppressionList()).map(x => [x.key, x]));
+        let prev = this.lastSuppressionList;
+        function anyReduced() {
+            for (let newEntry of newSuppressionList.values()) {
+                let oldEntry = prev.get(newEntry.key);
+                if (oldEntry && newEntry.expiresAt < oldEntry.expiresAt) {
+                    return true;
+                }
+            }
+            for (let oldEntry of prev.values()) {
+                if (!newSuppressionList.has(oldEntry.key)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (anyReduced()) {
+            console.info("Suppression has been reduced (entries removed or expiry times decreased), performing full rescan to find any revealed values.");
+            this.scannedHashes.clear();
+            void this.scanNow({});
+        }
+        this.lastSuppressionList = newSuppressionList;
         await this.updateRecentErrors(this._recentErrors);
-    }
+    });
 
     private scannedHashes = new Set<string>();
     private scanNow = runInSerial(async (config: {
         noLocalFiles?: boolean;
     }) => {
+        // If we're scanning everything, we should update the suppression list, because it might have been changed remotely, and we might be scanning everything because the user clicked refresh. 
+        if (!this.lastSuppressionList || !config.noLocalFiles) {
+            this.lastSuppressionList = new Map((await suppressionList.getSuppressionList()).map(x => [x.key, x]));
+        }
         for (let appendable of getAppendables()) {
             let startTime = Date.now() - VIEW_WINDOW;
             let endTime = Date.now() + timeInHour * 2;
@@ -597,6 +652,7 @@ class RecentErrors {
                     path = await urlCache.getURLLocalPath(file.url, hash);
                     if (!path) continue;
                     let scanner = await suppressionList.scanForRecentErrors({
+                        debugName: file.url,
                         startTime: file.startTime,
                         endTime: file.endTime,
                     });
@@ -609,43 +665,11 @@ class RecentErrors {
                         await fs.promises.unlink(path);
                         continue;
                     }
-                    let sizeT = size;
-                    let fd = await fs.promises.open(path, "r");
-                    try {
-                        await new Promise<void>(async (resolve, reject) => {
-                            const gunzip = zlib.createGunzip();
-
-                            gunzip.on("data", (chunk: Buffer) => {
-                                void scanner.onData(chunk);
-                            });
-
-                            gunzip.on("end", async () => {
-                                try {
-                                    resolve();
-                                } catch (error) {
-                                    reject(error);
-                                }
-                            });
-
-                            gunzip.on("error", reject);
-
-                            try {
-                                for (let i = 0; i < sizeT; i += READ_CHUNK_SIZE) {
-                                    let chunkSize = Math.min(READ_CHUNK_SIZE, sizeT - i);
-                                    let buffer = Buffer.alloc(chunkSize);
-                                    await fd.read(buffer, 0, chunkSize, i);
-                                    let result = gunzip.write(buffer);
-                                    if (!result) {
-                                        await new Promise(resolve => gunzip.once("drain", resolve));
-                                    }
-                                }
-                                gunzip.end();
-                            } catch (error) {
-                                reject(error);
-                            }
-                        });
-                    } finally {
-                        await fd.close();
+                    const fileStream = fs.createReadStream(path);
+                    const gunzip = zlib.createGunzip();
+                    const decompressedStream = fileStream.pipe(gunzip);
+                    for await (const chunk of decompressedStream) {
+                        scanner.onData(chunk);
                     }
                     let newErrors = await scanner.finish();
                     await this.addErrors(newErrors);
@@ -668,6 +692,10 @@ class RecentErrors {
         await this.scanNow({});
         return this._recentErrors;
     }
+
+    public async raiseTestError(...params: unknown[]) {
+        console.error(...params);
+    }
 }
 const recentErrors = new RecentErrors();
 export const RecentErrorsController = getSyncedController(SocketFunction.register(
@@ -676,6 +704,7 @@ export const RecentErrorsController = getSyncedController(SocketFunction.registe
     () => ({
         getRecentErrors: {},
         rescanAllErrorsNow: {},
+        raiseTestError: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],
@@ -712,4 +741,4 @@ export const notifyWatchersOfError = batchFunction({
     }
 );
 
-const errorWatcherBase = new SocketChannel<LogDatum[]>("error-watcher-38de08cd-3247-4f75-9ac0-7919b240607d");
+export const errorWatcherBase = new SocketChannel<LogDatum[]>("error-watcher-38de08cd-3247-4f75-9ac0-7919b240607d");

package/src/diagnostics/logs/errorNotifications/ErrorSuppressionUI.tsx

@@ -10,6 +10,8 @@ import { nextId, sort, timeInDay } from "socket-function/src/misc";
 import { formatNumber, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { formatDateJSX } from "../../../misc/formatJSX";
 import { LogDatum } from "../diskLogger";
+import { measureFnc } from "socket-function/src/profiling/measure";
+import { throttleRender } from "../../../functional/throttleRender";
 
 export class ErrorSuppressionUI extends qreact.Component<{
     dataSeqNum: number;
@@ -20,8 +22,10 @@ export class ErrorSuppressionUI extends qreact.Component<{
 }> {
     state = t.state({
         matchedInput: t.string(""),
+        renderLimit: t.number(10)
     });
 
+    @measureFnc
     private calculatePreviewMatchCount(pattern: string): number {
         if (!pattern.trim()) return 0;
 
@@ -50,6 +54,8 @@ export class ErrorSuppressionUI extends qreact.Component<{
     }
 
     public render() {
+        if (throttleRender({ key: "ErrorSuppressionUI", frameDelay: 30 })) return undefined;
+
         this.props.dataSeqNum;
         const controller = SuppressionListController(SocketFunction.browserNodeId());
         const entries = (controller.getSuppressionList() || []);
@@ -117,6 +123,27 @@ export class ErrorSuppressionUI extends qreact.Component<{
                 >
                     Fixed
                 </Button>
+                <Button
+                    onClick={() => {
+                        let value = this.state.matchedInput;
+                        this.state.matchedInput = "";
+                        void Querysub.onCommitFinished(async () => {
+                            await controller.setSuppressionEntry.promise({
+                                key: nextId(),
+                                match: value,
+                                comment: "",
+                                lastUpdateTime: Date.now(),
+                                expiresAt: Date.now(),
+                            });
+                            Querysub.commit(() => {
+                                this.props.rerunFilters();
+                            });
+                        });
+                    }}
+                    title="Fixed immediately, any future errors even that happen right now will trigger again. "
+                >
+                    Fixed Now
+                </Button>
                 <Button onClick={() => {
                     let value = this.state.matchedInput;
                     this.state.matchedInput = "";
@@ -137,8 +164,12 @@ export class ErrorSuppressionUI extends qreact.Component<{
                 </Button>
             </div>
 
-            <div className={css.vbox(8).fillWidth.overflowAuto.maxHeight("30vh")}>
-                {entries.map((entry) => {
+            <div className={css.pad2(12).bord2(200, 40, 85).hsl(200, 40, 95).fillWidth}>
+                <strong>Note:</strong> Suppression time updates don't automatically rerun the search. Click Run to rerun the search.
+            </div>
+
+            <div className={css.vbox(8).fillWidth.overflowAuto.maxHeight("20vh")}>
+                {entries.slice(0, this.state.renderLimit).map((entry) => {
                     const updateEntry = (changes: Partial<SuppressionEntry>) => {
                         let newEntry = { ...entry, ...changes };
                         void Querysub.onCommitFinished(async () => {
@@ -152,7 +183,7 @@ export class ErrorSuppressionUI extends qreact.Component<{
                         className={
                             css.hbox(8).pad2(12).bord2(0, 0, 10).fillWidth
                             //+ (entry.expiresAt < Date.now() && expiredCount > 0 && css.opacity(0.5))
-                            + ((count === 0 && expiredCount === 0) && css.opacity(0.6))
+                            + ((expiredCount === 0) && css.opacity(0.6))
                             + (
                                 count > 0 && entry.expiresAt !== NOT_AN_ERROR_EXPIRE_TIME && css.hsla(0, 50, 50, 0.5)
                                 || css.hsla(0, 0, 0, 0.1)
@@ -226,6 +257,9 @@ export class ErrorSuppressionUI extends qreact.Component<{
                         </Button>
                     </div>;
                 })}
+                {entries.length > this.state.renderLimit && <Button onClick={() => this.state.renderLimit *= 2}>
+                    Load More
+                </Button>}
             </div>
         </div>;
     }

package/src/diagnostics/logs/errorNotifications/ErrorWarning.tsx

@@ -1,21 +1,35 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../../4-dom/qreact";
 import { css } from "../../../4-dom/css";
-import { isCurrentUserSuperUser } from "../../../user-implementation/userData";
+import { isCurrentUserSuperUser, user_data } from "../../../user-implementation/userData";
 import { RecentErrorsController, SuppressionListController, watchRecentErrors, MAX_RECENT_ERRORS, NOT_AN_ERROR_EXPIRE_TIME, SuppressionEntry } from "./ErrorNotificationController";
 import { t } from "../../../2-proxy/schema2";
 import { InputLabel } from "../../../library-components/InputLabel";
 import { Button } from "../../../library-components/Button";
-import { ATag } from "../../../library-components/ATag";
+import { ATag, Anchor, URLOverride } from "../../../library-components/ATag";
 import { managementPageURL, showingManagementURL } from "../../managementPages";
 import { errorNotifyToggleURL } from "../LogViewer2";
 import { Querysub } from "../../../4-querysub/QuerysubController";
-import { nextId, timeInDay, timeInHour } from "socket-function/src/misc";
+import { deepCloneJSON, nextId, timeInDay, timeInHour } from "socket-function/src/misc";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { Icon } from "../../../library-components/icons";
 import { filterParam } from "../FastArchiveViewer";
 import { endTimeParam, startTimeParam } from "../TimeRangeSelector";
 import { formatDateJSX } from "../../../misc/formatJSX";
+import { atomic } from "../../../2-proxy/PathValueProxyWatcher";
+
+export function getLogsLinkParts(): URLOverride[] {
+    return [
+        showingManagementURL.getOverride(true),
+        managementPageURL.getOverride("LogViewer2"),
+        errorNotifyToggleURL.getOverride(true),
+        filterParam.getOverride(""),
+
+        // NOTE: While loading a weeks worth of logs clientside is a bit slow. Scanning serverside is not nearly as bad, as it can be done over hours, but... we want the page to be snappy, loading in seconds, so... just use a day, and we might reduce it even further if needed...
+        startTimeParam.getOverride(Date.now() - timeInDay * 1),
+        endTimeParam.getOverride(Date.now() + timeInHour * 2),
+    ];
+}
 
 export class ErrorWarning extends qreact.Component {
     state = t.state({
@@ -67,22 +81,36 @@ export class ErrorWarning extends qreact.Component {
                 </style>
             </Button>;
 
-        const logLink = [
-            showingManagementURL.getOverride(true),
-            managementPageURL.getOverride("LogViewer2"),
-            errorNotifyToggleURL.getOverride(true),
-            filterParam.getOverride(""),
-            startTimeParam.getOverride(Date.now() - timeInDay * 7),
-            endTimeParam.getOverride(Date.now() + timeInHour * 2),
-        ];
+        let discordURLWarning: qreact.ComponentChildren = undefined;
+        if (!atomic(user_data().secure.notifyDiscordWebhookURL)) {
+            discordURLWarning = (
+                <Anchor
+                    target="_blank"
+                    title="Can't send application notifications to developers due to missing Discord hook URL. Click here and set it."
+                    values={[
+                        showingManagementURL.getOverride(true),
+                        managementPageURL.getOverride("SecurityPage"),
+                    ]}
+                >
+                    <Button hue={0}>
+                        ⚠️ Missing Discord Hook URL <span className={css.filter("invert(1)")}>📞</span>
+                    </Button>
+                </Anchor>
+            );
+        }
+
+        const logLink = getLogsLinkParts();
 
         if (!recentErrors || recentErrors.length === 0) {
-            return <span className={css.hbox(8)}>
-                <ATag target="_blank" values={logLink}>
-                    No Errors
-                </ATag>
-                {refreshButton}
-            </span>;
+            return (
+                <span className={css.hbox(8)}>
+                    <ATag target="_blank" values={logLink}>
+                        No Errors
+                    </ATag>
+                    {refreshButton}
+                    {discordURLWarning}
+                </span>
+            );
         }
 
         // Count unique files
@@ -128,19 +156,21 @@ export class ErrorWarning extends qreact.Component {
                         View Logs
                     </ATag>
                     {refreshButton}
+                    {discordURLWarning}
                 </div>
 
                 {topExpired &&
                     <div className={css.hbox(8)}>
                         <Button onClick={() => {
+                            let newObj = deepCloneJSON({
+                                ...topExpired!,
+                                expiresAt: Date.now() + timeInDay,
+                            });
                             void Querysub.onCommitFinished(async () => {
-                                await suppressionController.setSuppressionEntry.promise({
-                                    ...topExpired!,
-                                    expiresAt: Date.now() + timeInDay,
-                                });
+                                await suppressionController.setSuppressionEntry.promise(newObj);
                             });
                         }}>
-                            Ignore Again
+                            Ignore Again ({formatDateJSX(topExpired.expiresAt)})
                         </Button>
                         <div>
                             Match Pattern =

package/src/diagnostics/logs/errorNotifications/errorDigests.tsx

@@ -0,0 +1,8 @@
+type DigestInfo = {
+    histogram: {
+        [timeGroup: number]: number;
+    };
+    topByFile: {
+        [file: string]: number;
+    };
+};