querysub 0.589.0 → 0.590.0

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

@@ -1,6 +1,4 @@
 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/Querysub";
 import { getDomain, isPublic } from "../../../config";
@@ -23,6 +21,7 @@ import { showingManagementURL, managementPageURL } from "../../managementPages";
 import { atomic } from "../../../2-proxy/PathValueProxyWatcher";
 import { magenta } from "socket-function/src/formatting/logColors";
 import { TicketServiceBase } from "../errorTickets/tickets";
+import { getArchives2 } from "../../../-a-archives/archives2";
 
 
 export type SuppressionEntry = {
@@ -36,8 +35,7 @@ export type SuppressionEntry = {
     createdTime: number;
     lastUpdatedTime: number;
 };
-export const suppression = archiveJSONT<SuppressionEntry>(() => nestArchives("logs/error-suppression/", getArchivesBackblaze(getDomain())));
-let suppressionCache: SuppressionEntry[] = [];
+const suppression = archiveJSONT<SuppressionEntry>(() => getArchives2("logs/error-suppression/"));
 
 // In-memory Discord notification throttling
 const timeInHour = 60 * 60 * 1000;
@@ -50,17 +48,8 @@ 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;
+    return await suppression.values();
 }
 
 let getMatcher = cacheLimited(10000, (text: string) => createMatchesPattern(Buffer.from(text), false));
@@ -157,12 +146,6 @@ async function reapplySuppressions() {
     }
 }
 
-async function onSuppressionsChanged() {
-    // NOTE: Update Now also reapplies suppression internally. after it finishes the update. 
-    void updateNow();
-    await reapplySuppressions();
-}
-
 type PatternResponse = {
     pattern: string;
 };
@@ -246,12 +229,13 @@ const trySendDiscordNotificationsBase = batchFunction({ delay: 1000 * 3 }, async
         return;
     }
 
+    const suppressionEntries = await getSuppressionEntries();
 
     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);
+        const suppressionEntry = suppressionEntries.find(e => e.id === suppressionId);
         if (!suppressionEntry) continue;
 
         if (data.isNew) {
@@ -309,6 +293,9 @@ export async function exposeErrorWatchService() {
     SocketFunction.expose(ErrorNotificationServiceBase);
     SocketFunction.expose(TicketServiceBase);
 
+    // Other nodes edit suppressions too, so periodically re-check the unmatched errors against the current entries.
+    void runInfinitePollCallAtStart(timeInMinute * 5, reapplySuppressions);
+
     let errorLogs = await getErrorLogs();
     for await (let error of watchAllValues(errorLogs)) {
         try {
@@ -348,8 +335,7 @@ export async function exposeErrorWatchService() {
                         lastUpdatedTime: Date.now(),
                     };
 
-                    suppressionCache.push(newEntry);
-                    void suppression.set(newEntry.id, newEntry);
+                    await suppression.set(newEntry.id, newEntry);
                     applySuppression(error, newEntry);
                     queueDiscordNotification(newEntry.id, 1, true);
 
@@ -426,39 +412,22 @@ class ErrorNotificationService {
     }
 
     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();
-        });
+        await suppression.set(entry.id, entry);
+        await reapplySuppressions();
     }
 
     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();
-        });
+        await suppression.delete(id);
+        await reapplySuppressions();
     }
 
     public async updateSuppressionNotes(id: string, notes: string | undefined) {
-        let entry = suppressionCache.find(e => e.id === id);
+        let entries = await getSuppressionEntries();
+        let entry = entries.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);
+        await suppression.set(id, { ...entry, notes, lastUpdatedTime: Date.now() });
     }
 }
 

package/src/diagnostics/managementPages.tsx

@@ -384,6 +384,9 @@ class ManagementRoot extends qreact.Component {
                             .ManagementRoot-page a {
                                 color: hsl(210, 75%, 50%);
                             }
+                            .ATag-current {
+                                color: hsl(270, 75%, 50%)!important;
+                            }
                         `}
                     </style>
                     <div class={css.fillWidth.hbox(20, 4).wrap.hsl(245, 25, 80).pad2(20, 4).pointerEvents("all")}>

package/src/diagnostics/misc-pages/SnapshotViewer.tsx

@@ -1,6 +1,6 @@
 module.allowclient = true;
 
-import { ArchiveSnapshotOverview, ArchiveSnapshotRead, downloadSnapshot, getSnapshot, getSnapshotList, loadSnapshot, saveSnapshot, uploadSnapshot } from "../../0-path-value-core/archiveLocks/archiveSnapshots";
+import { ArchiveSnapshotList, ArchiveSnapshotOverview, ArchiveSnapshotRead, downloadSnapshot, getLiveSnapshotList, getSavedSnapshotList, getSnapshot, loadSnapshot, saveSnapshot, uploadSnapshot } from "../../0-path-value-core/archiveLocks/archiveSnapshots";
 import { qreact } from "../../4-dom/qreact";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
@@ -9,7 +9,8 @@ import { css } from "typesafecss";
 import { Querysub, t } from "../../4-querysub/Querysub";
 import { ATag, Anchor } from "../../library-components/ATag";
 import { URLParam } from "../../library-components/URLParam";
-import { formatDateTime, formatNumber } from "socket-function/src/formatting/format";
+import { formatDateTime, formatNumber, formatTime } from "socket-function/src/formatting/format";
+import { sort } from "socket-function/src/misc";
 import { Button } from "../../library-components/Button";
 import { showModal } from "../../5-diagnostics/Modal";
 import { FullscreenModal } from "../../5-diagnostics/FullscreenModal";
@@ -26,6 +27,7 @@ import { getSyncedController } from "../../library-components/SyncedController";
 
 const selectedSnapshot = new URLParam("selectedSnapshot", "");
 export class SnapshotViewer extends qreact.Component {
+    static renderInProgress = true;
     state = t.state({
         // file => true
         expanded: t.lookup(t.boolean),
@@ -35,12 +37,23 @@ export class SnapshotViewer extends qreact.Component {
     });
     render() {
         let controller = SnapshotViewerSynced(getBrowserUrlNode());
-        let snapshotList = controller.getSnapshotList();
-        if (!snapshotList) return <div>Loading...</div>;
+        let savedList = controller.getSavedSnapshotList();
+        let liveList = controller.getLiveSnapshotList();
+        let snapshotList: ArchiveSnapshotOverview[] = [];
+        if (liveList) snapshotList.push(...liveList.snapshots);
+        if (savedList) snapshotList.push(...savedList.snapshots);
+        sort(snapshotList, x => -x.time);
+        let loadStatus = (
+            <div class={css.vbox(2)}>
+                <div>{liveList ? `Live snapshot list loaded in ${formatTime(liveList.loadTime)}` : "Loading live snapshot list..."}</div>
+                <div>{savedList ? `Snapshot list loaded in ${formatTime(savedList.loadTime)}` : "Loading snapshot list..."}</div>
+            </div>
+        );
         let file = selectedSnapshot.value;
         if (!file || typeof file !== "string") {
             return (
                 <div class={css.pad2(10).vbox(10)}>
+                    {loadStatus}
                     <h1>Snapshots are taken before every change. "zombie" means the file exists, but it has no confirm (so it will be ignored).</h1>
                     <div class={css.hbox(10)}>
                         <Button onClick={() => triggerSnapshotUpload(this)}>
@@ -90,7 +103,11 @@ export class SnapshotViewer extends qreact.Component {
 
         const entry = snapshotList.find(x => x.file === file);
         let snapshotInfo = controller.getSnapshot(file);
-        if (!entry) return <div>Snapshot not found, {file}</div>;
+        if (!entry) {
+            let stillLoading = file === "live" ? !liveList : !savedList;
+            if (stillLoading) return <div>Loading...</div>;
+            return <div>Snapshot not found, {file}</div>;
+        }
         return (
             <div class={css.pad2(10).vbox(10)}>
                 <div class={css.hbox(10)}>
@@ -237,8 +254,12 @@ async function seriousConfirm(config: {
 }
 
 class SnapshotViewerControllerBase {
-    public async getSnapshotList(): Promise<ArchiveSnapshotOverview[]> {
-        return await getSnapshotList();
+    public async getSavedSnapshotList(): Promise<ArchiveSnapshotList> {
+        return await getSavedSnapshotList();
+    }
+
+    public async getLiveSnapshotList(): Promise<ArchiveSnapshotList> {
+        return await getLiveSnapshotList();
     }
 
     public async loadSnapshot(config: {
@@ -271,7 +292,8 @@ export const SnapshotViewerController = SocketFunction.register(
     "SnapshotViewerController-a78ae3cf-5024-49da-b71a-f064a5d4b5f4",
     new SnapshotViewerControllerBase(),
     () => ({
-        getSnapshotList: {},
+        getSavedSnapshotList: {},
+        getLiveSnapshotList: {},
         loadSnapshot: {},
         getSnapshot: {},
         saveLiveSnapshot: {},
@@ -288,7 +310,8 @@ export const SnapshotViewerController = SocketFunction.register(
 );
 const SnapshotViewerSynced = getSyncedController(SnapshotViewerController, {
     reads: {
-        getSnapshotList: ["snapshots"],
+        getSavedSnapshotList: ["snapshots"],
+        getLiveSnapshotList: ["snapshots"],
         getSnapshot: ["snapshots"],
     },
     writes: {

package/src/diagnostics/watchdog.ts

@@ -1,7 +1,8 @@
 import { runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { FormattedMeasureTable, MeasureProfile, logMeasureTable, startMeasure } from "socket-function/src/profiling/measure";
+import { StatsValue, addToStats, createStatsValue } from "socket-function/src/profiling/stats";
 import { logErrors } from "../errors";
-import { isNode, sort } from "socket-function/src/misc";
+import { isNode, sort, timeInHour } from "socket-function/src/misc";
 import debugbreak from "debugbreak";
 import { registerPeriodic } from "./periodic";
 import { getOwnMachineId } from "sliftutils/misc/https/certs";
@@ -15,6 +16,75 @@ import { isPublic } from "../config";
 
 let lastProfile: MeasureProfile | undefined;
 
+const MEASURE_CHUNK_MAX_ENTRIES = 100;
+// Matches the deeper of the two watchdog console tables, so the stored breakdown groups the same way the logs do.
+const MEASURE_CHUNK_MERGE_DEPTH = 2;
+const MEASURE_CHUNK_RETENTION = timeInHour;
+
+export type MeasureChunkEntry = {
+    name: string;
+    ownTime: StatsValue;
+    totalTime: StatsValue;
+    stillOpenCount: number;
+};
+export type MeasureChunk = {
+    startTime: number;
+    endTime: number;
+    /** Sum over ALL groupings' own time, including groupings dropped past MEASURE_CHUNK_MAX_ENTRIES. */
+    profiledTime: number;
+    entries: MeasureChunkEntry[];
+};
+export type MeasureSummary = {
+    startTime: number;
+    endTime: number;
+    profiledTime: number;
+    entries: {
+        name: string;
+        ownTime: number;
+    }[];
+};
+
+let measureChunks: MeasureChunk[] = [];
+
+function storeMeasureChunk(profile: MeasureProfile) {
+    let merged = new Map<string, MeasureChunkEntry>();
+    for (let entry of Object.values(profile.entries)) {
+        let key = entry.name.split("|").slice(0, MEASURE_CHUNK_MERGE_DEPTH).join("|");
+        let existing = merged.get(key);
+        if (!existing) {
+            existing = { name: key, ownTime: createStatsValue(), totalTime: createStatsValue(), stillOpenCount: 0 };
+            merged.set(key, existing);
+        }
+        addToStats(existing.ownTime, entry.ownTime);
+        addToStats(existing.totalTime, entry.totalTime);
+        existing.stillOpenCount += entry.stillOpenCount;
+    }
+    let entries = sort(Array.from(merged.values()), x => -x.ownTime.sum);
+    let profiledTime = entries.reduce((total, entry) => total + entry.ownTime.sum, 0);
+    measureChunks.push({
+        startTime: profile.startTime,
+        endTime: profile.endTime,
+        profiledTime,
+        entries: entries.slice(0, MEASURE_CHUNK_MAX_ENTRIES),
+    });
+    let cutoff = Date.now() - MEASURE_CHUNK_RETENTION;
+    measureChunks = measureChunks.filter(x => x.endTime >= cutoff);
+}
+
+export function getLastMeasureSummary(): MeasureSummary | undefined {
+    let chunk = measureChunks[measureChunks.length - 1];
+    if (!chunk) return undefined;
+    return {
+        startTime: chunk.startTime,
+        endTime: chunk.endTime,
+        profiledTime: chunk.profiledTime,
+        entries: chunk.entries.map(x => ({ name: x.name, ownTime: x.ownTime.sum })),
+    };
+}
+export function getMeasureBreakdown(range: { startTime: number; endTime: number }): MeasureChunk | undefined {
+    return measureChunks.find(x => x.startTime === range.startTime && x.endTime === range.endTime);
+}
+
 addStatPeriodic({
     title: "Performance|% Profiled",
     getValue: () => {
@@ -94,6 +164,7 @@ function logProfileMeasuresTimingsNow() {
         process.stdout.write(`\n${debuggerValue}\n`);
     }
 
+    storeMeasureChunk(profile);
     lastProfile = profile;
     // if (isNode()) {
     //     if (SocketFunction.mountedNodeId) {

package/src/library-components/ATag.tsx

@@ -76,6 +76,7 @@ export class ATag extends qreact.Component<ATagProps> {
                         .color("inherit", "important")
                     )
 
+                    + (isCurrent && " ATag-current" || "")
                 }
                 onClick={e => {
                     if (this.props.rawLink) return;

package/src/library-components/SyncedController.ts

@@ -275,6 +275,7 @@ export function getSyncedController<T extends {
                     let promise = atomic(obj.promise);
 
                     // NOTE: If we are invalidated when the promise is running, nothing happens (as we don't watch invalidated if we are running with a promise). BUT, if the promise isn't running, we will run again, and start running again. In this way we don't queue up a lot if we invalidate a lot, but we do always run again after the invalidation to get the latest result!
+                    let currentPromise: Promise<unknown> | undefined;
                     if (!promise && (!result || atomic(obj.invalidated))) {
                         obj.invalidated = false;
                         let timeStart = Date.now();
@@ -285,6 +286,7 @@ export function getSyncedController<T extends {
                             }
                         }
                         let promiseObjBase = new PromiseObj<unknown>();
+                        currentPromise = promiseObjBase.promise;
                         let promiseObj: { promise: Promise<unknown> } = {
                             promise: promiseObjBase.promise,
                         };
@@ -348,6 +350,12 @@ export function getSyncedController<T extends {
                             return result.result;
                         }
                     }
+                    currentPromise = currentPromise || promise?.promise;
+                    if (currentPromise) {
+                        Querysub.triggerOnPromiseFinish(currentPromise, {
+                            waitReason: `Waiting for ${fncName} to finish`,
+                        });
+                    }
                     return undefined;
                 }
                 call.promise = (...args: any[]) => {