querysub 0.357.0 → 0.359.0

package/src/diagnostics/logs/IndexedLogs/LogViewer3.tsx

@@ -7,7 +7,7 @@ import { InputLabel, InputLabelURL } from "../../../library-components/InputLabe
 import { getLoggers2, getLoggers2Async, LogDatum } from "../diskLogger";
 import { list, timeInDay, keyByArray, sort, throttleFunction } from "socket-function/src/misc";
 import { formatDateTime, formatDateTimeDetailed, formatNumber, formatTime, formatPercent } from "socket-function/src/formatting/format";
-import { IndexedLogResults, IndexedLogs, TimeFilePathWithSize } from "./IndexedLogs";
+import { IndexedLogs, TimeFilePathWithSize } from "./IndexedLogs";
 import { Querysub } from "../../../4-querysub/QuerysubController";
 import { URLParam } from "../../../library-components/URLParam";
 import { getOwnMachineId, getOwnThreadId } from "../../../-f-node-discovery/NodeDiscovery";
@@ -21,6 +21,8 @@ import { ObjectDisplay } from "../ObjectDisplay";
 import { formatDateJSX } from "../../../misc/formatJSX";
 import { PUBLIC_MOVE_THRESHOLD } from "./BufferIndexLogsOptimizationConstants";
 import { atomic } from "../../../2-proxy/PathValueProxyWatcher";
+import { errorToUndefined } from "querysub/src/errors";
+import { IndexedLogResults, createEmptyIndexedLogResults } from "./BufferIndexHelpers";
 
 let searchText = new URLParam("searchText", "");
 let readLiveData = new URLParam("readLiveData", false);
@@ -31,9 +33,6 @@ let savedPathsURL = new URLParam("savedPaths", "");
 let selectedFieldsURL = new URLParam("selectedFields", {} as Record<string, boolean>);
 let useRelativeTimeURL = new URLParam("useRelativeTime", true);
 
-// Only auto-search if the string is long enough. Otherwise, we're going to get way too many results, which could slow down the server and won't be useful to us. 
-const MIN_AUTO_SEARCH_LENGTH = 7;
-
 const defaultSelectedFields = {
     param0: true,
     time: true,
@@ -43,13 +42,61 @@ const defaultSelectedFields = {
     __entry: true,
 };
 
-function createTestLog(text: string, type: "log" | "warn" | "info" | "error"): LogDatum {
+function mergeIndexedLogResults(existing: IndexedLogResults, incoming: IndexedLogResults): IndexedLogResults {
+    let readsByKey = new Map<string, typeof existing.reads[0]>();
+
+    for (let read of existing.reads) {
+        let key = `${read.cached}-${read.remote}`;
+        let existingRead = readsByKey.get(key);
+        if (existingRead) {
+            existingRead.count += read.count;
+            existingRead.size += read.size;
+            existingRead.totalSize = Math.max(existingRead.totalSize, read.totalSize);
+            existingRead.totalCount = Math.max(existingRead.totalCount, read.totalCount);
+        } else {
+            readsByKey.set(key, { ...read });
+        }
+    }
+
+    for (let read of incoming.reads) {
+        let key = `${read.cached}-${read.remote}`;
+        let existingRead = readsByKey.get(key);
+        if (existingRead) {
+            existingRead.count += read.count;
+            existingRead.size += read.size;
+            existingRead.totalSize = Math.max(existingRead.totalSize, read.totalSize);
+            existingRead.totalCount = Math.max(existingRead.totalCount, read.totalCount);
+        } else {
+            readsByKey.set(key, { ...read });
+        }
+    }
+
     return {
-        time: 0,
-        message: text,
-        __LOG_TYPE: type,
-        __machineId: getOwnMachineId(),
-        __threadId: getOwnThreadId(),
+        matchCount: existing.matchCount + incoming.matchCount,
+        totalLocalFiles: existing.totalLocalFiles + incoming.totalLocalFiles,
+        totalBackblazeFiles: existing.totalBackblazeFiles + incoming.totalBackblazeFiles,
+        reads: Array.from(readsByKey.values()),
+        localFilesSearched: existing.localFilesSearched + incoming.localFilesSearched,
+        backblazeFilesSearched: existing.backblazeFilesSearched + incoming.backblazeFilesSearched,
+        totalBlockCount: existing.totalBlockCount + incoming.totalBlockCount,
+        blockCheckedCount: existing.blockCheckedCount + incoming.blockCheckedCount,
+        blocksCheckedCompressedSize: existing.blocksCheckedCompressedSize + incoming.blocksCheckedCompressedSize,
+        blocksCheckedDecompressedSize: existing.blocksCheckedDecompressedSize + incoming.blocksCheckedDecompressedSize,
+        blockErrors: [...existing.blockErrors, ...incoming.blockErrors],
+        fileErrors: [...existing.fileErrors, ...incoming.fileErrors],
+        remoteIndexesSearched: existing.remoteIndexesSearched + incoming.remoteIndexesSearched,
+        remoteIndexSize: existing.remoteIndexSize + incoming.remoteIndexSize,
+        localIndexesSearched: existing.localIndexesSearched + incoming.localIndexesSearched,
+        localIndexSize: existing.localIndexSize + incoming.localIndexSize,
+        timeToFirstMatch: Math.min(existing.timeToFirstMatch === 0 ? Infinity : existing.timeToFirstMatch, incoming.timeToFirstMatch === 0 ? Infinity : incoming.timeToFirstMatch),
+        fileFindTime: existing.fileFindTime + incoming.fileFindTime,
+        indexSearchTime: existing.indexSearchTime + incoming.indexSearchTime,
+        blockSearchTime: existing.blockSearchTime + incoming.blockSearchTime,
+        totalSearchTime: Math.max(existing.totalSearchTime, incoming.totalSearchTime),
+        remoteBlockCount: existing.remoteBlockCount + incoming.remoteBlockCount,
+        localBlockCount: existing.localBlockCount + incoming.localBlockCount,
+        remoteBlockCheckedCount: existing.remoteBlockCheckedCount + incoming.remoteBlockCheckedCount,
+        localBlockCheckedCount: existing.localBlockCheckedCount + incoming.localBlockCheckedCount,
     };
 }
 
@@ -60,10 +107,7 @@ export class LogViewer3 extends qreact.Component {
         enableInfos: t.boolean(true),
         enableWarnings: t.boolean(true),
         enableErrors: t.boolean(true),
-        results: t.atomic<LogDatum[]>([
-            { "time": 1771825252649.44, "__LOG_TYPE": "log", "__machineId": "1ed7a7340a015680", "__mountId": "1d590f0919b1f438.1ed7a7340a015680.querysubtest.com:7007", "__threadId": "1d590f0919b1f438", "__port": 7007, "__nodeId": "1d590f0919b1f438.1ed7a7340a015680.querysubtest.com:7007", "__entry": "D:\\repos\\qs-cyoa\\src\\server.ts", "__hostName": "DESKTOP-05MP449", "__accountName": "desktop-05mp449\\quent", "__externalIP": "99.250.124.91", "__os": "win32", "__pid": 75888, "param0": "new non-local WATCH", "path": ".,querysubtest._com.,PathFunctionRunner.,book.,Data.,edittingBooks.,hkwnmoiwhuyqenbi.,books.,bf0713806bf1c4338._querysubtest._com_1755390476654._5208_1.,nodes.,1770378259589._5535.,aiCalls.,", "watcher": "client:127.0.0.1:1771825250819.3994:0.634106584461968", "diskAudit": true },
-            { "time": 1771825252649.4397, "__LOG_TYPE": "log", "__machineId": "1ed7a7340a015680", "__mountId": "1d590f0919b1f438.1ed7a7340a015680.querysubtest.com:7007", "__threadId": "x1d590f0919b1f438", "__port": 7007, "__nodeId": "1d590f0919b1f438.1ed7a7340a015680.querysubtest.com:7007", "__entry": "D:\\repos\\qs-cyoa\\src\\server.ts", "__hostName": "DESKTOP-05MP449", "__accountName": "desktop-05mp449\\quent", "__externalIP": "99.250.124.91", "__os": "win32", "__pid": 75888, "param0": "new non-local WATCH", "path": ".,querysubtest._com.,PathFunctionRunner.,book.,Data.,edittingBooks.,hkwnmoiwhuyqenbi.,books.,bf0713806bf1c4338._querysubtest._com_1755390476654._5208_1.,nodes.,1770378259589._5535.,totalTime.,", "watcher": "client:127.0.0.1:1771825250819.3994:0.634106584461968", "diskAudit": true },
-        ]),
+        results: t.atomic<LogDatum[]>([]),
         searching: t.boolean,
         searchingLogs: t.boolean,
         searchingInfos: t.boolean,
@@ -72,8 +116,13 @@ export class LogViewer3 extends qreact.Component {
         paths: t.atomic<TimeFilePathWithSize[]>([]),
         loadingPaths: t.boolean,
         stats: t.atomic<IndexedLogResults | undefined>(undefined),
+        hasSearched: t.boolean(false),
+        forceMoveStartTime: t.atomic<number | undefined>(undefined),
+        forceMoveEndTime: t.atomic<number | undefined>(undefined),
     });
 
+    private searchSequenceNumber = 0;
+
     componentDidMount(): void {
         void this.loadPaths();
     }
@@ -118,20 +167,29 @@ export class LogViewer3 extends qreact.Component {
 
         let totalSizeRead = 0;
         let cachedSize = 0;
+        let cachedCount = 0;
         let uncachedSize = 0;
         let uncachedCount = 0;
         let uncachedRemoteSize = 0;
         let uncachedRemoteCount = 0;
         let totalSize = 0;
+        let remoteTotalSize = 0;
+        let localTotalSize = 0;
 
         for (let read of stats.reads) {
             totalSizeRead += read.size;
             if (read.cached) {
                 cachedSize += read.size;
+                cachedCount += read.count;
             } else {
                 uncachedSize += read.size;
                 uncachedCount += read.count;
                 totalSize += read.totalSize;
+                if (read.remote) {
+                    remoteTotalSize += read.totalSize;
+                } else {
+                    localTotalSize += read.totalSize;
+                }
             }
             if (read.remote && !read.cached) {
                 uncachedRemoteSize += read.size;
@@ -161,21 +219,28 @@ export class LogViewer3 extends qreact.Component {
         };
 
         const fileItems = [
-            `${formatTime(stats.fileFindTime)} | ${formatNumber(stats.localFilesSearched + stats.backblazeFilesSearched)} | ${formatNumber(totalSize)}B`,
-            `pending ${formatNumber(stats.localFilesSearched)}`,
+            `${formatTime(stats.fileFindTime)} | ${formatNumber(stats.localFilesSearched + stats.backblazeFilesSearched)} / ${formatNumber(stats.totalLocalFiles + stats.totalBackblazeFiles)} | ${formatNumber(totalSize)}B`,
+            `remote ${formatNumber(stats.backblazeFilesSearched)} / ${formatNumber(stats.totalBackblazeFiles)} | ${formatNumber(remoteTotalSize)}B`,
+            `pending ${formatNumber(stats.localFilesSearched)} / ${formatNumber(stats.totalLocalFiles)} | ${formatNumber(localTotalSize)}B`,
         ];
 
+        const totalIndexesSearched = stats.remoteIndexesSearched + stats.localIndexesSearched;
+        const totalIndexSize = stats.remoteIndexSize + stats.localIndexSize;
         const indexItems = [
-            `${formatTime(stats.indexSearchTime)} | ${formatNumber(stats.indexesSearched)} | ${formatNumber(stats.indexSize)}B`,
+            `${formatTime(stats.indexSearchTime)} | ${formatNumber(totalIndexesSearched)} | ${formatNumber(totalIndexSize)}B | ${formatNumber(totalSize / totalIndexSize)}X`,
+            `remote ${formatNumber(stats.remoteIndexesSearched)} | ${formatNumber(stats.remoteIndexSize)}B | ${formatNumber(remoteTotalSize / stats.remoteIndexSize)}X`,
+            `local ${formatNumber(stats.localIndexesSearched)} | ${formatNumber(stats.localIndexSize)}B | ${formatNumber(localTotalSize / stats.localIndexSize)}X`,
         ];
 
         const blockItems = [
-            `${formatTime(stats.blockSearchTime)} | ${formatNumber(stats.blockCheckedCount)} | ${formatNumber(stats.blocksCheckedCompressedSize)}B | ${formatNumber(stats.blocksCheckedDecompressedSize / stats.blocksCheckedCompressedSize)}X`,
-            `total blocks ${formatNumber(stats.totalBlockCount)}`,
+            <div title={`Scanned size = ${formatNumber(stats.blocksCheckedCompressedSize)}B, Decompressed size = ${formatNumber(stats.blocksCheckedDecompressedSize)}B, Compression ratio = ${formatNumber(stats.blocksCheckedDecompressedSize / stats.blocksCheckedCompressedSize)}X`}>{formatTime(stats.blockSearchTime)} | {formatNumber(stats.blockCheckedCount)} | {formatNumber(stats.blocksCheckedCompressedSize)}B | {formatNumber(stats.blocksCheckedDecompressedSize / stats.blocksCheckedCompressedSize)}X</div>,
+            `total scanned ${formatNumber(stats.totalBlockCount)} (${formatPercent(stats.blockCheckedCount / stats.totalBlockCount)})`,
+            `remote ${formatNumber(stats.remoteBlockCheckedCount)} / ${formatNumber(stats.remoteBlockCount)} (${formatPercent(stats.remoteBlockCheckedCount / stats.remoteBlockCount)}) | local ${formatNumber(stats.localBlockCheckedCount)} / ${formatNumber(stats.localBlockCount)} (${formatPercent(stats.localBlockCheckedCount / stats.localBlockCount)})`,
         ];
         let cacheItems = [
-            `disk read ${formatNumber(uncachedSize)}B`,
+            `disk read ${formatNumber(uncachedSize)}B (${formatNumber(uncachedCount)})`,
             `remote ${formatPercent(uncachedRemoteSize / totalSizeRead)} (${formatNumber(uncachedRemoteCount)})`,
+            `cached ${formatNumber(cachedSize)} (${formatNumber(cachedCount)})`,
         ];
 
         const resultItems = [
@@ -194,14 +259,15 @@ export class LogViewer3 extends qreact.Component {
                 {renderStage("Files", fileItems, 290, true, false)}
                 {renderStage("Indexes", indexItems, 250, false, false)}
                 {renderStage("Blocks", blockItems, 210, false, false)}
-                {renderStage("Cache", cacheItems, 160, false, false)}
+                {renderStage("Reads", cacheItems, 160, false, false)}
                 {renderStage("Results", resultItems, 120, false, false)}
                 {renderStage("Done", doneItems, undefined, false, !hasErrors)}
                 {(() => {
                     if (!hasErrors) return undefined;
                     let errorItems: preact.ComponentChild[] = [];
                     if (stats.fileErrors.length > 0) {
-                        errorItems.push(<div title={stats.fileErrors.join("\n")}>{stats.fileErrors.length} files failed</div>);
+                        const errorTitle = stats.fileErrors.map(e => `${e.path}:\n${e.error}`).join("\n\n");
+                        errorItems.push(<div title={errorTitle}>{stats.fileErrors.length} files failed</div>);
                     }
                     if (stats.blockErrors.length > 0) {
                         errorItems.push(<div title={stats.blockErrors.join("\n")}>{stats.blockErrors.length} blocks failed</div>);
@@ -217,7 +283,7 @@ export class LogViewer3 extends qreact.Component {
         const now = Date.now();
         const threshold = now - (2 * PUBLIC_MOVE_THRESHOLD);
 
-        const machineWarnings: Record<string, { machineId: string; oldestTime: number }> = {};
+        const machineWarnings: Record<string, { machineId: string; oldestTime: number; count: number; totalSize: number }> = {};
 
         for (const path of paths) {
             if (path.logCount !== undefined) continue;
@@ -227,26 +293,102 @@ export class LogViewer3 extends qreact.Component {
             if (!path.machineId) continue;
 
             const existing = machineWarnings[path.machineId];
-            if (!existing || path.startTime < existing.oldestTime) {
+            if (!existing) {
                 machineWarnings[path.machineId] = {
                     machineId: path.machineId,
                     oldestTime: path.startTime,
+                    count: 1,
+                    totalSize: path.size || 0,
                 };
+            } else {
+                if (path.startTime < existing.oldestTime) {
+                    existing.oldestTime = path.startTime;
+                }
+                existing.count++;
+                existing.totalSize += path.size || 0;
             }
         }
 
         const warnings = Object.values(machineWarnings);
         if (warnings.length === 0) return undefined;
 
+        const isFrozen = !!savedPathsURL.value;
+
         return (
-            <div className={css.vbox(10).pad2(10).hsl(40, 50, 50).colorhsl(60, 50, 100)}>
-                <div className={css.fontWeight(600)}>Machines not moving logs to remote storage:</div>
-                {warnings.map((warning) => (
-                    <div key={warning.machineId} className={css.hbox(10)}>
-                        <MachineThreadInfo machineId={warning.machineId} />
-                        <span>is not moving logs to remote storage. Logs are {formatTime(now - warning.oldestTime)} old</span>
-                    </div>
-                ))}
+            <div className={css.vbox(10).pad2(10).hsl(0, 50, 50).colorhsl(60, 50, 100)}>
+                {isFrozen && (
+                    <>
+                        <div className={css.fontWeight(600)}>Frozen files are too old:</div>
+                        {warnings.map((warning) => (
+                            <div key={warning.machineId} className={css.hbox(10)}>
+                                <MachineThreadInfo machineId={warning.machineId} />
+                                <span>has {formatNumber(warning.count)} pending files ({formatNumber(warning.totalSize)}B) that are {formatTime(now - warning.oldestTime)} old</span>
+                            </div>
+                        ))}
+                        <Button
+                            onClick={() => {
+                                this.clearFrozenPaths();
+                                void this.loadPaths();
+                            }}
+                            hue={180}
+                        >
+                            Clear Frozen Files and Reload
+                        </Button>
+                    </>
+                )}
+                {!isFrozen && (
+                    <>
+                        <div className={css.fontWeight(600)}>FIX pending logs not being merged!</div>
+                        {warnings.map((warning) => (
+                            <div key={warning.machineId} className={css.hbox(10)}>
+                                <MachineThreadInfo machineId={warning.machineId} />
+                                <span>is not moving logs to remote storage. {formatNumber(warning.count)} files ({formatNumber(warning.totalSize)}B) are {formatTime(now - warning.oldestTime)} old</span>
+                            </div>
+                        ))}
+                        <Button
+                            onClick={async () => {
+                                Querysub.commitLocal(() => {
+                                    this.state.forceMoveStartTime = Date.now();
+                                    this.state.forceMoveEndTime = undefined;
+                                });
+
+                                let forceMoveInterval = setInterval(() => {
+                                    this.forceUpdate();
+                                }, 100);
+
+                                try {
+                                    let loggers = await getLoggers2Async();
+                                    for (let logger of Object.values(loggers)) {
+                                        await logger.clientForceMoveLogsToPublic();
+                                    }
+                                    await this.loadPaths();
+                                } finally {
+                                    if (forceMoveInterval) {
+                                        clearInterval(forceMoveInterval);
+                                    }
+
+                                    Querysub.commitLocal(() => {
+                                        this.state.forceMoveEndTime = Date.now();
+                                    });
+                                }
+                            }}
+                            hue={180}
+                        >
+                            Force Move Logs to Public
+                        </Button>
+                        {(() => {
+                            if (this.state.forceMoveStartTime !== undefined && this.state.forceMoveEndTime === undefined) {
+                                const elapsed = Date.now() - this.state.forceMoveStartTime;
+                                return <div>Moving logs... {formatTime(elapsed)}</div>;
+                            }
+                            if (this.state.forceMoveStartTime !== undefined && this.state.forceMoveEndTime !== undefined) {
+                                const duration = this.state.forceMoveEndTime - this.state.forceMoveStartTime;
+                                return <div>Moved logs in {formatTime(duration)}</div>;
+                            }
+                            return undefined;
+                        })()}
+                    </>
+                )}
             </div>
         );
     }
@@ -256,7 +398,9 @@ export class LogViewer3 extends qreact.Component {
             return;
         }
 
-        this.state.loadingPaths = true;
+        Querysub.commitLocal(() => {
+            this.state.loadingPaths = true;
+        });
 
         let loggers = await getLoggers2Async();
         let selectedLoggers: typeof loggers.logLogs[] = [];
@@ -293,8 +437,21 @@ export class LogViewer3 extends qreact.Component {
         });
     }
 
+    cancel = async () => {
+        this.searchSequenceNumber++;
+        let loggers = await getLoggers2Async();
+        for (let logger of Object.values(loggers)) {
+            logger.clientCancelAllCallbacks();
+        }
+        Querysub.commitLocal(() => {
+            this.state.searching = false;
+            this.state.hasSearched = false;
+        });
+    };
+
 
-    search = throttleFunction(200, async () => {
+    search = async () => {
+        await this.cancel();
         Querysub.commitLocal(() => {
             this.state.searching = true;
             this.state.results = [];
@@ -305,15 +462,6 @@ export class LogViewer3 extends qreact.Component {
             this.state.searchingErrors = false;
         });
 
-        let startTime = Date.now();
-
-        let hasPaths = Querysub.localRead(() => this.getPaths().length > 0);
-        let getFilesTime = 0;
-        if (readLiveData.value || !hasPaths) {
-            let startTime = Date.now();
-            await this.loadPaths();
-            getFilesTime = Date.now() - startTime;
-        }
 
         let loggers = await getLoggers2Async();
 
@@ -337,6 +485,20 @@ export class LogViewer3 extends qreact.Component {
             }
         });
 
+        this.searchSequenceNumber++;
+        let currentSequenceNumber = this.searchSequenceNumber;
+
+        let startTime = Date.now();
+
+        let hasPaths = Querysub.localRead(() => this.getPaths().length > 0);
+        let getFilesTime = 0;
+        if (readLiveData.value || !hasPaths) {
+            let startTime = Date.now();
+            await this.loadPaths();
+            getFilesTime = Date.now() - startTime;
+        }
+
+
         if (selectedLoggers.length === 0) {
             console.error("No log sources selected");
             Querysub.commitLocal(() => {
@@ -347,25 +509,7 @@ export class LogViewer3 extends qreact.Component {
 
         let searchBuffer = Querysub.localRead(() => Buffer.from(searchText.value, "utf8"));
         let results: LogDatum[] = [];
-        let stats: IndexedLogResults = {
-            matchCount: 0,
-            reads: [],
-            localFilesSearched: 0,
-            backblazeFilesSearched: 0,
-            totalBlockCount: 0,
-            blockCheckedCount: 0,
-            blocksCheckedCompressedSize: 0,
-            blocksCheckedDecompressedSize: 0,
-            blockErrors: [],
-            fileErrors: [],
-            indexesSearched: 0,
-            indexSize: 0,
-            timeToFirstMatch: 0,
-            fileFindTime: 0,
-            indexSearchTime: 0,
-            blockSearchTime: 0,
-            totalSearchTime: 0,
-        };
+        let stats: IndexedLogResults = createEmptyIndexedLogResults();
         stats.fileFindTime += getFilesTime;
 
         let paths = Querysub.localRead(() => this.getPaths());
@@ -373,13 +517,33 @@ export class LogViewer3 extends qreact.Component {
         let range = Querysub.localRead(() => getTimeRange());
 
         let updateResults = throttleFunction(100, () => {
+            if (this.searchSequenceNumber !== currentSequenceNumber) return;
             Querysub.commitLocal(() => {
                 this.state.results = results;
             });
         });
 
+        let loggerResults = new Map<typeof loggers.logLogs, IndexedLogResults>();
+
+        let updateStats = () => {
+            if (this.searchSequenceNumber !== currentSequenceNumber) return;
+
+            let mergedStats: IndexedLogResults = createEmptyIndexedLogResults();
+
+            for (let loggerResult of loggerResults.values()) {
+                mergedStats = mergeIndexedLogResults(mergedStats, loggerResult);
+            }
+
+            mergedStats.totalSearchTime = Date.now() - startTime;
+
+            Querysub.commitLocal(() => {
+                this.state.stats = mergedStats;
+            });
+        };
+
         await Promise.all(selectedLoggers.map(async (logger) => {
-            let result = await logger.clientFind({
+            let done = false;
+            let result = await errorToUndefined(logger.clientFind({
                 params: {
                     startTime: range.startTime,
                     endTime: range.endTime,
@@ -392,25 +556,20 @@ export class LogViewer3 extends qreact.Component {
                     results.push(match);
                     void updateResults();
                 },
-            });
-            stats.reads.push(...result.reads);
-            stats.matchCount += result.matchCount;
-            stats.localFilesSearched += result.localFilesSearched;
-            stats.backblazeFilesSearched += result.backblazeFilesSearched;
-            stats.totalBlockCount += result.totalBlockCount;
-            stats.blockCheckedCount += result.blockCheckedCount;
-            stats.blocksCheckedCompressedSize += result.blocksCheckedCompressedSize;
-            stats.blocksCheckedDecompressedSize += result.blocksCheckedDecompressedSize;
-            stats.indexesSearched += result.indexesSearched;
-            stats.indexSize += result.indexSize;
-            stats.timeToFirstMatch = Math.min(stats.timeToFirstMatch, result.timeToFirstMatch);
-            stats.fileFindTime += result.fileFindTime;
-            stats.indexSearchTime += result.indexSearchTime;
-            stats.blockSearchTime += result.blockSearchTime;
-            stats.totalSearchTime = Date.now() - startTime;
+                onResults: (loggerStats: IndexedLogResults) => {
+                    if (done) return;
+                    loggerResults.set(logger, loggerStats);
+                    updateStats();
+                },
+            }));
+            done = true;
+
+            if (result) {
+                loggerResults.set(logger, result);
+                updateStats();
+            }
+
             Querysub.commitLocal(() => {
-                this.state.results = results;
-                this.state.stats = stats;
                 if (logger === loggers.logLogs) this.state.searchingLogs = false;
                 if (logger === loggers.infoLogs) this.state.searchingInfos = false;
                 if (logger === loggers.warnLogs) this.state.searchingWarnings = false;
@@ -418,14 +577,13 @@ export class LogViewer3 extends qreact.Component {
             });
         }));
 
-        stats.totalSearchTime = Date.now() - startTime;
 
         Querysub.commitLocal(() => {
             this.state.results = results;
             this.state.searching = false;
-            this.state.stats = stats;
+            this.state.hasSearched = true;
         });
-    });
+    };
 
     renderResults() {
         let fieldNames = new Set<string>();
@@ -534,7 +692,7 @@ export class LogViewer3 extends qreact.Component {
                 />
             </div>
 
-            {this.state.results.length === 0 && !this.state.searching && <div className={css.hsl(40, 50, 50).colorhsl(60, 50, 100).boldStyle.pad2(10).ellipsis}>
+            {this.state.results.length === 0 && !this.state.searching && this.state.hasSearched && <div className={css.hsl(40, 50, 50).colorhsl(60, 50, 100).boldStyle.pad2(10).ellipsis}>
                 No logs matched, try adjusting your search or time range.
             </div>}
 
@@ -629,11 +787,6 @@ export class LogViewer3 extends qreact.Component {
                         fillWidth
                         focusOnMount
                         url={searchText}
-                        onChangeValue={(value) => {
-                            if (value.length >= MIN_AUTO_SEARCH_LENGTH) {
-                                void this.search();
-                            }
-                        }}
                         onKeyDown={(e) => {
                             if (e.key === "Enter") {
                                 searchText.value = e.currentTarget.value;
@@ -668,27 +821,78 @@ export class LogViewer3 extends qreact.Component {
                     >
                         Search
                     </Button>
-                </div>
-
-                {this.state.loadingPaths && <div>Loading paths...</div>}
-                {this.state.searching && <div>Searching...</div>}
-
-                {this.getPaths().length > 0 && (
-                    <div className={css.hbox(10).fillWidth}>
-                        <FilePathSelector
-                            paths={this.getPaths()}
-                            onChange={(paths) => {
-                                this.state.paths = paths;
-                            }}
-                        />
+                    {this.state.searching && (
                         <Button
-                            onClick={() => this.freezePaths()}
-                            hue={180}
+                            flavor="large"
+                            onClick={() => void this.cancel()}
+                            hue={60}
                         >
-                            Freeze Files ({this.state.paths.length})
+                            Cancel
                         </Button>
-                    </div>
-                )}
+                    )}
+                </div>
+
+                <div className={css.hbox(10).fillWidth}>
+                    <FilePathSelector
+                        paths={this.getPaths()}
+                        onChange={(paths) => {
+                            this.state.paths = paths;
+                            this.freezePaths();
+                        }}
+                        fileErrors={this.state.stats?.fileErrors}
+                    />
+                    <Button
+                        onClick={() => {
+                            if (savedPathsURL.value) {
+                                this.clearFrozenPaths();
+                                void this.loadPaths();
+                            } else {
+                                this.freezePaths();
+                            }
+                        }}
+                        hue={savedPathsURL.value ? 0 : 180}
+                    >
+                        {savedPathsURL.value ? `Clear Frozen Files (${this.getPaths().length})` : `Freeze Files (${this.state.paths.length})`}
+                    </Button>
+                    {!savedPathsURL.value && (
+                        <div className={css.pad2(8, 4).hsl(40, 60, 50).colorhsl(40, 0, 100)}>
+                            Files frozen in memory. Click Preview Files to refresh.
+                        </div>
+                    )}
+                    {(() => {
+                        if (!savedPathsURL.value) return undefined;
+                        const paths = this.getPaths();
+                        const pendingCount = paths.filter(x => x.logCount === undefined).length;
+                        if (pendingCount === 0) return undefined;
+                        return (
+                            <Button
+                                onClick={() => {
+                                    const paths = this.getPaths();
+                                    const nonPendingPaths = paths.filter(x => x.logCount !== undefined);
+                                    const json = JSON.stringify(nonPendingPaths);
+                                    const buffer = Buffer.from(json, "utf8");
+                                    const compressed = LZ4.compress(buffer);
+                                    savedPathsURL.value = compressed.toString("base64");
+                                }}
+                                hue={40}
+                            >
+                                Remove Pending ({pendingCount})
+                            </Button>
+                        );
+                    })()}
+
+                    {this.state.loadingPaths && <div>Loading paths...</div>}
+                    {this.state.searching && (() => {
+                        let searchingSources: string[] = [];
+                        if (this.state.searchingLogs) searchingSources.push("Logs");
+                        if (this.state.searchingInfos) searchingSources.push("Infos");
+                        if (this.state.searchingWarnings) searchingSources.push("Warnings");
+                        if (this.state.searchingErrors) searchingSources.push("Errors");
+                        return <div className={css.pad2(4, 2).hsl(120, 40, 50).colorhsl(120, 0, 100)}>
+                            Searching: {searchingSources.join(", ")}
+                        </div>;
+                    })()}
+                </div>
 
                 {this.renderPendingLogWarnings()}
 

package/src/diagnostics/logs/IndexedLogs/TimeFileTree.ts

@@ -70,7 +70,7 @@ const KEY_MAPPING: Record<string, { field: keyof Omit<TimeFilePath, "fullPath">;
     "compressed": { field: "compressedSize", parseAsNumber: true },
 };
 
-function decodeLogFilePath(path: string): TimeFilePath | undefined {
+export function decodeLogFilePath(path: string): TimeFilePath | undefined {
     if (!path.endsWith(LOG_FILE_EXTENSION)) {
         return undefined;
     }