querysub 0.455.0 → 0.456.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.455.0",
+  "version": "0.456.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

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

@@ -585,8 +585,8 @@ export class ArchivesBackblaze {
                 console.error(`[${context}] getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });
             }
 
-            // TODO: Handle if the bucket is deleted?
-            console.error(`[${context}] giving up after ${3 - retries + 1} attempts: ${err.stack ?? err}`);
+            // NOTE: The AI thought case that happens when we run out of retries, that's stupid. This obviously isn't the case. This is the case when it's a normal error, as in the file doesn't exist, we need to throw. We absolutely should not warn here. Warning here wouldn't be anything. It would just be saying, oh, we checked if a file and it didn't, which is normal, which is why we check if a file exists. 
+
             throw err;
         }
     }

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -418,16 +418,27 @@ async function fastMemorySync() {
         }
     }
     let checkNodes = shuffle(Array.from(aliveNodes), Date.now()).slice(0, API_AUDIT_COUNT);
-    let otherNodesAll = await Promise.all(
-        checkNodes.map(async nodeId => {
-            let nodes = await timeoutToUndefinedSilent(200, NodeDiscoveryController.nodes[nodeId].getAllNodeIds());
+    let perPeerNodes = await Promise.all(
+        checkNodes.map(async peerNodeId => {
+            let nodes = await timeoutToUndefinedSilent(200, NodeDiscoveryController.nodes[peerNodeId].getAllNodeIds());
             if (!nodes) {
-                deadNodes.set(nodeId, Date.now());
+                deadNodes.set(peerNodeId, Date.now());
             }
-            return nodes || [];
+            return { peerNodeId, nodes: nodes || [] };
         })
     );
-    let otherNodes = Array.from(new Set(otherNodesAll.flat()));
+    let reportedBy = new Map<string, string[]>();
+    for (let { peerNodeId, nodes } of perPeerNodes) {
+        for (let nodeId of nodes) {
+            let reporters = reportedBy.get(nodeId);
+            if (!reporters) {
+                reporters = [];
+                reportedBy.set(nodeId, reporters);
+            }
+            reporters.push(peerNodeId);
+        }
+    }
+    let otherNodes = Array.from(reportedBy.keys());
     // This would log WAY too much, because we poll a lot, because we want to minimize downtime
     //console.log(magenta(`Fast memory sync at ${formatVeryNiceDateTime(Date.now())}, nodes found ${otherNodes.length}`), getDebuggerUrl());
 
@@ -436,8 +447,30 @@ async function fastMemorySync() {
     //  sync now.
     let missingNodes = otherNodes.filter(nodeId => !allNodeIds2.has(nodeId));
     if (missingNodes.length > 0) {
-        console.log(yellow(`Node list is missing nodes, resyncing node`), { missingNodes, otherNodes });
+        let missingNodeReporters = Object.fromEntries(
+            missingNodes.map(nodeId => [nodeId, reportedBy.get(nodeId) ?? []])
+        );
+        console.log(yellow(`Node list is missing nodes, resyncing node`), { missingNodes, missingNodeReporters, otherNodes });
         await syncArchives();
+
+        // If after syncing our own archive view those nodes are STILL missing, then they are
+        //  ghosts in the peer's in-memory allNodeIds2 — push a targeted resync to each peer that
+        //  told us about a ghost, so they can drop it from their own allNodeIds2.
+        let stillMissing = missingNodes.filter(nodeId => !allNodeIds2.has(nodeId));
+        if (stillMissing.length > 0) {
+            let peersToResync = new Set<string>();
+            for (let nodeId of stillMissing) {
+                for (let peerNodeId of reportedBy.get(nodeId) ?? []) {
+                    if (isOwnNodeId(peerNodeId)) continue;
+                    peersToResync.add(peerNodeId);
+                }
+            }
+            let reason = `ghost-resync: peer reported nodes not in our archive after sync: ${stillMissing.join("|")}`;
+            console.log(yellow(`Pushing targeted resync to ${peersToResync.size} peers`), { stillMissing, peers: Array.from(peersToResync) });
+            for (let peerNodeId of peersToResync) {
+                ignoreErrors(NodeDiscoveryController.nodes[peerNodeId].resyncNodes(reason));
+            }
+        }
     }
 }
 

package/src/5-diagnostics/Table.tsx

@@ -5,6 +5,7 @@ import preact from "preact";
 import { showModal } from "./Modal";
 import { FullscreenModal } from "./FullscreenModal";
 import { canHaveChildren } from "socket-function/src/types";
+import { measureBlock } from "socket-function/src/profiling/measure";
 
 // Undefined means we infer the column
 // Null means the column is removed
@@ -24,6 +25,13 @@ export type TableType<RowT extends RowType = RowType> = {
 
 module.hotreload = true;
 
+const SHALLOW_CACHE_MAX_SIZE = 100_000;
+type ShallowCacheEntry = {
+    columns: ColumnsType;
+    cells: preact.ComponentChild[];
+};
+const shallowCacheMap = new Map<RowType, ShallowCacheEntry>();
+
 export class Table<RowT extends RowType> extends qreact.Component<TableType<RowT> & {
     class?: string;
     cellClass?: string;
@@ -34,6 +42,10 @@ export class Table<RowT extends RowType> extends qreact.Component<TableType<RowT
     characterLimit?: number;
     dark?: boolean;
 
+    // If true, cache the rendered cells per row (keyed by row reference + columns reference).
+    // Resets the cache wholesale once it exceeds SHALLOW_CACHE_MAX_SIZE.
+    shallowCache?: boolean;
+
     getRowAttributes?: (row: RowT, index: number) => preact.JSX.HTMLAttributes<HTMLTableRowElement>;
 }> {
     state = {
@@ -60,75 +72,93 @@ export class Table<RowT extends RowType> extends qreact.Component<TableType<RowT
                         <th class={css.pad2(8, 4) + cellClass}>{column?.title || toSpaceCase(columnName)}</th>
                     )}
                 </tr>
-                {rows.map((row, index) => (
-                    <tr
-                        class={
-                            (index % 2 === 1 && css.hsla(0, 0, 100, 0.25) || "")
-                            // NOTE: We don't set z-index, so children z-index values can be laid out above our siblings
-                            //  (if we set z-index it will create a new z-index order under us, and our children will never
-                            //      be able to above our siblings, which breaks palettes).
-                            + css.relative
+                {rows.map((row, index) => {
+                    const renderCells = () => Object.entries(columns).filter(x => x[1] !== null).map(([columnName, column]) => {
+                        let value = row[columnName];
+                        let formatter = column?.formatter || "guess";
+                        let result = measureBlock(() => formatValue(value, formatter, { row, columnName }), `formatValue|${columnName}`);
+                        let renderedObj = renderTrimmed({
+                            content: result,
+                            lineLimit,
+                            characterLimit,
+                        });
+                        let attributes = { ...renderedObj.outerAttributes };
+                        attributes.class = attributes.class || "";
+                        attributes.class += " " + css.whiteSpace("pre-wrap").pad2(8, 4);
+                        attributes.class += cellClass;
+                        // If the inner content looks like a VNode, take it's attributes and unwrap it,
+                        //  so it can fill the entire cell.
+                        let innerContent = renderedObj.innerContent;
+                        if (
+                            canHaveChildren(innerContent) && "props" in innerContent
+                            && canHaveChildren(innerContent.props)
+                            // Table can't show gap, so don;t collapse if it has gap.
+                            && !((innerContent.props?.class as string + " " + innerContent.props?.className as string).includes("gap"))
+                            // NOTE: I'm not sure why we were only elevating the children if we only had 1 child?
+                            //  Changing this will break things, but it should be better overall.
+                            // && "children" in innerContent.props
+                            // && (
+                            //     Array.isArray(innerContent.props.children) && innerContent.props.children.length === 1
+                            //     || !Array.isArray(innerContent.props.children)
+                            // )
+                            // AND, it is a div (a tags shouldn't be unwrapped)
+                            && (innerContent.type === "div")
+                        ) {
+                            attributes.class += " " + (innerContent.props.class || "");
+                            attributes.class += " " + (innerContent.props.className || "");
+                            let baseOnClick = attributes.onClick;
+                            let props = innerContent.props;
+                            attributes.onClick = (e) => {
+                                if (baseOnClick) baseOnClick(e);
+                                (props as any).onClick?.(e);
+                            };
+                            for (let key in props) {
+                                if (key === "class") continue;
+                                if (key === "onClick") continue;
+                                (attributes as any)[key] = props[key];
+                            }
+                            innerContent = props.children as any;
                         }
-                        {...this.props.getRowAttributes?.(row, index)}
-                    >
-                        <td class={css.center}>{index + 1}</td>
-                        {Object.entries(columns).filter(x => x[1] !== null).map(([columnName, column]) => {
-                            let value = row[columnName];
-                            let formatter = column?.formatter || "guess";
-                            let result = formatValue(value, formatter, { row, columnName });
-                            let renderedObj = renderTrimmed({
-                                content: result,
-                                lineLimit,
-                                characterLimit,
-                            });
-                            let attributes = { ...renderedObj.outerAttributes };
-                            attributes.class = attributes.class || "";
-                            attributes.class += " " + css.whiteSpace("pre-wrap").pad2(8, 4);
-                            attributes.class += cellClass;
-                            // If the inner content looks like a VNode, take it's attributes and unwrap it,
-                            //  so it can fill the entire cell.
-                            let innerContent = renderedObj.innerContent;
-                            if (
-                                canHaveChildren(innerContent) && "props" in innerContent
-                                && canHaveChildren(innerContent.props)
-                                // Table can't show gap, so don;t collapse if it has gap.
-                                && !((innerContent.props?.class as string + " " + innerContent.props?.className as string).includes("gap"))
-                                // NOTE: I'm not sure why we were only elevating the children if we only had 1 child?
-                                //  Changing this will break things, but it should be better overall.
-                                // && "children" in innerContent.props
-                                // && (
-                                //     Array.isArray(innerContent.props.children) && innerContent.props.children.length === 1
-                                //     || !Array.isArray(innerContent.props.children)
-                                // )
-                                // AND, it is a div (a tags shouldn't be unwrapped)
-                                && (innerContent.type === "div")
-                            ) {
-                                attributes.class += " " + (innerContent.props.class || "");
-                                attributes.class += " " + (innerContent.props.className || "");
-                                let baseOnClick = attributes.onClick;
-                                let props = innerContent.props;
-                                attributes.onClick = (e) => {
-                                    if (baseOnClick) baseOnClick(e);
-                                    (props as any).onClick?.(e);
-                                };
-                                for (let key in props) {
-                                    if (key === "class") continue;
-                                    if (key === "onClick") continue;
-                                    (attributes as any)[key] = props[key];
-                                }
-                                innerContent = props.children as any;
+                        return <td
+                            {...attributes}
+                            data-column={columnName}
+                            // If it ever becomes non-table cell, it breaks the table
+                            style={{ display: "table-cell" }}
+                        >
+                            {innerContent}
+                        </td>;
+                    });
+                    let cells: preact.ComponentChild[];
+                    if (this.props.shallowCache) {
+                        const cached = shallowCacheMap.get(row);
+                        if (cached && cached.columns === columns) {
+                            cells = cached.cells;
+                        } else {
+                            if (shallowCacheMap.size >= SHALLOW_CACHE_MAX_SIZE) {
+                                shallowCacheMap.clear();
+                            }
+                            cells = renderCells();
+                            shallowCacheMap.set(row, { columns: columns as ColumnsType, cells });
+                        }
+                    } else {
+                        cells = renderCells();
+                    }
+                    return (
+                        <tr
+                            class={
+                                (index % 2 === 1 && css.hsla(0, 0, 100, 0.25) || "")
+                                // NOTE: We don't set z-index, so children z-index values can be laid out above our siblings
+                                //  (if we set z-index it will create a new z-index order under us, and our children will never
+                                //      be able to above our siblings, which breaks palettes).
+                                + css.relative
                             }
-                            return <td
-                                {...attributes}
-                                data-column={columnName}
-                                // If it ever becomes non-table cell, it breaks the table
-                                style={{ display: "table-cell" }}
-                            >
-                                {innerContent}
-                            </td>;
-                        })}
-                    </tr>
-                ))}
+                            {...this.props.getRowAttributes?.(row, index)}
+                        >
+                            <td class={css.center}>{index + 1}</td>
+                            {cells}
+                        </tr>
+                    );
+                })}
                 {allRows.length > rows.length && <tr>
                     <td
                         colSpan={1 + Object.keys(columns).length}

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

@@ -47,7 +47,9 @@ let enableErrorsURL = new URLParam("enableErrors", true);
 let savedPathsURL = new URLParam("savedPaths", "");
 let selectedFieldsURL = new URLParam("selectedFields", {} as Record<string, boolean>);
 let useRelativeTimeURL = new URLParam("useRelativeTime", true);
-let showLifecycleColumnURL = new URLParam("showlifecycle", true);
+
+// NOTE: Because this doesn't cache properly, it lags a lot, so we shouldn't try to use it. 
+let showLifecycleColumnURL = new URLParam("showlifecycle", false);
 
 const defaultSelectedFields = {
     param0: true,
@@ -74,7 +76,7 @@ export class LogViewer3 extends qreact.Component {
         hasSearched: t.boolean(false),
         forceMoveStartTime: t.atomic<number | undefined>(undefined),
         forceMoveEndTime: t.atomic<number | undefined>(undefined),
-        showLifecycleColumn: t.boolean(true),
+        showLifecycleColumn: t.boolean(false),
     });
 
     lifecycleController = LifeCyclesController(SocketFunction.browserNodeId());
@@ -640,6 +642,7 @@ export class LogViewer3 extends qreact.Component {
             </div>}
 
             <Table
+                shallowCache
                 rows={this.state.results}
                 columns={columns}
                 lineLimit={4}