querysub 0.374.0 → 0.375.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.374.0",
+  "version": "0.375.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -34,9 +34,7 @@
     "join": "./bin/join.js",
     "join-public": "./bin/join-public.js",
     "movelogs": "./bin/movelogs.js",
-    "addsuperuser": "./bin/addsuperuser.js",
-    "error-email": "./bin/error-email.js",
-    "error-im": "./bin/error-im.js"
+    "addsuperuser": "./bin/addsuperuser.js"
   },
   "dependencies": {
     "@types/fs-ext": "^2.0.3",

package/src/deployManager/components/MachineDetailPage.tsx

@@ -7,10 +7,10 @@ import { formatNumber, formatVeryNiceDateTime } from "socket-function/src/format
 import { sort } from "socket-function/src/misc";
 import { ATag, Anchor } from "../../library-components/ATag";
 import { ShowMore } from "../../library-components/ShowMore";
-import { filterParam } from "../../diagnostics/logs/FastArchiveViewer";
 import { managementPageURL } from "../../diagnostics/managementPages";
 import { t } from "../../2-proxy/schema2";
 import { Querysub } from "../../4-querysub/QuerysubController";
+import { getLogViewerParams } from "../../diagnostics/logs/IndexedLogs/LogViewerParams";
 
 export class MachineDetailPage extends qreact.Component {
     render() {
@@ -105,10 +105,7 @@ export class MachineDetailPage extends qreact.Component {
                     <div>
                         Apply Node ID: {machine.applyNodeId}
                     </div>
-                    <ATag values={[
-                        managementPageURL.getOverride("LogViewer2"),
-                        filterParam.getOverride(`__machineId = ${machineInfo.machineId}`),
-                    ]}>
+                    <ATag values={getLogViewerParams({ __machineId: machineInfo.machineId })}>
                         Machine Logs
                     </ATag>
                 </div>

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -20,8 +20,8 @@ import { PrimitiveDisplay } from "../../diagnostics/logs/ObjectDisplay";
 import { parseAnsiColors, rgbToHsl } from "../../diagnostics/logs/ansiFormat";
 import { RenderGitRefInfo, UpdateServiceButtons, bigEmoji, buttonStyle } from "./deployButtons";
 import { TypedConfigEditor } from "../../library-components/TypedConfigEditor";
-import { filterParam } from "../../diagnostics/logs/FastArchiveViewer";
 import { managementPageURL } from "../../diagnostics/managementPages";
+import { getLogViewerParams } from "../../diagnostics/logs/IndexedLogs/LogViewerParams";
 
 
 
@@ -401,10 +401,7 @@ export class ServiceDetailPage extends qreact.Component {
                                     {isWatching ? "Stop Watching Output" : "Watch Screen Output"}
                                 </div>
 
-                                <ATag values={[
-                                    managementPageURL.getOverride("LogViewer2"),
-                                    filterParam.getOverride(`__machineId = ${machineId}`),
-                                ]}>
+                                <ATag values={getLogViewerParams({ __machineId: machineId })}>
                                     Machine Logs
                                 </ATag>
                             </div>

package/src/deployManager/machineApplyMainCode.ts

@@ -866,6 +866,13 @@ export async function machineApplyMain() {
         if (await quickIsOutdated()) {
             console.log(magenta("Likely outdated, resyncing now"));
             await resyncServices();
+        } else {
+            let config = await machineInfos.get(getOwnMachineId());
+            if (config) {
+                config.heartbeat = Date.now();
+                console.log(magenta(`Updating heartbeat for ${getOwnMachineId()} to ${config.heartbeat}`));
+                await machineInfos.set(getOwnMachineId(), config);
+            }
         }
     });
 

package/src/diagnostics/NodeViewer.tsx

@@ -36,8 +36,8 @@ import { SocketRegistered } from "socket-function/SocketFunctionTypes";
 import { ATag } from "../library-components/ATag";
 import { getSyncedController } from "../library-components/SyncedController";
 import child_process from "child_process";
-import { filterParam } from "./logs/FastArchiveViewer";
 import { getHTTPSKeyCert } from "../-e-certs/certAuthority";
+import { getLogViewerParams } from "./logs/IndexedLogs/LogViewerParams";
 
 
 type NodeData = {
@@ -296,10 +296,9 @@ export class NodeViewer extends qreact.Component {
                                         if (str.startsWith("http")) return formatValue(obj);
 
                                         return (
-                                            <ATag values={[
-                                                managementPageURL.getOverride("LogViewer2"),
-                                                filterParam.getOverride(`__nodeId = ${str}`),
-                                            ]}>
+                                            <ATag values={getLogViewerParams({
+                                                __nodeId: str,
+                                            })}>
                                                 Logs
                                             </ATag>
                                         );

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

@@ -16,7 +16,7 @@ export type SearchParams = {
     findBuffer: Buffer;
     pathOverrides?: TimeFilePathWithSize[];
     only?: "local" | "public";
-    forceReadPublic?: boolean;
+    forceReadProduction?: boolean;
 };
 
 export type Unit = number;

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

@@ -272,10 +272,10 @@ export class IndexedLogs<T> {
         startTime: number;
         endTime: number;
         only?: "local" | "public";
-        forceReadPublic?: boolean;
+        forceReadProduction?: boolean;
     }): Promise<TimeFilePathWithSize[]> {
         let finalPaths: TimeFilePathWithSize[] = [];
-        if (config.forceReadPublic && !isPublic()) {
+        if (config.forceReadProduction && !isPublic()) {
             let machineNodes = await this.getMachineNodes();
             if (machineNodes.length === 0) throw new Error(`Cannot find any public nodes to read from`);
             return await IndexedLogShimController.nodes[machineNodes[0]].getPaths({
@@ -352,7 +352,7 @@ export class IndexedLogs<T> {
         onResults?: (results: IndexedLogResults) => Promise<boolean>;
     }): Promise<IndexedLogResults> {
 
-        if (config.params.forceReadPublic && !isPublic()) {
+        if (config.params.forceReadProduction && !isPublic()) {
             let machineNodes = await this.getMachineNodes();
             if (machineNodes.length === 0) throw new Error(`Cannot find any public nodes to read from`);
             return await this.clientFind({
@@ -649,7 +649,7 @@ export class IndexedLogs<T> {
         startTime: number;
         endTime: number;
         only?: "local" | "public";
-        forceReadPublic?: boolean;
+        forceReadProduction?: boolean;
 
     }): Promise<TimeFilePathWithSize[]> {
         let controller = IndexedLogShimController.nodes[SocketFunction.getBrowserNodeId()];
@@ -658,7 +658,7 @@ export class IndexedLogs<T> {
             startTime: config.startTime,
             endTime: config.endTime,
             only: config.only,
-            forceReadPublic: config.forceReadPublic,
+            forceReadProduction: config.forceReadProduction,
         });
     }
     public onFindResult(config: {
@@ -778,7 +778,7 @@ class IndexedLogShim {
         startTime: number;
         endTime: number;
         only?: "local" | "public";
-        forceReadPublic?: boolean;
+        forceReadProduction?: boolean;
     }): Promise<TimeFilePathWithSize[]> {
         let indexedLogs = loggerByName.get(config.indexedLogsName);
         if (!indexedLogs) throw new Error(`Indexed logs ${config.indexedLogsName} not found`);
@@ -786,7 +786,7 @@ class IndexedLogShim {
             startTime: config.startTime,
             endTime: config.endTime,
             only: config.only,
-            forceReadPublic: config.forceReadPublic,
+            forceReadProduction: config.forceReadProduction,
         });
     }
 

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

@@ -26,11 +26,10 @@ import { IndexedLogResults, createEmptyIndexedLogResults, mergeIndexedLogResults
 import { TimeFilePath } from "./TimeFileTree";
 import { isPublic } from "../../../config";
 import { Zip } from "../../../zip";
+import { readProductionLogsURL, searchTextURL } from "./LogViewerParams";
 
-let searchText = new URLParam("searchText", "");
 let excludePendingResults = new URLParam("excludePendingResults", false);
 let limitURL = new URLParam("limit", 100);
-let readPublicLogs = new URLParam("readPublicLogs", false);
 
 let savedPathsURL = new URLParam("savedPaths", "");
 let selectedFieldsURL = new URLParam("selectedFields", {} as Record<string, boolean>);
@@ -105,6 +104,218 @@ export class LogViewer3 extends qreact.Component {
         await this.loadPaths();
     }
 
+    async loadPaths() {
+        if (savedPathsURL.value) {
+            return;
+        }
+
+        Querysub.commitLocal(() => {
+            this.state.loadingPaths = true;
+            this.state.results = [];
+            this.state.stats = undefined;
+        });
+
+        let loggers = await getLoggers2Async();
+        let selectedLoggers: typeof loggers.logLogs[] = [];
+        Querysub.localRead(() => {
+            if (this.state.enableLogs) selectedLoggers.push(loggers.logLogs);
+            if (this.state.enableInfos) selectedLoggers.push(loggers.infoLogs);
+            if (this.state.enableWarnings) selectedLoggers.push(loggers.warnLogs);
+            if (this.state.enableErrors) selectedLoggers.push(loggers.errorLogs);
+        });
+
+        if (selectedLoggers.length === 0) {
+            console.error("No log sources selected");
+            Querysub.commitLocal(() => {
+                this.state.loadingPaths = false;
+            });
+            return;
+        }
+
+        let allPaths: TimeFilePathWithSize[] = [];
+        let range = Querysub.localRead(() => getTimeRange());
+
+        await Promise.all(selectedLoggers.map(async (logger) => {
+            let paths = await logger.clientGetPaths({
+                startTime: range.startTime,
+                endTime: range.endTime,
+                only: excludePendingResults.value ? "public" : undefined,
+                forceReadProduction: readProductionLogsURL.value,
+            });
+            allPaths.push(...paths);
+        }));
+        sort(allPaths, x => -x.startTime);
+
+        Querysub.commitLocal(() => {
+            this.state.paths = allPaths;
+            this.state.loadingPaths = false;
+        });
+        return allPaths;
+    }
+
+    async updateToLatestResults() {
+        let prevPaths = this.getPaths();
+        let newPaths = await this.loadPaths();
+        Querysub.commitLocal(() => {
+            function getHash(path: TimeFilePath): string {
+                return path.threadId + "_" + path.machineId;
+            }
+            let keep = new Set(prevPaths.map(getHash));
+            this.state.paths = newPaths?.filter(x => keep.has(getHash(x))) || [];
+        });
+        await this.search();
+    }
+
+    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 = async () => {
+        await this.cancel();
+        Querysub.commitLocal(() => {
+            this.state.searching = true;
+            this.state.results = [];
+            this.state.stats = undefined;
+            this.state.searchingLogs = false;
+            this.state.searchingInfos = false;
+            this.state.searchingWarnings = false;
+            this.state.searchingErrors = false;
+        });
+
+
+        let loggers = await getLoggers2Async();
+
+        let selectedLoggers: typeof loggers.logLogs[] = [];
+        Querysub.localRead(() => {
+            if (this.state.enableLogs) {
+                selectedLoggers.push(loggers.logLogs);
+                this.state.searchingLogs = true;
+            }
+            if (this.state.enableInfos) {
+                selectedLoggers.push(loggers.infoLogs);
+                this.state.searchingInfos = true;
+            }
+            if (this.state.enableWarnings) {
+                selectedLoggers.push(loggers.warnLogs);
+                this.state.searchingWarnings = true;
+            }
+            if (this.state.enableErrors) {
+                selectedLoggers.push(loggers.errorLogs);
+                this.state.searchingErrors = true;
+            }
+        });
+
+        this.searchSequenceNumber++;
+        let currentSequenceNumber = this.searchSequenceNumber;
+
+        let startTime = Date.now();
+
+        let hasPaths = Querysub.localRead(() => this.getPaths().length > 0);
+        let getFilesTime = 0;
+        if (!hasPaths) {
+            let startTime = Date.now();
+            await this.loadPaths();
+            getFilesTime = Date.now() - startTime;
+        }
+
+
+        if (selectedLoggers.length === 0) {
+            console.error("No log sources selected");
+            Querysub.commitLocal(() => {
+                this.state.searching = false;
+            });
+            return;
+        }
+
+        let searchBuffer = Querysub.localRead(() => Buffer.from(searchTextURL.value, "utf8"));
+        let results: LogDatum[] = [];
+        let stats: IndexedLogResults = createEmptyIndexedLogResults();
+        stats.fileFindTime += getFilesTime;
+
+        let paths = Querysub.localRead(() => this.getPaths());
+
+        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 done = false;
+            let result = await errorToUndefined(logger.clientFind({
+                params: {
+                    startTime: range.startTime,
+                    endTime: range.endTime,
+                    limit: limitURL.value,
+                    findBuffer: searchBuffer,
+                    pathOverrides: paths,
+                    only: excludePendingResults.value ? "local" : undefined,
+                    forceReadProduction: readProductionLogsURL.value,
+                },
+                onResult: (match: LogDatum) => {
+                    console.log("onResult", match);
+                    results.push(match);
+                    void updateResults();
+                },
+                onResults: (loggerStats: IndexedLogResults) => {
+                    if (done) return;
+                    loggerResults.set(logger, loggerStats);
+                    updateStats();
+                },
+            }));
+            done = true;
+
+            if (result) {
+                loggerResults.set(logger, result);
+                updateStats();
+            }
+
+            Querysub.commitLocal(() => {
+                if (logger === loggers.logLogs) this.state.searchingLogs = false;
+                if (logger === loggers.infoLogs) this.state.searchingInfos = false;
+                if (logger === loggers.warnLogs) this.state.searchingWarnings = false;
+                if (logger === loggers.errorLogs) this.state.searchingErrors = false;
+            });
+        }));
+
+
+        Querysub.commitLocal(() => {
+            this.state.results = results;
+            this.state.searching = false;
+            this.state.hasSearched = true;
+        });
+    };
+
     renderSearchStats() {
         const stats = this.state.stats;
         if (!stats) return undefined;
@@ -288,7 +499,7 @@ export class LogViewer3 extends qreact.Component {
                                 <span>is not moving logs to remote storage. {formatNumber(warning.count)} files ({formatNumber(warning.totalSize)}B) are {formatTime(now - warning.oldestTime)} old</span>
                             </div>
                         ))}
-                        {!isPublic() && !readPublicLogs.value && <Button
+                        {!isPublic() && !readProductionLogsURL.value && <Button
                             onClick={async () => {
                                 Querysub.commitLocal(() => {
                                     this.state.forceMoveStartTime = Date.now();
@@ -336,217 +547,6 @@ export class LogViewer3 extends qreact.Component {
         );
     }
 
-    async loadPaths() {
-        if (savedPathsURL.value) {
-            return;
-        }
-
-        Querysub.commitLocal(() => {
-            this.state.loadingPaths = true;
-            this.state.results = [];
-            this.state.stats = undefined;
-        });
-
-        let loggers = await getLoggers2Async();
-        let selectedLoggers: typeof loggers.logLogs[] = [];
-        Querysub.localRead(() => {
-            if (this.state.enableLogs) selectedLoggers.push(loggers.logLogs);
-            if (this.state.enableInfos) selectedLoggers.push(loggers.infoLogs);
-            if (this.state.enableWarnings) selectedLoggers.push(loggers.warnLogs);
-            if (this.state.enableErrors) selectedLoggers.push(loggers.errorLogs);
-        });
-
-        if (selectedLoggers.length === 0) {
-            console.error("No log sources selected");
-            Querysub.commitLocal(() => {
-                this.state.loadingPaths = false;
-            });
-            return;
-        }
-
-        let allPaths: TimeFilePathWithSize[] = [];
-        let range = Querysub.localRead(() => getTimeRange());
-
-        await Promise.all(selectedLoggers.map(async (logger) => {
-            let paths = await logger.clientGetPaths({
-                startTime: range.startTime,
-                endTime: range.endTime,
-                only: excludePendingResults.value ? "public" : undefined,
-                forceReadPublic: readPublicLogs.value,
-            });
-            allPaths.push(...paths);
-        }));
-        sort(allPaths, x => -x.startTime);
-
-        Querysub.commitLocal(() => {
-            this.state.paths = allPaths;
-            this.state.loadingPaths = false;
-        });
-        return allPaths;
-    }
-
-    async updateToLatestResults() {
-        let prevPaths = this.getPaths();
-        let newPaths = await this.loadPaths();
-        Querysub.commitLocal(() => {
-            function getHash(path: TimeFilePath): string {
-                return path.threadId + "_" + path.machineId;
-            }
-            let keep = new Set(prevPaths.map(getHash));
-            this.state.paths = newPaths?.filter(x => keep.has(getHash(x))) || [];
-        });
-        await this.search();
-    }
-
-    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 = async () => {
-        await this.cancel();
-        Querysub.commitLocal(() => {
-            this.state.searching = true;
-            this.state.results = [];
-            this.state.stats = undefined;
-            this.state.searchingLogs = false;
-            this.state.searchingInfos = false;
-            this.state.searchingWarnings = false;
-            this.state.searchingErrors = false;
-        });
-
-
-        let loggers = await getLoggers2Async();
-
-        let selectedLoggers: typeof loggers.logLogs[] = [];
-        Querysub.localRead(() => {
-            if (this.state.enableLogs) {
-                selectedLoggers.push(loggers.logLogs);
-                this.state.searchingLogs = true;
-            }
-            if (this.state.enableInfos) {
-                selectedLoggers.push(loggers.infoLogs);
-                this.state.searchingInfos = true;
-            }
-            if (this.state.enableWarnings) {
-                selectedLoggers.push(loggers.warnLogs);
-                this.state.searchingWarnings = true;
-            }
-            if (this.state.enableErrors) {
-                selectedLoggers.push(loggers.errorLogs);
-                this.state.searchingErrors = true;
-            }
-        });
-
-        this.searchSequenceNumber++;
-        let currentSequenceNumber = this.searchSequenceNumber;
-
-        let startTime = Date.now();
-
-        let hasPaths = Querysub.localRead(() => this.getPaths().length > 0);
-        let getFilesTime = 0;
-        if (!hasPaths) {
-            let startTime = Date.now();
-            await this.loadPaths();
-            getFilesTime = Date.now() - startTime;
-        }
-
-
-        if (selectedLoggers.length === 0) {
-            console.error("No log sources selected");
-            Querysub.commitLocal(() => {
-                this.state.searching = false;
-            });
-            return;
-        }
-
-        let searchBuffer = Querysub.localRead(() => Buffer.from(searchText.value, "utf8"));
-        let results: LogDatum[] = [];
-        let stats: IndexedLogResults = createEmptyIndexedLogResults();
-        stats.fileFindTime += getFilesTime;
-
-        let paths = Querysub.localRead(() => this.getPaths());
-
-        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 done = false;
-            let result = await errorToUndefined(logger.clientFind({
-                params: {
-                    startTime: range.startTime,
-                    endTime: range.endTime,
-                    limit: limitURL.value,
-                    findBuffer: searchBuffer,
-                    pathOverrides: paths,
-                    only: excludePendingResults.value ? "local" : undefined,
-                    forceReadPublic: readPublicLogs.value,
-                },
-                onResult: (match: LogDatum) => {
-                    console.log("onResult", match);
-                    results.push(match);
-                    void updateResults();
-                },
-                onResults: (loggerStats: IndexedLogResults) => {
-                    if (done) return;
-                    loggerResults.set(logger, loggerStats);
-                    updateStats();
-                },
-            }));
-            done = true;
-
-            if (result) {
-                loggerResults.set(logger, result);
-                updateStats();
-            }
-
-            Querysub.commitLocal(() => {
-                if (logger === loggers.logLogs) this.state.searchingLogs = false;
-                if (logger === loggers.infoLogs) this.state.searchingInfos = false;
-                if (logger === loggers.warnLogs) this.state.searchingWarnings = false;
-                if (logger === loggers.errorLogs) this.state.searchingErrors = false;
-            });
-        }));
-
-
-        Querysub.commitLocal(() => {
-            this.state.results = results;
-            this.state.searching = false;
-            this.state.hasSearched = true;
-        });
-    };
 
     renderResults() {
         let fieldNames = new Set<string>();
@@ -695,8 +695,8 @@ export class LogViewer3 extends qreact.Component {
                     />
                     {!isPublic() && <InputLabelURL
                         checkbox
-                        label="Read Public Logs"
-                        url={readPublicLogs}
+                        label="Read Production Logs"
+                        url={readProductionLogsURL}
                         onChangeValue={(newValue) => {
                             if (newValue) {
                                 savedPathsURL.value = "";
@@ -754,7 +754,7 @@ export class LogViewer3 extends qreact.Component {
                     </Button>
                     <TimeRangeSelector />
                 </div>
-                {!isPublic() && readPublicLogs.value && <div className={css.fontSize(40).pad2(12, 6).hsl(280, 40, 50).colorhsl(0, 0, 100).boldStyle}>
+                {!isPublic() && readProductionLogsURL.value && <div className={css.fontSize(40).pad2(12, 6).hsl(280, 40, 50).colorhsl(0, 0, 100).boldStyle}>
                     Reading public logs
                 </div>}
 
@@ -763,10 +763,10 @@ export class LogViewer3 extends qreact.Component {
                         flavor="large"
                         fillWidth
                         focusOnMount
-                        url={searchText}
+                        url={searchTextURL}
                         onKeyDown={(e) => {
                             if (e.key === "Enter") {
-                                searchText.value = e.currentTarget.value;
+                                searchTextURL.value = e.currentTarget.value;
                                 void this.search();
                             }
                         }}
@@ -776,6 +776,7 @@ export class LogViewer3 extends qreact.Component {
                             flavor="large"
                             onClick={() => void this.loadPaths()}
                             hue={this.state.paths.length ? 200 : 120}
+                            className={css + (this.state.loadingPaths && css.opacity(0.5))}
                         >
                             {this.getPaths().length && "Reset Files" || "Preview Files"}
                         </Button>
@@ -835,7 +836,7 @@ export class LogViewer3 extends qreact.Component {
                     >
                         {savedPathsURL.value ? `Clear Frozen Files (${this.getPaths().length})` : `Freeze Files (${this.state.paths.length})`}
                     </Button>
-                    {!savedPathsURL.value && (
+                    {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>