querysub 0.324.0 → 0.326.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.324.0",
+  "version": "0.326.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -37,7 +37,8 @@
     "depend": "yarn --silent depcruise src --include-only \"^src\" --config --output-type dot | dot -T svg > dependency-graph.svg",
     "test": "yarn typenode ./test.ts",
     "test3": "yarn typenode ./src/test/test.tsx --local",
-    "test2": "yarn typenode ./src/4-dom/qreactTest.tsx --local"
+    "test2": "yarn typenode ./src/4-dom/qreactTest.tsx --local",
+    "error-watch": "yarn typenode ./src/diagnostics/logs/errorNotifications/errorWatchEntry.tsx"
   },
   "bin": {
     "deploy": "./bin/deploy.js",

package/src/-a-archives/archiveCache.ts

@@ -12,10 +12,11 @@ import { Args } from "socket-function/src/types";
 import { getArchivesBackblaze } from "./archivesBackBlaze";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { SizeLimiter } from "../diagnostics/SizeLimiter";
+import { isPublic } from "../config";
 
 const SIZE_LIMIT = new SizeLimiter({
     diskRoot: getStorageDir(),
-    maxBytes: 1024 * 1024 * 1024 * 50,
+    maxBytes: isPublic() ? 1024 * 1024 * 1024 * 250 : 1024 * 1024 * 1024 * 50,
     // Anything less than this and we can't even load enough weights models for a single task
     minBytes: 1024 * 1024 * 1024 * 8,
     maxDiskFraction: 0.3,

package/src/-a-auth/certs.ts

@@ -469,7 +469,8 @@ export function decodeNodeId(nodeId: string, allowMissingThreadId?: "allowMissin
         return undefined;
     }
     let parts = locationObj.address.split(".");
-    if (nodeId.startsWith("127-0-0-1.") && parts.length === 3) {
+    // NOTE: We have to only allow localhost domains on our port as the underlying domain gets stripped when we're looking at the machine ID, So if we allowed localhost domains on other domains, then it would potentially allow the possibility for a server to trick us to connecting to them. And then once the connection is established, it could talk back and we would think it has a localhost machine ID, which is implicitly trusted, which would then give it access to everything. 
+    if (nodeId.startsWith(`127-0-0-1.${getDomain()}`) && parts.length === 3 && nodeId.includes(":")) {
         return {
             threadId: "",
             machineId: parts.at(-3) || "",

package/src/-c-identity/IdentityController.ts

@@ -191,6 +191,7 @@ const changeIdentityOnce = cacheWeak(async function changeIdentityOnce(connectio
     };
     let signature = sign(threadKeyCert, payload);
     await timeoutToError(
+        // NOTE: This timeout has to be small as if we try to connect to a node to send it something time sensitive such as a PathValue and it takes too long it might result in us having a PathValue which is expired. The threshold is around 60 seconds and so we want to build a timeout calling a few different nodes before the PathValue expires. 
         10 * 1000,
         IdentityController.nodes[nodeId].changeIdentity(signature, payload),
         () => new Error(`Timeout calling changeIdentity for ${nodeId}`)

package/src/-d-trust/NetworkTrust2.ts

@@ -1,7 +1,7 @@
 import { measureWrap } from "socket-function/src/profiling/measure";
 import { getIdentityCA, getMachineId, getOwnMachineId } from "../-a-auth/certs";
 import { getArchives } from "../-a-archives/archives";
-import { isNode, throttleFunction, timeInSecond } from "socket-function/src/misc";
+import { isNode, throttleFunction, timeInHour, timeInSecond } from "socket-function/src/misc";
 import { SocketFunctionHook } from "socket-function/SocketFunctionTypes";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { IdentityController_getMachineId } from "../-c-identity/IdentityController";
@@ -19,6 +19,7 @@ import { magenta } from "socket-function/src/formatting/logColors";
 // Cache the untrust list, to prevent bugs from causing too many backend reads (while also allowing
 //  bad servers which make request before their trust is verified from staying broken).
 const UNTRUST_CACHE_TIME = 30 * timeInSecond;
+const TRUSTED_CACHE_RESET_INTERVAL = timeInHour;
 
 const archives = lazy(() => getArchives("trust2/"));
 
@@ -57,6 +58,8 @@ export const isTrusted = measureWrap(async function isTrusted(machineId: string)
     // See the comment in requiresNetworkTrustHook for why clients have to trust all callers.
     if (isClient()) return true;
 
+    await populateTrustedCache();
+
     if (trustedCache.has(machineId)) {
         return true;
     }
@@ -70,31 +73,10 @@ export const isTrusted = measureWrap(async function isTrusted(machineId: string)
         return false;
     }
 
-    return await isTrustedBase(machineId);
-});
-let trustedCachePopulated = false;
-const isTrustedBase = runInSerial(measureWrap(async function isTrustedBase(machineId: string) {
-    if (!trustedCachePopulated) {
-        trustedCachePopulated = true;
-        let trustedMachineIds = await archives().find("");
-        lastArchivesTrusted = trustedMachineIds.slice();
-        for (let trustedMachineId of trustedMachineIds) {
-            trustedCache.add(trustedMachineId);
-            // NOTE: We don't load trust certs here, as we need to load them on demand in case the trust changes after our initial startup.
-        }
-    } else {
-        // Checking a single entry is a lot faster (as find is slow)
-        let trusted = await archives().get(machineId);
-        if (trusted) {
-            trustedCache.add(machineId);
-        }
-    }
-    // Always trust ourself
-    trustedCache.add(getOwnMachineId());
-
-    // NOTE: The only happens in the case WE connected to it (ex, "127-0-0-1.querysubtest.com:15358"). It can't look like this if it connected to us, in which case the nodeId will be "client:...", being mostly random, and created by us (UNTIL they prove they have another id). So... I'm not even sure the isPublic check is required? We only connect to nodes we discover through node discovery, which requires backblaze write permissions. But I guess it's fine to be extra careful about it...
-    if (!isPublic()) {
-        trustedCache.add("127-0-0-1");
+    // Checking a single entry is fast and if we don't trust them they'll be added to untrusted cache so it shouldn't slow things down by too much. 
+    let trusted = await archives().get(machineId);
+    if (trusted) {
+        trustedCache.add(machineId);
     }
 
     if (!trustedCache.has(machineId)) {
@@ -103,7 +85,24 @@ const isTrustedBase = runInSerial(measureWrap(async function isTrustedBase(machi
     } else {
         return true;
     }
-}));
+});
+let populateTrustedCache = lazy(async () => {
+    let trustedMachineIds = await archives().find("");
+    lastArchivesTrusted = trustedMachineIds.slice();
+    for (let trustedMachineId of trustedMachineIds) {
+        trustedCache.add(trustedMachineId);
+    }
+    // Always trust ourself
+    trustedCache.add(getOwnMachineId());
+
+    // NOTE: This only happens to servers that we connect to. Also we only allow the machine ID to be this special ID in the case it's on our domain. And because we use HTTPS when connecting to domains, it means that it must be implicitly trusted if it has a certificate for our domain.
+    trustedCache.add("127-0-0-1");
+
+    setTimeout(() => {
+        trustedCache.clear();
+        populateTrustedCache.reset();
+    }, TRUSTED_CACHE_RESET_INTERVAL);
+});
 
 export async function isNodeTrusted(nodeId: string) {
     let domainName = getNodeIdDomainMaybeUndefined(nodeId);

package/src/-e-certs/EdgeCertController.ts

@@ -129,12 +129,21 @@ export async function publishMachineARecords() {
     let nodeObj = getNodeIdLocation(selfNodeId);
     if (!nodeObj) throw new Error(`Invalid nodeId ${selfNodeId}`);
     let machineAddress = nodeObj.address.split(".").slice(1).join(".");
-    await setRecord("A", machineAddress, ip);
-    await setRecord("A", "*." + machineAddress, ip);
+    let prevMachineIP = await getRecords("A", machineAddress);
     let ipDomain = await getIPDomain();
-    await setRecord("A", ipDomain, ip);
+    let promises: Promise<void>[] = [];
+    promises.push(setRecord("A", ipDomain, ip));
 
-    await publishEdgeDomain();
+
+    if (ip === "127.0.0.1" && prevMachineIP.length > 0 && !prevMachineIP.includes("127.0.0.1")) {
+        console.log(yellow(`Not setting A record for ${machineAddress} to ${ip}, as we previously had a public IP. IF you want to switch back to 127.0.0.1, manually go in and delete the A records for ${machineAddress}. Port forwarding should allow this to work anyways, and the bootstrapper should be smart enough to try 127-0-0-1 style addresses to allow fast development (ex, if you want to download a large file from the local development server quickly).`));
+    } else {
+        promises.push(setRecord("A", machineAddress, ip));
+        promises.push(setRecord("A", "*." + machineAddress, ip));
+    }
+
+    promises.push(publishEdgeDomain());
+    await Promise.all(promises);
 
     return {
         ip,

package/src/0-path-value-core/archiveLocks/ArchiveLocks2.ts

@@ -699,11 +699,15 @@ class TransactionLocker {
                     //  where backblaze returns no files? Which it might be doing, as multiple times this code has
                     //  triggered (without this check), and deletes all of our files...
                     let unconfirmedOldFiles2 = unconfirmedOldFiles.filter(a => !doubleCheckLookup.has(a.file) && doubleCheckDataFiles.has(a.file));
-                    console.warn(red(`Deleted ${unconfirmedOldFiles2.length} very old unconfirmed files`), { files: unconfirmedOldFiles2.map(x => x.file) });
-                    logNodeStats(`archives|TΔ Delete Old Rejected File`, formatNumber, unconfirmedOldFiles2.length);
-                    // At the point the file was very old when we started reading, not part of the active transaction.
-                    for (let file of unconfirmedOldFiles2) {
-                        await this.deleteDataFile(file.file, `old unconfirmed file`);
+                    if (unconfirmedOldFiles2.length > 0) {
+                        console.warn(red(`Deleted ${unconfirmedOldFiles2.length} very old unconfirmed files`), { files: unconfirmedOldFiles2.map(x => x.file) });
+                        logNodeStats(`archives|TΔ Delete Old Rejected File`, formatNumber, unconfirmedOldFiles2.length);
+                        // At the point the file was very old when we started reading, not part of the active transaction.
+                        for (let file of unconfirmedOldFiles2) {
+                            await this.deleteDataFile(file.file, `old unconfirmed file`);
+                        }
+                    } else {
+                        console.warn(`Almost deleted ${unconfirmedOldFiles.length} very old unconfirmed files. This is bad, did we miss their confirmations that first time? If we missed them twice in a row, we might literally delete the database, and need to enter recovery mode to fix it...`, { files: unconfirmedOldFiles });
                     }
                 }
             }

package/src/4-querysub/Querysub.ts

@@ -52,6 +52,7 @@ import yargs, { check } from "yargs";
 import { parseArgsFactory } from "../misc/rawParams";
 
 import * as typesafecss from "typesafecss";
+import "../library-components/urlResetGroups";
 
 
 typesafecss.setMeasureBlock(measureBlock);
@@ -72,6 +73,7 @@ let yargObj = parseArgsFactory()
     .option("verbosenetwork", { type: "boolean", desc: "Log all network activity" })
     .option("verboseframework", { type: "boolean", desc: "Log internal SocketFunction framework" })
     .option("nodelay", { type: "boolean", desc: "Don't delay committing functions, even ones that are marked to be delayed." })
+    .option("hot", { type: "boolean", desc: "force hot reloading to turn on even if public is true." })
     .argv
     ;
 setImmediate(() => {
@@ -724,7 +726,7 @@ export class Querysub {
         }
 
         // Hot reloading on public servers breaks things when we update (as the git pull triggers a hot reload), so... don't do that.
-        if (config.hotReload && !isPublic()) {
+        if (config.hotReload && !isPublic() || yargObj.hot) {
             watchFilesAndTriggerHotReloading();
         }
 

package/src/diagnostics/logs/FastArchiveAppendable.ts

@@ -348,7 +348,7 @@ export class FastArchiveAppendable<Datum> {
             endTime: number;
         };
         cacheBust: number;
-        wantData?: (posStart: number, posEnd: number, json: Buffer, file: FileMetadata) => boolean;
+        getWantData?: (file: FileMetadata) => Promise<((posStart: number, posEnd: number, data: Buffer) => boolean) | undefined>;
         onData: (datum: Datum[], file: FileMetadata) => void;
         // Called after onData
         onStats?: (stats: DatumStats, file: FileMetadata) => void;
@@ -365,7 +365,7 @@ export class FastArchiveAppendable<Datum> {
         };
         stopSynchronize: () => void;
     } | "cancelled"> {
-        let { wantData, onData, onStats } = config;
+        let { onData, onStats } = config;
         // Create unique client sync ID upfront
         let syncId = nextId();
 
@@ -525,12 +525,14 @@ export class FastArchiveAppendable<Datum> {
 
                 let scanProgressCount = 0;
 
+                const wantData = await config.getWantData?.(file);
+
                 function onParsedData(posStart: number, posEnd: number, buffer: Buffer | "done"): MaybePromise<void> {
                     if (buffer !== "done") {
                         scanProgressCount++;
                     }
                     if (buffer !== "done") {
-                        if (wantData && !wantData(posStart, posEnd, buffer, file)) {
+                        if (wantData && !wantData(posStart, posEnd, buffer)) {
                             notMatchedSize += (posEnd - posStart);
                             notMatchedCount++;
                             return;

package/src/diagnostics/logs/FastArchiveViewer.tsx

@@ -31,7 +31,7 @@ const caseInsensitiveParam = new URLParam("caseInsensitive", false);
 export class FastArchiveViewer<T> extends qreact.Component<{
     fastArchives: FastArchiveAppendable<T>[];
     onStart: () => void;
-    getWantData?: () => Promise<((posStart: number, posEnd: number, data: Buffer, file: FileMetadata) => boolean) | undefined>;
+    getWantData?: (file: FileMetadata) => Promise<((posStart: number, posEnd: number, data: Buffer) => boolean) | undefined>;
     onDatums: (source: FastArchiveAppendable<T>, datums: T[], metadata: FileMetadata) => void;
     // Called after onData
     onStats?: (source: FastArchiveAppendable<T>, stats: DatumStats, metadata: FileMetadata) => void;
@@ -103,7 +103,6 @@ export class FastArchiveViewer<T> extends qreact.Component<{
         let fastArchives = Querysub.fastRead(() => this.props.fastArchives);
         let onFinish = Querysub.fastRead(() => this.props.onFinish);
         let getWantData = Querysub.fastRead(() => this.props.getWantData);
-        let wantData = await getWantData?.();
         // Increment sequence number for this new sync attempt
         this.currentSequenceNumber++;
         this.latestSequenceNumber = this.currentSequenceNumber;
@@ -296,35 +295,37 @@ export class FastArchiveViewer<T> extends qreact.Component<{
                 const result = await fastArchive.synchronizeData({
                     range: timeRange,
                     cacheBust: Querysub.fastRead(() => cacheBustParam.value),
-                    wantData: (posStart: number, posEnd: number, data: Buffer, file) => {
-
-                        let isLimited = false;
-                        for (let i = posStart; i < posEnd && !isLimited; i++) {
-                            if (data[i] === limitedBuffer[0]) {
-                                for (let j = 1; j < limitedBuffer.length; j++) {
-                                    if (data[i + j] !== limitedBuffer[j]) {
-                                        break;
-                                    }
-                                    if (j === limitedBuffer.length - 1) {
-                                        isLimited = true;
-                                        break;
+                    getWantData: async (file) => {
+                        let wantData = await getWantData?.(file);
+                        return (posStart: number, posEnd: number, data: Buffer) => {
+                            let isLimited = false;
+                            for (let i = posStart; i < posEnd && !isLimited; i++) {
+                                if (data[i] === limitedBuffer[0]) {
+                                    for (let j = 1; j < limitedBuffer.length; j++) {
+                                        if (data[i + j] !== limitedBuffer[j]) {
+                                            break;
+                                        }
+                                        if (j === limitedBuffer.length - 1) {
+                                            isLimited = true;
+                                            break;
+                                        }
                                     }
                                 }
                             }
-                        }
-                        if (isLimited) {
-                            this.limitedScanCount++;
-                        }
+                            if (isLimited) {
+                                this.limitedScanCount++;
+                            }
 
-                        let matched = true;
-                        if (wantData) {
-                            matched = wantData(posStart, posEnd, data, file);
-                        }
-                        matched = matched && scanMatch(posStart, posEnd, data);
-                        if (isLimited && matched) {
-                            this.limitedMatchCount++;
-                        }
-                        return matched;
+                            // scanMatch is faster than wantData (generally), so run it first
+                            let matched = scanMatch(posStart, posEnd, data);
+                            if (matched && wantData) {
+                                matched = wantData(posStart, posEnd, data);
+                            }
+                            if (isLimited && matched) {
+                                this.limitedMatchCount++;
+                            }
+                            return matched;
+                        };
                     },
                     onData: (datums, file) => {
                         if (!isLatestSync()) return;
@@ -570,9 +571,6 @@ export class FastArchiveViewer<T> extends qreact.Component<{
                         flavor="large"
                         fillWidth
                         onKeyUp={this.handleDownload}
-                        ref2={() => {
-                            void this.handleDownload();
-                        }}
                         noEnterKeyBlur
                         placeholder="Filter terms, ex x | y & z"
                     />
@@ -610,13 +608,23 @@ export class FastArchiveViewer<T> extends qreact.Component<{
                         </div>}
                         {!this.state.finished && <LoaderAurora />}
                         {this.limitedScanCount > 0 && (
-                            <div className={infoDisplay(60).boldStyle}>
-                                {formatNumber(this.limitedScanCount)} scanned logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
+                            <div className={infoDisplay(60).boldStyle.button}
+                                onClick={() => {
+                                    filterParam.value = LOG_LIMIT_FLAG;
+                                    void this.handleDownload();
+                                }}
+                            >
+                                Click here to see {formatNumber(this.limitedScanCount)} scanned logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
                             </div>
                         )}
-                        {this.limitedMatchCount > 0 && (
-                            <div className={infoDisplay(0).boldStyle}>
-                                {formatNumber(this.limitedMatchCount)} matched logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
+                        {this.limitedMatchCount > 0 && filterParam.value && (
+                            <div className={infoDisplay(0).boldStyle.button}
+                                onClick={() => {
+                                    filterParam.value += " & " + LOG_LIMIT_FLAG;
+                                    void this.handleDownload();
+                                }}
+                            >
+                                Click here to see {formatNumber(this.limitedMatchCount)} matched logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
                             </div>
                         )}
                         {this.state.pendingSyncInitializations > 0 && (

package/src/diagnostics/logs/LogViewer2.tsx

@@ -13,7 +13,7 @@ import { logErrors } from "../../errors";
 import { batchFunction, runInSerial } from "socket-function/src/batching";
 import { Querysub } from "../../4-querysub/QuerysubController";
 import { sort, timeInDay, timeInHour } from "socket-function/src/misc";
-import { FastArchiveViewer } from "./FastArchiveViewer";
+import { FastArchiveViewer, filterParam } from "./FastArchiveViewer";
 import { LogDatum, getLoggers, LOG_LIMIT_FLAG } from "./diskLogger";
 import { ColumnType, Table, TableType } from "../../5-diagnostics/Table";
 import { formatDateJSX } from "../../misc/formatJSX";
@@ -24,7 +24,7 @@ import { ObjectDisplay } from "./ObjectDisplay";
 import { endTime } from "../misc-pages/archiveViewerShared";
 import { ErrorSuppressionUI } from "./errorNotifications/ErrorSuppressionUI";
 import { FileMetadata } from "./FastArchiveController";
-import { SuppressionListController, getSuppressEntryChecker } from "./errorNotifications/ErrorNotificationController";
+import { SuppressionListController, getSuppressEntryChecker, getSuppressionFull } from "./errorNotifications/ErrorNotificationController";
 import { SocketFunction } from "socket-function/SocketFunction";
 
 const RENDER_INTERVAL = 1000;
@@ -56,6 +56,7 @@ export class LogViewer2 extends qreact.Component {
     });
 
     private example: string | undefined = undefined;
+    private operationSequenceNum = 0;
     private datumCount = 0;
     private matchedSize = 0;
     private notMatchedSize = 0;
@@ -100,6 +101,10 @@ export class LogViewer2 extends qreact.Component {
             }
         }
 
+        let suppressionController = SuppressionListController(SocketFunction.browserNodeId());
+        let suppressionList = suppressionController.getSuppressionList();
+        let hasErrorNotifyToggle = errorNotifyToggleURL.value;
+
         const timeRange = getTimeRange();
         return (
             <div className={css.vbox(20).pad2(20).fillBoth}>
@@ -114,6 +119,7 @@ export class LogViewer2 extends qreact.Component {
                                 let now = Date.now();
                                 startTimeParam.value = now - timeInDay * 7;
                                 endTimeParam.value = now + timeInHour * 2;
+                                filterParam.value = "";
                             }
                             this.rerun();
                         }}
@@ -148,40 +154,34 @@ export class LogViewer2 extends qreact.Component {
                         this.datums = [];
                         this.suppressionCounts = new Map();
                         this.expiredSuppressionCounts = new Map();
-                    }}
-                    getWantData={async () => {
-                        if (!Querysub.fastRead(() => errorNotifyToggleURL.value)) return undefined;
-                        let suppressionList = await SuppressionListController(SocketFunction.browserNodeId()).getSuppressionList.promise();
-                        let now = Date.now();
-                        // Newest first, so when we add a new entry we can see what it matches, even if it takes it away from older entries
-                        sort(suppressionList, x => -x.lastUpdateTime);
-                        let checkers = suppressionList.map(x => getSuppressEntryChecker(x));
-                        this.suppressionCounts = new Map(suppressionList.map(x => [x.key, 0]));
-                        this.expiredSuppressionCounts = new Map(suppressionList.map(x => [x.key, 0]));
-                        let updateCounts = batchFunction({ delay: 1000 }, () => {
-                            Querysub.commit(() => {
-                                this.state.datumsSeqNum++;
-                            });
-                        });
-                        return (posStart, posEnd, data, file) => {
-                            for (let checker of checkers) {
-                                if (checker.fnc(data, posStart, posEnd)) {
-                                    if (checker.entry.expiresAt < now) {
-                                        let count = this.expiredSuppressionCounts.get(checker.entry.key) || 0;
-                                        count++;
-                                        this.expiredSuppressionCounts.set(checker.entry.key, count);
-                                        void updateCounts(undefined);
-                                    } else {
-                                        let count = this.suppressionCounts.get(checker.entry.key) || 0;
-                                        count++;
-                                        this.suppressionCounts.set(checker.entry.key, count);
-                                        void updateCounts(undefined);
-                                        return false;
-                                    }
+                        this.operationSequenceNum++;
+                        void (async () => {
+                            const currentSequenceNum = this.operationSequenceNum;
+                            while (true) {
+                                await new Promise(resolve => setTimeout(resolve, 1000));
+                                if (this.operationSequenceNum !== currentSequenceNum) {
+                                    break;
                                 }
+                                Querysub.commit(() => {
+                                    this.state.datumsSeqNum++;
+                                });
                             }
-                            return true;
-                        };
+                        })();
+                    }}
+                    getWantData={async (file) => {
+                        if (!hasErrorNotifyToggle) return undefined;
+                        // By defaulting to the synchronous one, the list will be updated if there's any changes. However, we will also just get it asynchronously if the list hasn't been updated by the time we call get1data. And because we assign it back to the variable, it'll be cached. 
+                        suppressionList = suppressionList || await suppressionController.getSuppressionList.promise();
+                        let suppressionFull = getSuppressionFull({
+                            entries: suppressionList,
+                            blockTimeRange: {
+                                startTime: file.startTime,
+                                endTime: file.endTime,
+                            },
+                            suppressionCounts: this.suppressionCounts,
+                            expiredSuppressionCounts: this.expiredSuppressionCounts,
+                        });
+                        return suppressionFull;
                     }}
                     onDatums={(source, datums, file) => {
                         this.datumCount += datums.length;
@@ -212,6 +212,7 @@ export class LogViewer2 extends qreact.Component {
                         }
                     }}
                     onFinish={() => {
+                        this.operationSequenceNum++;
                         Querysub.commit(() => {
                             sort(this.datums, x => -(x.time || 0));
                             this.state.datumsSeqNum++;

package/src/diagnostics/logs/TimeRangeSelector.tsx

@@ -82,10 +82,26 @@ export class TimeRangeSelector extends qreact.Component {
                     >
                         Set to future data
                     </Button>
-                    {(endTimeParam.value || startTimeParam.value) && <Button
+                    <Button
+                        hue={110} onClick={() => {
+                            startTimeParam.value = now - timeInDay;
+                            endTimeParam.value = now + timeInHour * 2;
+                        }}
+                    >
+                        Set to last day
+                    </Button>
+                    <Button
+                        hue={110} onClick={() => {
+                            startTimeParam.value = now - timeInDay * 7;
+                            endTimeParam.value = now + timeInHour * 2;
+                        }}
+                    >
+                        Set to last 7 days
+                    </Button>
+                    {!!(endTimeParam.value || startTimeParam.value) && <Button
                         hue={110} onClick={resetToLastDay}
                     >
-                        Reset to Last Day
+                        Reset
                     </Button>}
                     {(!startTimeParam.value || !endTimeParam.value) && <Button
                         hue={110}