querysub 0.650.0 → 0.652.0

package/overview.md

@@ -0,0 +1,46 @@
+# Querysub Overview
+
+The system is fundamentally a data synchronization system.
+
+## Path values and time
+
+Data exists in path values, which have a path (a structured list of strings) and a value. These are time based: they have the time that they occur at, which is a globally unique time. This time includes a somewhat unique identifier for the server that created the time (best effort — it cannot be relied on, but is usually unique), the time itself, and also a version value that our system uses to create something that happens at the same time, but just an epsilon amount after.
+
+## Locks and validity
+
+Path values also include what are referred to as locks. Locks are essentially a list of reads that were done at the time the path value was created.
+
+Values are evaluated in an eventually consistent manner. A value can be rejected if its locks are rejected. This can mean that the value it read has itself become rejected, or it can mean that the value it read was not the latest value at the time — which we know if we find another value between the creation time of the value that was read and the time that it was read at. That's why it's called a lock: it's a kind of locking of that value between its creation time and the time we read it. Of course, it's a reversed lock — instead of having the writer fail because of the lock, we have the reader fail.
+
+## Synchronization and watchers
+
+Synchronization is very important. We synchronize values between different watchers in a client, and between machines. This is done at a low level in PathWatcher and RemoteWatcher. We have the ability to watch a path, or watch the direct children of a path. There is no recursive watching — if values need to be recursively watched, the watcher has to recursively access more and more each time it receives values, watching more each time.
+
+## Schema
+
+We have a schema system which can simplify accesses and make it so that if values aren't provided, we know whether to default to a primitive value or use a proxy so the code can drill down further.
+
+## Proxy watcher
+
+Most accesses are done using the proxy watcher. This is a system that sits on top of our other systems, letting you write regular JavaScript code to access fields and write to fields as if it were plain JavaScript, with all of the reads and writes being converted to path value reads and writes.
+
+## Client writes, function calls, and predictions
+
+On the client, anything that needs to impact a remote value is mutated by making a special socket function call to the server, asking it to add a function call write — which writes a path value to a specific location. We then have a function runner server that reads from that location, running those functions. The client side also runs these functions, but only as a prediction. That way most actions feel immediate. When the server function runner does eventually run, it updates with the actual results.
+
+## Sharding
+
+The servers are sharded — they are split up over different values. We generally don't do global path hashing. Instead, there are specific paths that a server reads on startup, and it does its hashing by looking at the child key of those paths when they match. These generally match up with lookups, so the hashes are usually the lookup keys. This allows an object's fields to be on the same server — minimizing the number of different servers we access — while still sharding the data.
+
+## Geographic routing
+
+Almost everything has some level of sharding or geographic control. For example, the client side tries to connect to the querysub server — the server that actually adds the function calls and interacts with the client — and it usually connects to the closest one, or the one with the lowest latency. Function runners are also sharded between geographic locations, and the client usually requests one that is close to it.
+
+## Non-core systems
+
+- The binary format of path values, which involves compression, etc.
+- The error notification system.
+- The logging and log search system.
+- The MCP server.
+- QReact, which implements a JSX component renderer using our synchronization system.
+- A machine and service management system.

package/package.json

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

package/src/deployManager/machineApplyMainCode.ts

@@ -31,7 +31,7 @@ import { ProcessRecord, syncProcessRecords, listProcessRecords } from "./process
 
 
 
-const getMemoryInfo = measureWrap(async function getMemoryInfo(): Promise<{ value: number; max: number } | undefined> {
+const getMemoryInfo = measureWrap(async function getMemoryInfo(): Promise<{ memory?: { value: number; max: number }; swap?: { value: number; max: number } } | undefined> {
     if (os.platform() === "win32") {
         throw new Error("Windows is not supported for machine resource monitoring");
     }
@@ -40,17 +40,24 @@ const getMemoryInfo = measureWrap(async function getMemoryInfo(): Promise<{ valu
         // Linux: Use free command
         let result = await runPromise("free -b", { quiet: true });
         let lines = result.split("\n");
-        let memLine = lines.find(line => line.startsWith("Mem:"));
-        if (memLine) {
-            let parts = memLine.split(/\s+/);
+        let parseLine = (prefix: string): { value: number; max: number } | undefined => {
+            let line = lines.find(line => line.startsWith(prefix));
+            if (!line) return undefined;
+            let parts = line.split(/\s+/);
             let total = parseInt(parts[1]);
             let used = parseInt(parts[2]);
-            if (total && used >= 0) {
+            if (total >= 0 && used >= 0) {
                 return { value: used, max: total };
             }
+            return undefined;
+        };
+        let memory = parseLine("Mem:");
+        let swap = parseLine("Swap:");
+        if (memory || swap) {
+            return { memory, swap };
         }
     } catch (e: any) {
-        console.warn(`Error getting memory info: ${e.message}`);
+        console.warn(`Error getting memory info: ${e.stack}`);
     }
     return undefined;
 });
@@ -98,11 +105,19 @@ const getLiveMachineInfo = measureWrap(async function getLiveMachineInfo() {
         getDiskInfo()
     ]);
 
-    if (memoryInfo) {
+    if (memoryInfo?.memory) {
         machineInfo.info.ram = {
             type: "MEMORY",
-            value: memoryInfo.value,
-            max: memoryInfo.max,
+            value: memoryInfo.memory.value,
+            max: memoryInfo.memory.max,
+        };
+    }
+
+    if (memoryInfo?.swap) {
+        machineInfo.info.swap = {
+            type: "SWAP",
+            value: memoryInfo.swap.value,
+            max: memoryInfo.swap.max,
         };
     }
 

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

@@ -20,11 +20,14 @@ import { MCPIndexedLogs, normalizeTime } from "./MCPIndexedLogs";
 import { searchStorageLogsForMCP } from "../../../deployManager/components/storage/storageLogMCPSearch";
 import { getAllNodeIds } from "../../../-f-node-discovery/NodeDiscovery";
 import { NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
-import { formatTime } from "socket-function/src/formatting/format";
+import { formatDateTime, formatTime } from "socket-function/src/formatting/format";
 import { SocketFunction } from "socket-function/SocketFunction";
+import { sort } from "socket-function/src/misc";
+import { getSuppressionEntries } from "../errorNotifications2/errorNotifications";
 
 const DEFAULT_MCP_HTTP_PORT = 4487;
 const NODE_INFO_TIMEOUT_MS = 5000;
+const DEFAULT_SUPPRESSION_LIMIT = 20;
 
 const PROTOCOL_VERSION = "2025-03-26";
 const SERVER_INFO = { name: "querysub-indexed-logs", version: "0.1.0" };
@@ -97,6 +100,19 @@ Query syntax (case-sensitive substring match against each entry's JSON):
             properties: {},
         },
     },
+    {
+        name: "getSuppressions",
+        description: `List error-suppression entries (patterns that stop matching errors from triggering notifications), sorted most-recently-updated first. There can be hundreds, so results are limited (default ${DEFAULT_SUPPRESSION_LIMIT}); use the optional query filter to narrow.
+
+Returns { total, returned, results } — total is the entry count after filtering, results contains { id, pattern, notes, lastUpdated, created, timeout, expired }. All three times are formatted date strings. expired is present (true) when the entry's timeout has passed, meaning it no longer suppresses anything.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number", default: DEFAULT_SUPPRESSION_LIMIT, description: "Maximum entries to return, most recently updated first." },
+                query: { type: "string", description: "Optional case-insensitive substring filter, matched against id, pattern, and notes." },
+            },
+        },
+    },
 ];
 
 type JsonRpcRequest = {
@@ -184,6 +200,8 @@ async function dispatch(method: string, params: unknown, mcp: MCPIndexedLogs): P
             });
         } else if (toolName === "listNodes") {
             result = await getNodeInfos();
+        } else if (toolName === "getSuppressions") {
+            result = await getSuppressionsForMCP(args as { limit?: number; query?: string });
         } else {
             throw new Error(`Unknown tool ${toolName}`);
         }
@@ -220,6 +238,34 @@ async function getNodeInfos(): Promise<NodeInfo[]> {
     );
 }
 
+async function getSuppressionsForMCP(config: { limit?: number; query?: string }) {
+    let limit = config.limit ?? DEFAULT_SUPPRESSION_LIMIT;
+    let entries = await getSuppressionEntries();
+    let query = config.query?.toLowerCase();
+    if (query) {
+        const q = query;
+        entries = entries.filter(x => (x.id + "\n" + x.pattern + "\n" + (x.notes || "")).toLowerCase().includes(q));
+    }
+    sort(entries, x => -x.lastUpdatedTime);
+    let now = Date.now();
+    let results = entries.slice(0, limit).map(x => {
+        let expired: true | undefined;
+        if (x.timeout < now) {
+            expired = true;
+        }
+        return {
+            id: x.id,
+            pattern: x.pattern,
+            notes: x.notes,
+            lastUpdated: formatDateTime(x.lastUpdatedTime),
+            created: formatDateTime(x.createdTime),
+            timeout: formatDateTime(x.timeout),
+            expired,
+        };
+    });
+    return { total: entries.length, returned: results.length, results };
+}
+
 async function main() {
     let mcp = new MCPIndexedLogs();
 

package/src/diagnostics/pathAuditer.ts

@@ -394,22 +394,27 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
             continue;
         }
 
+        let responseMissing = !response.time || compareTime(response.time, epochTime) === 0;
+        if (responseMissing) {
+            response = { ...response, valid: true, isTransparent: true };
+        }
         if (ourValue.isTransparent && response.isTransparent) continue;
 
         if (request.time) {
             let ourExact = authorityStorage.getValueExactMaybeRejected(request.path, request.time);
             if (!ourExact || !ourExact.valid) continue;
             if (compareTime(ourExact.time, epochTime) === 0) continue;
+            if (ourExact.isTransparent && responseMissing) continue;
             // The exact value = server does not have
             //      - Send it our value
-            if (!response.time) {
+            if (!response.time || responseMissing) {
                 valuesToSend.push(ourExact);
                 trackSyncAge({
                     path: request.path,
                     ourTimeId: ourExact.time.time,
                     remoteTimeId: undefined,
                     ourValid: ourExact.valid,
-                    remoteValid: response.valid,
+                    remoteValid: undefined,
                     remoteNodeId: nodeId,
                     reason: "Remote is missing our value, sending it to them",
                 });
@@ -471,14 +476,14 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
         }
         // Our latest valid = server does not have & it's latest valid is older than ours
         //      - Send it our value
-        else if (response.valid === undefined && (!response.time || compareTime(ourValue.time, response.time) > 0)) {
+        else if (responseMissing && compareTime(ourValue.time, epochTime) > 0) {
             valuesToSend.push(ourValue);
             trackSyncAge({
                 path: response.path,
                 ourTimeId: ourValue.time.time,
-                remoteTimeId: response.time?.time,
+                remoteTimeId: undefined,
                 ourValid: ourValue.valid ?? false,
-                remoteValid: response.valid,
+                remoteValid: undefined,
                 remoteNodeId: nodeId,
                 reason: "Remote is missing our value, sending it to them",
             });
@@ -535,12 +540,13 @@ class PathAuditerService {
             } else {
                 value = authorityStorage.getValueAtOrBeforeTime(request.path);
             }
+            value = value || createMissingEpochValue(request.path);
             results.push({
                 path: request.path,
-                time: value?.time,
-                valid: value === undefined ? undefined : value.valid,
-                isTransparent: !!value?.isTransparent,
-                event: !!value?.event,
+                time: value.time,
+                valid: value.valid,
+                isTransparent: !!value.isTransparent,
+                event: !!value.event,
             });
         }
         return results;

package/src/library-components/UsageBar.tsx

@@ -8,8 +8,11 @@ export const MEMORY_WARNING_THRESHOLD = 0.7;
 export const MEMORY_ERROR_THRESHOLD = 0.85;
 export const DISK_WARNING_THRESHOLD = 0.8;
 export const DISK_ERROR_THRESHOLD = 0.92;
+// Swap in use at all means memory pressure already happened, so warn much earlier than RAM.
+export const SWAP_WARNING_THRESHOLD = 0.25;
+export const SWAP_ERROR_THRESHOLD = 0.7;
 
-/** The standard thresholds for the machine resource bar types ("MEMORY" / "DISK"), so every page showing these bars warns identically. */
+/** The standard thresholds for the machine resource bar types ("MEMORY" / "DISK" / "SWAP"), so every page showing these bars warns identically. */
 export function getUsageThresholds(type: string): { warningThreshold?: number; errorThreshold?: number } {
     if (type === "MEMORY") {
         return { warningThreshold: MEMORY_WARNING_THRESHOLD, errorThreshold: MEMORY_ERROR_THRESHOLD };
@@ -17,6 +20,9 @@ export function getUsageThresholds(type: string): { warningThreshold?: number; e
     if (type === "DISK") {
         return { warningThreshold: DISK_WARNING_THRESHOLD, errorThreshold: DISK_ERROR_THRESHOLD };
     }
+    if (type === "SWAP") {
+        return { warningThreshold: SWAP_WARNING_THRESHOLD, errorThreshold: SWAP_ERROR_THRESHOLD };
+    }
     return {};
 }