querysub 0.324.0 → 0.326.0

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

@@ -109,74 +109,201 @@ export const getSuppressEntryChecker = cacheLimited(
     }
 );
 
+export const getSuppressionFull = measureWrap(function getSuppressionFull(config: {
+    entries: SuppressionEntry[];
+    blockTimeRange: {
+        startTime: number;
+        endTime: number;
+    };
+    suppressionCounts?: Map<string, number>;
+    expiredSuppressionCounts?: Map<string, number>;
+    // => wants data
+}): ((posStart: number, posEnd: number, data: Buffer, obj?: { outdatedSuppressionKey?: string }) => boolean) {
+    let { entries, blockTimeRange } = config;
+    const { suppressionCounts, expiredSuppressionCounts } = config;
+    // Add some buffer, just in case entries get added a bit later, or early.
+    let startTime = blockTimeRange.startTime - timeInHour;
+    let endTime = blockTimeRange.endTime + timeInHour;
+
+    sort(entries, x => -x.lastUpdateTime);
+
+    let checkers = entries.map(x => getSuppressEntryChecker(x));
+
+    let definitelyNotExpired = checkers.filter(x => x.entry.expiresAt > endTime);
+    let definitelyExpired = checkers.filter(x => x.entry.expiresAt < startTime);
+    let maybeExpired = checkers.filter(x => x.entry.expiresAt >= startTime && x.entry.expiresAt <= endTime);
+
+    return (posStart, posEnd, data, obj) => {
+        let suppressed = false;
+        for (let checker of definitelyNotExpired) {
+            if (checker.fnc(data, posStart, posEnd)) {
+                if (!suppressionCounts && !expiredSuppressionCounts && !obj) {
+                    return false;
+                }
+                suppressed = true;
+                if (!suppressionCounts) break;
+
+                let count = suppressionCounts.get(checker.entry.key) || 0;
+                count++;
+                suppressionCounts.set(checker.entry.key, count);
+            }
+        }
+
+        // Handle definitelyExpired - these are outdated suppressions
+        let mostRecentOutdatedSuppressionKey: string | undefined = undefined;
+
+        // Handle maybeExpired - need to parse timestamp to check if suppression was active
+        if (maybeExpired.length > 0 && (suppressionCounts || expiredSuppressionCounts || obj)) {
+            const getLogTime = () => {
+                try {
+                    let logEntry = JSON.parse(data.slice(posStart, posEnd).toString()) as LogDatum;
+                    return typeof logEntry.time === "number" ? logEntry.time : 0;
+                } catch {
+                    return 0;
+                }
+            };
+            let logTime = getLogTime();
+
+            for (let checker of maybeExpired) {
+                if (checker.fnc(data, posStart, posEnd)) {
+                    if (checker.entry.expiresAt >= logTime) {
+                        suppressed = true;
+                        if (suppressionCounts) {
+                            let count = suppressionCounts.get(checker.entry.key) || 0;
+                            count++;
+                            suppressionCounts.set(checker.entry.key, count);
+                        }
+                    } else {
+                        if (!mostRecentOutdatedSuppressionKey) {
+                            mostRecentOutdatedSuppressionKey = checker.entry.key;
+                        }
+                        // Even if we don't want the expired suppression counts, we might want the normal suppression counts, so we have to keep going. 
+                        if (expiredSuppressionCounts) {
+                            let count = expiredSuppressionCounts.get(checker.entry.key) || 0;
+                            count++;
+                            expiredSuppressionCounts.set(checker.entry.key, count);
+                        }
+                    }
+                }
+            }
+        }
+
+        if (expiredSuppressionCounts || obj) {
+            for (let checker of definitelyExpired) {
+                if (checker.fnc(data, posStart, posEnd)) {
+                    // First match is the most recent (entries are sorted by lastUpdateTime desc)
+                    if (!mostRecentOutdatedSuppressionKey) {
+                        mostRecentOutdatedSuppressionKey = checker.entry.key;
+                    }
+                    if (!expiredSuppressionCounts) break;
+                    let count = expiredSuppressionCounts.get(checker.entry.key) || 0;
+                    count++;
+                    expiredSuppressionCounts.set(checker.entry.key, count);
+                }
+            }
+        }
+
+        // Set the most recent outdated suppression key if we found any and weren't suppressed
+        if (obj && mostRecentOutdatedSuppressionKey && !suppressed) {
+            obj.outdatedSuppressionKey = mostRecentOutdatedSuppressionKey;
+        }
+
+        return !suppressed;
+    };
+});
+
 
 const suppressionListKey = "suppression-list.json";
 const suppressionListArchive = archiveJSONT<SuppressionListBase>(() =>
     getArchives("suppression-list"),
 );
+const suppressionUpdatedChannel = new SocketChannel<boolean>("suppression-updated");
 
 class SuppressionList {
+    private init = lazy(async () => {
+        suppressionUpdatedChannel.watch(() => {
+            void this.updateEntriesNow();
+        });
+    });
+    private updateEntriesNow = async () => {
+        let entries = await suppressionListArchive.get(suppressionListKey);
+        if (!entries) {
+            entries = { entries: {} };
+        }
+        this.getEntries.set(Promise.resolve(entries));
+    };
     private getEntries = lazy(async (): Promise<SuppressionListBase> => {
+        await this.init();
         await runInfinitePollCallAtStart(SUPPRESSION_POLL_INTERVAL, async () => {
-            let entries = await suppressionListArchive.get(suppressionListKey);
-            if (!entries) {
-                entries = { entries: {} };
-            }
-            await suppressionListArchive.set(suppressionListKey, entries);
-            this.getEntries.set(Promise.resolve(entries));
+            await this.updateEntriesNow();
         });
         // Infinite poll will have set this, so we don't infinitely loop
         return await this.getEntries();
     });
 
     public async filterObjsToNonSuppressed(objs: LogDatum[]): Promise<LogDatum[]> {
-        // NOTE: Streamed data should be rare enough
+        // NOTE: Streamed data should be rare enough, that handling this inefficiently is okay.
+        if (objs.length === 0) return [];
+        let startTime = objs[0].time;
+        let endTime = objs[objs.length - 1].time;
         let parts: Buffer[] = [];
         for (let obj of objs) {
             parts.push(Buffer.from(JSON.stringify(obj)));
             parts.push(objectDelimitterBuffer);
+            if (obj.time < startTime) {
+                startTime = obj.time;
+            }
+            if (obj.time > endTime) {
+                endTime = obj.time;
+            }
         }
         let buffer = Buffer.concat(parts);
-        let scanner = await this.scanForRecentErrors();
+        let scanner = await this.scanForRecentErrors({
+            startTime,
+            endTime,
+        });
         await scanner.onData(buffer);
         return await scanner.finish();
     }
-    public async scanForRecentErrors(): Promise<{
+    public async scanForRecentErrors(config: {
+        startTime: number;
+        endTime: number;
+    }): Promise<{
         onData: (data: Buffer) => void;
         finish: () => Promise<LogDatum[]>;
     }> {
         let entries = await this.getEntries();
-        let now = Date.now();
-        let checkers = Object.values(entries.entries)
-            .map(entry => getSuppressEntryChecker(entry))
-            ;
+        let suppressionFull = getSuppressionFull({
+            entries: Object.values(entries.entries),
+            blockTimeRange: {
+                startTime: config.startTime,
+                endTime: config.endTime,
+            },
+        });
         let datums: LogDatum[] = [];
+        // Create an object which we'll reuse that will be the output object for the suppression key. 
+        // for the suppression key. 
+        let obj: { outdatedSuppressionKey?: string } = {};
         let callback = createLogScanner({
             onParsedData: (posStart, posEnd, buffer) => {
                 if (buffer === "done") {
                     return;
                 }
-                let outdatedSuppressionKey: string | undefined = undefined;
-                for (let checker of checkers) {
-                    if (checker.fnc(buffer, posStart, posEnd)) {
-                        if (checker.entry.expiresAt < now) {
-                            outdatedSuppressionKey = checker.entry.key;
-                            continue;
-                        }
-                        return;
-                    }
-                }
-                let obj: LogDatum;
+                let result = suppressionFull(posStart, posEnd, buffer, obj);
+
+                if (!result) return;
+
+                let datum: LogDatum;
                 try {
-                    obj = JSON.parse(buffer.slice(posStart, posEnd).toString()) as LogDatum;
+                    datum = JSON.parse(buffer.slice(posStart, posEnd).toString()) as LogDatum;
                 } catch (e: any) {
                     process.stderr.write(`Failed to parse log datum in around ${buffer.slice(posStart, posEnd).slice(0, 100).toString("hex")}, error is:\n${e.stack}`);
                     return;
                 }
-                if (outdatedSuppressionKey) {
-                    obj.__matchedOutdatedSuppressionKey = outdatedSuppressionKey;
+                if (obj.outdatedSuppressionKey) {
+                    datum.__matchedOutdatedSuppressionKey = obj.outdatedSuppressionKey;
                 }
-                datums.push(obj);
+                datums.push(datum);
             },
         });
         let lastWaitTime = Date.now();
@@ -201,13 +328,15 @@ class SuppressionList {
         let entries = await this.getEntries();
         entry.lastUpdateTime = Date.now();
         entries.entries[entry.key] = entry;
-        await suppressionListArchive.set(suppressionListKey, entries);
+        void suppressionListArchive.set(suppressionListKey, entries);
+        suppressionUpdatedChannel.broadcast(true);
         await recentErrors.onSuppressionChanged();
     }
     public async removeSuppressionEntry(key: string) {
         let entries = await this.getEntries();
         delete entries.entries[key];
-        await suppressionListArchive.set(suppressionListKey, entries);
+        void suppressionListArchive.set(suppressionListKey, entries);
+        suppressionUpdatedChannel.broadcast(true);
         await recentErrors.onSuppressionChanged();
     }
 
@@ -378,7 +507,9 @@ const limitRecentErrors = measureWrap(function limitRecentErrors(objs: LogDatum[
 class RecentErrors {
 
     private initialize = lazy(async () => {
-        errorWatcherBase.watch(x => this.addErrors(x));
+        errorWatcherBase.watch(x => {
+            void this.addErrors(x);
+        });
         await this.scanNow({});
         runInfinitePoll(BACKBLAZE_POLL_INTERVAL, async () => {
             await this.scanNow({ noLocalFiles: true });
@@ -415,6 +546,7 @@ class RecentErrors {
     });
 
     private async addErrors(objs: LogDatum[]) {
+        if (objs.length === 0) return;
         for (let obj of objs) {
             this._recentErrors.push(obj);
         }
@@ -464,7 +596,10 @@ class RecentErrors {
                     let hash = getFileMetadataHash(file);
                     path = await urlCache.getURLLocalPath(file.url, hash);
                     if (!path) continue;
-                    let scanner = await suppressionList.scanForRecentErrors();
+                    let scanner = await suppressionList.scanForRecentErrors({
+                        startTime: file.startTime,
+                        endTime: file.endTime,
+                    });
 
                     // Stream decompress the file while reading it
                     size = await fs.promises.stat(path).then(x => x.size);
@@ -554,7 +689,7 @@ export const RecentErrorsController = getSyncedController(SocketFunction.registe
     },
 });
 
-const recentErrorsChannel = new SocketChannel<true>("recent-errors-eeceb0c8-4086-4ab3-b3ff-fa9fd5282e14");
+export const recentErrorsChannel = new SocketChannel<true>("recent-errors-eeceb0c8-4086-4ab3-b3ff-fa9fd5282e14");
 
 export const watchRecentErrors = lazy(function watchRecentErrors() {
     recentErrorsChannel.watch(async () => {
@@ -571,7 +706,9 @@ export const notifyWatchersOfError = batchFunction({
 },
     async (objs: LogDatum[]) => {
         objs = await suppressionList.filterObjsToNonSuppressed(objs);
-        errorWatcherBase.broadcast(objs);
+        if (objs.length > 0) {
+            errorWatcherBase.broadcast(objs);
+        }
     }
 );
 

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

@@ -60,7 +60,7 @@ export class ErrorSuppressionUI extends qreact.Component<{
         const previewMatchCount = this.calculatePreviewMatchCount(this.state.matchedInput);
 
         return <div className={css.vbox(16).pad2(16).fillWidth.bord2(0, 0, 50, 5).hsl(0, 0, 80)}>
-            <h2 className={css.fontSize(18).marginTop(0)}>Error Suppression List</h2>
+            <div className={css.fontSize(18)}>Error Suppression List ({formatNumber(entries.length)})</div>
 
             <div className={css.hbox(8).fillWidth}>
                 <InputLabel
@@ -133,7 +133,7 @@ export class ErrorSuppressionUI extends qreact.Component<{
                         });
                     });
                 }}>
-                    Not an error
+                    Not a bug
                 </Button>
             </div>
 
@@ -192,22 +192,28 @@ export class ErrorSuppressionUI extends qreact.Component<{
                             Ignore (for a week)
                         </Button>
                         <Button onClick={() => updateEntry({ expiresAt: NOT_AN_ERROR_EXPIRE_TIME })}>
-                            Not an error
+                            Not a bug
                         </Button>
                         <Button
                             onClick={() => updateEntry({ expiresAt: Date.now() - timeInDay * 7 })}
-                            title="Unignore"
+                            title="Unignore, so past errors show up again as errors"
                         >
                             Unignore
                         </Button>
+                        <Button
+                            onClick={() => updateEntry({ expiresAt: Date.now() })}
+                            title="Set ignore time to now, so any future errors will receive notifications"
+                        >
+                            Ignore previous
+                        </Button>
                         {entry.expiresAt === NOT_AN_ERROR_EXPIRE_TIME && <span>
-                            Not an error
+                            Not a bug
                         </span>}
                         {entry.expiresAt < Date.now() && <span>
-                            Expired
+                            Expired {formatDateJSX(entry.expiresAt)}
                         </span>}
                         {entry.expiresAt > Date.now() && entry.expiresAt !== NOT_AN_ERROR_EXPIRE_TIME && <span>
-                            Expires in {formatDateJSX(Date.now() * 2 - entry.expiresAt)}
+                            Expires {formatDateJSX(entry.expiresAt)}
                         </span>}
                         <span className={css.opacity(0.5)}>
                             (Last Updated: {formatDateJSX(entry.lastUpdateTime)})

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

@@ -10,9 +10,12 @@ import { ATag } from "../../../library-components/ATag";
 import { managementPageURL, showingManagementURL } from "../../managementPages";
 import { errorNotifyToggleURL } from "../LogViewer2";
 import { Querysub } from "../../../4-querysub/QuerysubController";
-import { nextId, timeInDay } from "socket-function/src/misc";
+import { nextId, timeInDay, timeInHour } from "socket-function/src/misc";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { Icon } from "../../../library-components/icons";
+import { filterParam } from "../FastArchiveViewer";
+import { endTimeParam, startTimeParam } from "../TimeRangeSelector";
+import { formatDateJSX } from "../../../misc/formatJSX";
 
 export class ErrorWarning extends qreact.Component {
     state = t.state({
@@ -64,9 +67,18 @@ export class ErrorWarning extends qreact.Component {
                 </style>
             </Button>;
 
+        const logLink = [
+            showingManagementURL.getOverride(true),
+            managementPageURL.getOverride("LogViewer2"),
+            errorNotifyToggleURL.getOverride(true),
+            filterParam.getOverride(""),
+            startTimeParam.getOverride(Date.now() - timeInDay * 7),
+            endTimeParam.getOverride(Date.now() + timeInHour * 2),
+        ];
+
         if (!recentErrors || recentErrors.length === 0) {
             return <span className={css.hbox(8)}>
-                <ATag target="_blank" values={[showingManagementURL.getOverride(true), managementPageURL.getOverride("LogViewer2"), errorNotifyToggleURL.getOverride(true)]}>
+                <ATag target="_blank" values={logLink}>
                     No Errors
                 </ATag>
                 {refreshButton}
@@ -112,7 +124,7 @@ export class ErrorWarning extends qreact.Component {
                         ⚠️ {fileCountText} files with errors
                     </div>
 
-                    <ATag target="_blank" values={[showingManagementURL.getOverride(true), managementPageURL.getOverride("LogViewer2"), errorNotifyToggleURL.getOverride(true)]}>
+                    <ATag target="_blank" values={logLink}>
                         View Logs
                     </ATag>
                     {refreshButton}
@@ -139,7 +151,7 @@ export class ErrorWarning extends qreact.Component {
                     </div>
                 }
                 <div className={css.hbox(8).hsl(0, 50, 50).pad2(4, 2).colorhsl(0, 50, 95)}>
-                    {recentErrors[0].param0} ({recentErrors[0].__NAME__})
+                    ({formatDateJSX(recentErrors[0].time)}) {recentErrors[0].param0} ({recentErrors[0].__NAME__})
                 </div>
 
                 <div className={css.hbox(8).fillWidth}>

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

@@ -0,0 +1,78 @@
+import { batchFunction, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { getControllerNodeId } from "../../../-g-core-values/NodeCapabilities";
+import { RecentErrorsController, recentErrorsChannel, watchRecentErrors } from "./ErrorNotificationController";
+import { timeInSecond } from "socket-function/src/misc";
+import { formatDateTime } from "socket-function/src/formatting/format";
+
+
+
+// 3) Dismissing of certain errors is not working. They keep coming back.
+//      - I think our expiry date comparison code might be wrong. It seems like once they leave the maybe expired range they come back immediately. If we can reproduce this locally, it'll be trivial to debug because the suppression stuff is global, so we can just see if there are any errors, and if there are, we break in on them. 
+// UGH... To debug this, we need to ignore the changes and then we need to work on the other stuff and then we need to come back later and see if those changes have shown up again. We basically need to debug it when it happens. We can't debug it now. It's too late, Now the errors should be showing up because they are expired. 
+
+
+// The constant error notifications might be fixed now. We'll see tomorrow after all the rolling updates finish. 
+// 4) fix whatever's causing constant error notifications. Something is broadcasting on the Recent Errors Change channel constantly. 
+//      - I guess usually there's no server that's going to be listening on it. So it's... Not that big of a deal, but it's still annoying. 
+
+
+//  4.1) update channel watching so you can specify that you want to watch only on a specific node ID and then update our code so we only watch it on the controller node ID that we're interfacing with. 
+
+
+// 5) Verify our suppression updates broadcast across the channel correctly, causing us to be able to suppress a notification and our watching script to then stop seeing the new updates. Realistically, it's the calling script that stops setting them, but same thing. 
+
+
+
+// 5) Set up the Instant Messaging Sending API. 
+//  - Discord. With beeper it won't really matter what we're messaging. We could also do WhatsApp. It's really all the same.  
+
+// 6) Set up all the code to properly rate limit IMs, batch them, link back to the log page, etc. 
+//      - Just link to the error page for the last week. We don't need to link to anything specific. 
+//      - properly getting the node ID that we're going to be watching, and if it goes down, getting a new one, and ignoring messages from the old node. 
+//      - And if no node exists, we need to warn and then wait. 
+
+
+// 7) Write the digest script, which is very different, but will run in the same entry.
+//      - Separate warnings and errors and also bucket by time bucket
+//      - suppressed errors by time bucket (but no type, as we definitely don't want to parse all suppressed errors...)
+//      - Time the entire thing, and put that, and the profile, in the digest too! That will give us a good gauge on if the errors/suppressions are getting slow (due to a lot of errors, or a lot of suppression checks!)
+// 8) Write a page that shows the results of the digest in tabs, writing the digest probably just to backblaze 
+//      - For now, just have two tabs, one for errors and one for warnings. 
+//      - If we're going to do a full scan, we might as well show time series data as well. It's trivial. 
+//      - Also track the number of suppressed errors as well. We won't have details on these such as a breakdown, but we can at least show the count (and the count by time)
+// 9) send an email every time period, and also send an IM that has smaller information
+//      - Both will link to the actual web page that has the digest, deep linking to the specific tabs. 
+//      - Show the chart in the email as well, but just format it like ASCII Because image dependencies are annoying and I don't want to implement them right now as it might take a few days to get working. 
+
+async function runIMNotifies() {
+    let controllerNodeId = await getControllerNodeId(RecentErrorsController.base);
+    if (!controllerNodeId) throw new Error("No controller node id found");
+    //todonext
+    //  Temporary hardcode to use the local server
+    controllerNodeId = "127-0-0-1.querysubtest.com:7007";
+
+    let controller = RecentErrorsController.base.nodes[controllerNodeId];
+    recentErrorsChannel.watch(() => {
+        void updateRecentErrors(undefined);
+    });
+    const updateRecentErrors = batchFunction(
+        //todonext
+        //  Increase this after we finish testing
+        { delay: 1000 },
+        async function updateRecentErrors() {
+            let recentErrors = await controller.getRecentErrors();
+            console.log(`Received ${recentErrors.length} recent errors at ${formatDateTime(Date.now())}`);
+            for (let error of recentErrors) {
+                console.log(`    ${error.param0}`);
+            }
+            console.log();
+            console.log();
+        }
+    );
+    await updateRecentErrors(undefined);
+}
+
+async function main() {
+    void runIMNotifies();
+}
+void main();

package/src/diagnostics/logs/lifeCycleAnalysis/spec.md

@@ -4,34 +4,6 @@ Very small amount of data
     https://127-0-0-1.querysubtest.com:7007/?hot&enableLogs&page=login&filter=%22431%22&showingmanagement&endTime=1755140880000&startTime=1754950020000&managementpage=LogViewer2
 
 
-3) Our time range is not being correctly applied. We have data from 4-5, and are filtering from 4:25 to 5:32, and not matching that data, even though it overlaps a lot.
-4) API watchers are repeatedly dying. I feel like this is fixable, especially with our logs...
-
-5) Update all services, and move them to that machine
-5) Verify the hezner server can run the site well
-6) Take down our digital ocean server
-7) Destroy our digital ocean server
-
-9) Add a filter to JUST see rate limited logs (by clicking on the button. which just searches for the special text)
-    - say "click here to view rate limited logs"
-
-10) "Started Listening" isn't being logged?
-    - https://127-0-0-1.querysubtest.com:7007/?enableLogs&page=login&showingmanagement&endTime=1757835685102.667&managementpage=LogViewer2&machineview=service-detail&startTime=1757745685102.667&serviceId=service-1756340309836&filter=__machineId%20%3D%20a794fbcf7b104c68%20%26%20Edge
-    - Or... maybe logs are lost SOMETIMES, and ALWAYS when we kill the server? Although... that would mean we have multiple issues. Ugh...
-
-11) API ranges overlapped? What? I think our code to pick an empty range is wrong?
-
-6) Update URLParam to allow linking it to other parameters, resetting when they change.
-    - With a function, and have standard one beside URLParam (that uses page and tab)
-        - ALSO managementPageURL
-    - Reset filter in FastArchiveViewer
-        - First observe the overlap with it and the BookOverview
-        - If we are actually on the book overview page and we close the management page then that shouldn't reset it. We just want to reset it when you change pages. Because we want you to be able to hide and show the management page quickly if you want to double check something. Generally speaking though, you won't be on a page with filter and then going back and forth. And if you are, whatever. That's just the management page. We just want to avoid the overall confusion and annoyance of having lots of pre-filled values (And mostly the confusion of having filter prefilled all the time because it's always going to be set because everyone uses it and no one resets it at the moment. 
-    - DON'T reset tab. It's useful to remember the tab? Hmm... sometimes at least...
-
-
-
-
 5) IM error notifications - allow immediately knowing about production issues, for better testing
     - Create a dedicated entry point which acts like a client of the HTTP server, using RecentErrorControllers.getRecentErrors
         - Getting it working in a script will be interesting, but... in theory it should just work?
@@ -48,67 +20,34 @@ Very small amount of data
     - For now this will just be for:
         - non-suppressed errors
         - suppressed errors
-    - Eventually the goal of this is to add our tracking charts to this. There are some really useful metrics we can track. 
-        - unique visit IPs. 
-        - Percent bounces. 
-        - average visit length and also median visit length top 95" bottom 5" 
-        - average stories read average story percentages read 
-        - percent of first page story views by subscribers percent of fifth page story view by subscribers 
-        - Number of users visiting the fifth page.
-        - New subscriptions
-        - Subscription cancellations
-        - Total subscriptions
 
 
 
 5) Life cycle analyzer
+    - Implement regular range lifecycles first (matching an === object field)
+        - THEN, Add lifecycle collections where we can define life cycles that have a certain type. 
+            - A collection that has everything by default and we remove life cycles from it would also be useful.
+        - AFTER that, MAYBE, support global values, setting them, and referencing them in the life cycle (which makes them shown as a whole, AND on each line in the life cycle, so we can see the progression).
+            - We have to allow selecting the value we want as well based on a lifecycle state that it can set with its logs. And then we're basically building expression. The whole thing becomes very complicated. So maybe we won't even do it. 
+            - We should definitely wait until we create life cycles and find use out of them before we start adding global values. 
+    - It seems like life cycles have two types. 
+        1) Set global values for user in other logs
+            - Allows for providing specific context, such as what are all the nodes that exist at this time, What are all the paths, authorities that exist, etc, So we can tell what the results should be by essentially knowing what the other values are on other servers inst... antly in a way that the current node couldn't possibly know at that time (And because it can't know it, it couldn't log it. So it's the only way to get this information).
+        2) Range based, a bunch of values connected via an === object field, making one range
+            - allows reducing the complexity of an analysis, by taking lots of different logs and reducing it to just one.. 
+                - IMPORTANT! Show the time and the count of logs in the life cycle.  
+                - also allows us to look at them as a whole, as in how long did it take. Which is minor because we could just measure it, However, sometimes it's annoying to pass the start time information around And if we don't pass the start time around, then we need to look at the start time from the first log and the end time for the last log, which again, would require looking at it as a lifecycle analysis. 
+            - allows adding information based on the existence or the non-existence of a log in that group, such as A setup process missing the last step. 
+                - IMPORTANT! we need to support this by allowing defining life cycles as requiring certain field value combinations which we will end up making basically just the field will always be type and the value will be the type in that life cycle and we'll hard code all the steps that are required and then we can warn when there's a missing step
+                    - I guess also show the count of every single step because that's useful to see if some things were repeated. 
+            - Allows drilling into a lifecycle to see just the specific information of the lifecycle cross server
+                - Otherwise, it's somewhat annoying to look at things cross-server, and while we can search for a specific key that we log, which is exactly what life cycles will do, it's easier to just click to drilldown, rather than having to make the query dynamically every time we want it. 
+        2.1) Collections of life cycles so we can further reduce the complexity. 
     - Uses FastArchiveViewer, but instead of showing a table, shows lifecycles (a derived concept)
         - We save them in backblaze, with a bit of cache for loading them
-    - List of life cycles
-    - Life cycle
-        - Title
-        - Operation list (each supports | / &, but having multiple is even better)
-            - Match filter
-            - Group key extractions (optional, if not set it becomes a singleton)
-                - Just a field name
-                - CAN have multiple, which adds us as multiple life cycles
-                    - With each one being namespaced using the key, so we can tell them apart
-            - Global value setting (optional, if not set it has no global state impact)
-                - A list of set values
-                    - Each one is an expression which can use fields in the object, ex:
-                    - `alivePathValueServers.$threadId = true`
-            - Show AND SHOULDN'T include match filters!
-                - So when we should the count matched, we can show stats for these, which will often be should have "finished", and shouldn't have "error", so we can see completed, and errors
-                - Similar to error notifications, but... it's nice to also have this here, as we could miss the notification, or suppress it, but when we are looking at a life cycle it's relevant skyrockets.
-                - ALSO for start, so we can see cutoff starts!
-    OH! How do we handle cut off starts?
-        - Maybe... we have a "read preload" duration, and... we read that, BUT, only include life cycles which are also in our main selected time. So we don't cut anything off in our main time, but don't add new values which also get cut off!
-    - Same time/machine/thread selector as log viewer
-    - Allow filtering to specific life cycles
-        - After download, shows matches per life cycle
-        - Button to reset to all
-    - Download logs, and scan for selected life cycles
-        - Immediately on load, showing progress and throttling, so it's not too bad
-    - Result 
-        - List of life cycles, with count of each
-        - Table of individual life cycles?
-        - Can then filter within these life cycles by searching
-        - BUT, importantly, if any log is matched in a life cycle, the entire life cycle is matched
-        - AND, global settings for ALL life cycles are applied, not just filtered ones!
-    - Table of result life cycles
-        - Preview shows first matched line
-        - ALSO, shows duration of life cycle!
-        - And start date
-        - Expand to see pin that specific life cycle above
-            - Show list of logs in it, in another table, with searching on each of them
-            - Start date AND duration of each line!
-        - Can pin multiple life cycles (I guess might as well)
-    - Show list of global value expressions as well (limited, but with filtering to search them easily)
-        - Can expand a global value to see object (but again... limited?)
-    - Can select a specific global value path, to have it injected into
-        - a column for before and after each life cycle
-        - A column for after each line within a life cycle
-        - Can also select parent values, to show all paths under that (use ShowMore, to make them manageable...)
+    - show the life cycles and allow viewing just the specific life cycles and then drilling into those life cycles. Also allow viewing multiple at once so we can view a stream that has many life cycles (as in life cycle collections, which we can also save. )
+    - Show overlap when we're showing the list of life cycles by having it first sorted by start time and then have some kind of indicator for how many values after the value it overlaps with. So if it's serial there'll be no overlap. If everything is being queued up and then run in serial we'll see the overlap go from 1, 2, 3, 4, 5, 6, 7, 8, etc. If it's just in parallel, it'll count up to a number and then go up and down a little bit as values are added and removed. If everything's added at once and it's in parallel, then the values will go up, but then they'll very quickly go down.
+        - Maybe we should have some indication for how much parallel overlap there is? Or kind of like how much gap there is to the start time of the next thing and to the end time of the next thing, something like that. 
 
 6) Add life cycles for
     - Node discovery life cycle (new node, check for alive, check for paths, etc)
@@ -121,6 +60,7 @@ Very small amount of data
         - Use different keys for threadId, and, triggeredNodeId, so we can track how a node discovers other nodes, vs how a node is discovered
         - Mark as dead, dead count increases, remove node as dead
             - MAYBE there should be 2 lifecycles, one for all, and one for just creation type stuff (no discovery)
+    - There's a life cycle for something dying which starts when we first see it's dead and ends when the count reaches the maximum. We want to use the capability to change the ending state so we can have it as partially dead but not fully dead or fully dead so we can see if the dead life cycles keep starting but not finishing which would be bad. 
     - Trusted machine lifecycle
         - Check if we need to add trust
         - Add trust to archives
@@ -147,6 +87,10 @@ Very small amount of data
     - Re-enable all of our services as well.
     - Just logs MIGHT be able to do it, but... life cycles should make it a lot easier to correlate logs, which is something we need to do anyways to solve it...
 
+Make sure we check our life cycles for nodes being added and removed to make sure that life cycle path is pretty empty and there aren't nodes constantly being lost and re-added. 
+
+Check the startup lifecycle to make sure we can detect the nodes pretty fast and in parallel, instead of serial
+
 10) Verify old user/fast-log-cache machine folders are deleted
 
 

package/src/diagnostics/managementPages.tsx

@@ -230,7 +230,8 @@ export async function isManagementUser() {
         debugName: "isManagementUser",
         call: testCall,
     });
-    return !!writes.result;
+    let isTrustedResult = !!writes.result;
+    return isTrustedResult;
 }
 
 export async function assertIsManagementUser() {