querysub 0.441.0 → 0.442.0

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

@@ -0,0 +1,389 @@
+import { timeInHour, timeInMinute, timeoutToError, timeoutToUndefined, timeoutToUndefinedSilent } from "socket-function/src/misc";
+import { lazy } from "socket-function/src/caching";
+import { getMachineId } from "../../../-a-auth/certs";
+import { getAllNodeIds, getOwnMachineId, isOwnNodeId } from "../../../-f-node-discovery/NodeDiscovery";
+import { NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
+import { getLoggers2Async, LogDatum } from "../diskLogger";
+import { Archives } from "../../../-a-archives/archives";
+import { TimeFilePath, TimeFileTree } from "./TimeFileTree";
+import { BufferReader, INDEX_EXTENSION, createEmptyIndexedLogResults } from "./BufferIndexHelpers";
+import { BufferIndex } from "./BufferIndex";
+import { LogStreamer } from "./LogStreamer";
+import { createMatchesPattern } from "./bufferSearchFindMatcher";
+import { IndexedLogs, IndexedLogShimController } from "./IndexedLogs";
+import { formatDateTime, formatTime } from "socket-function/src/formatting/format";
+
+// endTime must be at least this far in the past — we never want to search the
+// most-recent slice (it's still being written to and not yet promoted to public).
+const END_TIME_MIN_AGE = timeInMinute;
+// After we trigger forceMoveLogsToPublic for a machine, we record that the
+// machine's logs are guaranteed to be in public storage up through (now - this).
+const MOVE_GRACE = timeInMinute;
+// TTL for the path-cache (the slow TimeFileTree.findAllPaths walk).
+const PATHS_CACHE_TTL = timeInMinute;
+
+const LOGGER_NAMES = ["logs/log", "logs/info", "logs/warn", "logs/error"] as const;
+type LoggerName = typeof LOGGER_NAMES[number];
+
+export type SearchResult = {
+    allColumns: string[];
+    results: Record<string, string>[];
+    // Per-logger file counts: how many we found in range vs how many we
+    // actually searched (cutoff-pruning skips the rest).
+    files: Record<string, { total: number; scanned: number }>;
+    // Both fields are only present when we stopped early because we hit
+    // `limit`. Their *presence* signals truncation; their absence means the
+    // results are complete. (We rely on JSON.stringify dropping undefined
+    // fields so callers see them only when they matter.)
+    limitHit?: true;
+    note?: string;
+};
+
+type Direction = "fromStart" | "fromEnd";
+
+// Accept epoch ms (number) or any string `new Date(...)` understands. String
+// inputs without a timezone designator are interpreted as local time, which is
+// what callers typically have on hand (e.g. "2026-05-09 03:00").
+function normalizeTime(value: string | number, label: string): number {
+    if (typeof value === "number") return value;
+    let asNumber = Number(value);
+    if (!Number.isNaN(asNumber) && value.trim() !== "") return asNumber;
+    let parsed = new Date(value).getTime();
+    if (Number.isNaN(parsed)) {
+        throw new Error(`${label}: could not parse ${JSON.stringify(value)} as a time`);
+    }
+    return parsed;
+}
+
+export class MCPIndexedLogs {
+    // machineId -> latest timestamp guaranteed to already be moved-to-public.
+    private movedThroughByMachine = new Map<string, number>();
+
+    // Cache: `${type}|${loggerName}|${startBucket}|${endBucket}` -> { time, paths }.
+    // Buckets are hour-aligned start/end so adjacent searches reuse work.
+    private pathsCache = new Map<string, { time: number; paths: TimeFilePath[] }>();
+
+    public async search(config: {
+        query: string;
+        machine: string | "local";
+        startTime: string | number;
+        endTime: string | number;
+        direction: Direction;
+        columns: string[];
+        limit?: number;
+    }): Promise<SearchResult> {
+        let limit = config.limit ?? 100;
+        let startTime = normalizeTime(config.startTime, "startTime");
+        let endTime = normalizeTime(config.endTime, "endTime");
+        console.log(`[search] query=${JSON.stringify(config.query)} | machine=${config.machine} | startTime=${formatDateTime(startTime)} | endTime=${formatDateTime(endTime)} | direction=${config.direction} | columns=[${config.columns.join(",")}] | limit=${config.limit ?? "(default)"}`);
+        let now = Date.now();
+        if (endTime > now - END_TIME_MIN_AGE) {
+            throw new Error(`endTime must be at least ${formatTime(END_TIME_MIN_AGE)} in the past (got ${formatTime(now - endTime)} ago)`);
+        }
+        if (startTime >= endTime) {
+            throw new Error(`startTime (${formatDateTime(startTime)}) must be < endTime (${formatDateTime(endTime)})`);
+        }
+
+        let machineId = config.machine === "local" ? getOwnMachineId() : config.machine;
+
+        let moveStart = Date.now();
+        let moveOutcome = await this.ensureMovedThrough(machineId, endTime);
+        console.log(`[search] ensureMovedThrough ${moveOutcome} in ${formatTime(Date.now() - moveStart)}`);
+
+        let loggers = await getLoggers2Async();
+        let useType: "local" | "public" = config.machine === "local" ? "local" : "public";
+        let queryBuffer = Buffer.from(config.query, "utf8");
+        let matchesPattern = createMatchesPattern(queryBuffer, false);
+
+        // Gather all files (across the 4 loggers) into a single time-ordered list.
+        type FileEntry = {
+            path: TimeFilePath;
+            loggerName: LoggerName;
+            archives: Archives;
+        };
+        let allFiles: FileEntry[] = [];
+
+        // Per-logger counts: total = files in range matching this machine,
+        // scanned = files we actually opened and ran findMatchingBlocks on.
+        let fileCounts: Record<string, { total: number; scanned: number }> = {};
+        for (let name of LOGGER_NAMES) fileCounts[name] = { total: 0, scanned: 0 };
+
+        let pathsStart = Date.now();
+        let totalPathsSeen = 0;
+        await Promise.all(LOGGER_NAMES.map(async (loggerName) => {
+            let logger = this.getLoggerByName(loggers, loggerName);
+            let archives = logger.debugGetCachedLogs({ type: useType });
+
+            let paths = await this.getCachedPaths({
+                archives,
+                type: useType,
+                loggerName,
+                startTime,
+                endTime,
+            });
+            totalPathsSeen += paths.length;
+
+            for (let p of paths) {
+                if (p.machineId !== machineId) continue;
+                if (p.endTime < startTime || p.startTime > endTime) continue;
+                allFiles.push({ path: p, loggerName, archives });
+                fileCounts[loggerName].total++;
+            }
+        }));
+        console.log(`[search] paths gathered in ${formatTime(Date.now() - pathsStart)} (totalSeen=${totalPathsSeen} matchedMachine=${allFiles.length})`);
+
+        if (config.direction === "fromStart") {
+            allFiles.sort((a, b) => a.path.startTime - b.path.startTime);
+        } else {
+            allFiles.sort((a, b) => b.path.startTime - a.path.startTime);
+        }
+
+        // Sequentially walk files in time-order, applying a moving cutoff once
+        // we have `limit` rows: any unprocessed file whose entire range is past
+        // the cutoff cannot contribute results we'd keep.
+        // - fromStart: cutoff = min(processed.endTime); skip files with startTime >= cutoff
+        // - fromEnd:   cutoff = max(processed.startTime); skip files with endTime   <= cutoff
+        let resultRows: Record<string, string>[] = [];
+        let allColumnsSet = new Set<string>();
+        let stats = createEmptyIndexedLogResults();
+        let cutoff: number | undefined;
+        let filesScanned = 0;
+
+        let searchStart = Date.now();
+        outer: for (let entry of allFiles) {
+            if (resultRows.length >= limit) break;
+            let p = entry.path;
+            if (cutoff !== undefined) {
+                if (config.direction === "fromStart") {
+                    if (p.startTime >= cutoff) continue;
+                } else {
+                    if (p.endTime <= cutoff) continue;
+                }
+            }
+
+            let indexBuf = await entry.archives.get(p.fullPath + INDEX_EXTENSION);
+            if (!indexBuf) continue;
+            let dataBuf = await entry.archives.get(p.fullPath);
+            if (!dataBuf) continue;
+            let dataReader = new BufferReader(dataBuf);
+
+            let blocks: number[];
+            try {
+                blocks = await BufferIndex.findMatchingBlocks({
+                    index: indexBuf,
+                    dataReader,
+                    query: queryBuffer,
+                    results: stats,
+                });
+                filesScanned++;
+                fileCounts[entry.loggerName].scanned++;
+            } catch (e) {
+                console.warn(`MCPIndexedLogs.search: error scanning ${p.fullPath + INDEX_EXTENSION}: ${(e as Error).stack ?? e}`);
+                continue;
+            }
+
+            if (config.direction === "fromStart") {
+                blocks.sort((a, b) => a - b);
+            } else {
+                blocks.sort((a, b) => b - a);
+            }
+
+            for (let block of blocks) {
+                if (resultRows.length >= limit) break outer;
+
+                let buffers: Buffer[];
+                try {
+                    buffers = await BufferIndex.getBlockBuffers({
+                        index: indexBuf,
+                        dataReader,
+                        blockIndex: block,
+                    });
+                } catch (e) {
+                    console.warn(`MCPIndexedLogs.search: error reading block ${block} of ${p.fullPath}: ${(e as Error).stack ?? e}`);
+                    continue;
+                }
+
+                let iterateForward = config.direction === "fromStart";
+                let bStart = iterateForward ? 0 : buffers.length - 1;
+                let bEnd = iterateForward ? buffers.length : -1;
+                let bStep = iterateForward ? 1 : -1;
+                for (let i = bStart; iterateForward ? i < bEnd : i > bEnd; i += bStep) {
+                    if (resultRows.length >= limit) break outer;
+                    let buf = buffers[i];
+                    if (!matchesPattern(buf)) continue;
+
+                    let datum: LogDatum;
+                    try {
+                        datum = LogStreamer.deserialize<LogDatum>(buf);
+                    } catch {
+                        continue;
+                    }
+
+                    if (typeof datum.time !== "number") continue;
+                    if (datum.time < startTime || datum.time > endTime) continue;
+
+                    let row: Record<string, string> = {};
+                    for (let col of config.columns) {
+                        if (col in datum) {
+                            row[col] = stringifyCell(datum[col]);
+                        }
+                    }
+                    for (let key of Object.keys(datum)) {
+                        allColumnsSet.add(key);
+                    }
+                    resultRows.push(row);
+                }
+            }
+
+            if (resultRows.length >= limit) {
+                if (config.direction === "fromStart") {
+                    cutoff = cutoff === undefined ? p.endTime : Math.min(cutoff, p.endTime);
+                } else {
+                    cutoff = cutoff === undefined ? p.startTime : Math.max(cutoff, p.startTime);
+                }
+            }
+        }
+
+        let limitHit = resultRows.length >= limit;
+        console.log(`[search] done in ${formatTime(Date.now() - searchStart)} (filesScanned=${filesScanned}/${allFiles.length} results=${resultRows.length} limit=${limit}${limitHit ? " HIT" : ""})`);
+
+        return {
+            allColumns: Array.from(allColumnsSet),
+            results: resultRows,
+            files: fileCounts,
+            limitHit: limitHit ? true : undefined,
+            note: limitHit
+                ? `Stopped at limit=${limit}. Results are truncated — there are likely more matches outside what's returned. This is NOT missing data; raise the limit or narrow the time range to see more.`
+                : undefined,
+        };
+    }
+
+    // For each logger, asks each remote node on the target machine whether it
+    // has pending logs overlapping [0, endTime]. The first node that answers
+    // without throwing wins; if it says yes, we ask the same node to flush.
+    // We iterate because not every node necessarily exposes the new endpoints
+    // (e.g. older versions still running). Records moved-through up to
+    // now - MOVE_GRACE so we skip this on subsequent calls covering the same
+    // window.
+    private async ensureMovedThrough(machineId: string, endTime: number): Promise<"cached" | "no-node" | "moved"> {
+        let lastMoved = this.movedThroughByMachine.get(machineId) ?? 0;
+        if (lastMoved >= endTime) return "cached";
+
+        let nodeIds = await this.findRemoteNodesOnMachine(machineId);
+        if (nodeIds.length === 0) {
+            console.warn(`MCPIndexedLogs: no remote nodes available for machine ${machineId}; falling back to whatever's in storage now`);
+            return "no-node";
+        }
+
+        for (let loggerName of LOGGER_NAMES) {
+            let answered = false;
+            for (let nodeId of nodeIds) {
+                try {
+                    let hasPending = await timeoutToUndefinedSilent(
+                        5000,
+                        IndexedLogShimController.nodes[nodeId].hasPendingInRange({
+                            indexedLogsName: loggerName,
+                            startTime: 0,
+                            endTime,
+                        }),
+                    );
+                    answered = true;
+                    if (!hasPending) break;
+                    console.log(`MCPIndexedLogs: hasPendingInRange returned true for ${loggerName} on ${nodeId}, forcing move to public`);
+                    await IndexedLogShimController.nodes[nodeId].forceMoveLogsToPublic({
+                        indexedLogsName: loggerName,
+                    });
+                    break;
+                } catch (e) {
+                    console.warn(`MCPIndexedLogs: hasPendingRange failed, trying next node: ${(e as Error).stack ?? e}`, { loggerName, nodeId });
+                }
+            }
+            if (!answered) {
+                console.warn(`MCPIndexedLogs: no node on machine ${machineId} could service hasPendingInRange/forceMoveLogsToPublic for ${loggerName}`);
+            }
+        }
+
+        this.movedThroughByMachine.set(machineId, Date.now() - MOVE_GRACE);
+        return "moved";
+    }
+
+    // Returns every non-self nodeId on the given machineId, ordered with
+    // movelogs-entrypoint nodes first (best-effort — a node whose entrypoint
+    // probe fails is sorted to the back, not dropped). Caller iterates this
+    // list and tries each until one services the request.
+    private async findRemoteNodesOnMachine(machineId: string): Promise<string[]> {
+        let allIds = await getAllNodeIds();
+        let candidates = allIds.filter(id => !isOwnNodeId(id) && getMachineId(id) === machineId);
+        if (candidates.length === 0) return [];
+
+        let preferred: string[] = [];
+        let rest: string[] = [];
+        await Promise.all(candidates.map(async (nodeId) => {
+            let entry = await timeoutToUndefinedSilent(
+                2500,
+                NodeCapabilitiesController.nodes[nodeId].getEntryPoint(),
+            );
+            if (entry?.includes("movelogs")) preferred.push(nodeId);
+            else rest.push(nodeId);
+        }));
+        return [...preferred, ...rest];
+    }
+
+    // Shared by searchIndexes and searchData to map a logger name to the
+    // IndexedLogs<LogDatum> instance that owns its archive.
+    private getLoggerByName(
+        loggers: Awaited<ReturnType<typeof getLoggers2Async>>,
+        name: LoggerName,
+    ): IndexedLogs<LogDatum> {
+        if (name === "logs/log") return loggers.logLogs;
+        if (name === "logs/info") return loggers.infoLogs;
+        if (name === "logs/warn") return loggers.warnLogs;
+        if (name === "logs/error") return loggers.errorLogs;
+        throw new Error(`Unknown logger ${name}`);
+    }
+
+    // Caches TimeFileTree.findAllPaths by hour-aligned bucket so repeated
+    // searches over similar windows reuse the slow folder walk.
+    private async getCachedPaths(config: {
+        archives: Archives;
+        type: "local" | "public";
+        loggerName: LoggerName;
+        startTime: number;
+        endTime: number;
+    }): Promise<TimeFilePath[]> {
+        let bucketStart = Math.floor(config.startTime / timeInHour) * timeInHour;
+        let bucketEnd = Math.ceil(config.endTime / timeInHour) * timeInHour;
+        let key = `${config.type}|${config.loggerName}|${bucketStart}|${bucketEnd}`;
+        let now = Date.now();
+
+        // Prune stale entries on read.
+        for (let [k, v] of Array.from(this.pathsCache.entries())) {
+            if (now - v.time > PATHS_CACHE_TTL) this.pathsCache.delete(k);
+        }
+
+        let cached = this.pathsCache.get(key);
+        if (cached && now - cached.time <= PATHS_CACHE_TTL) {
+            return cached.paths;
+        }
+
+        let paths = await new TimeFileTree(config.archives).findAllPaths({
+            startTime: bucketStart,
+            endTime: bucketEnd,
+        });
+        this.pathsCache.set(key, { time: now, paths });
+        return paths;
+    }
+
+}
+
+function stringifyCell(value: unknown): string {
+    if (value === undefined) return "";
+    if (value === null) return "null";
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}

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

@@ -0,0 +1,190 @@
+module.hotreload = false;
+
+// Allow callers to point this process at a different querysub project root
+// (so we use the right keys/certs/local data) before any other imports run.
+{
+    let argv = process.argv;
+    let cwdIdx = argv.indexOf("--cwd");
+    if (cwdIdx >= 0 && argv[cwdIdx + 1]) {
+        process.chdir(argv[cwdIdx + 1]);
+        argv.splice(cwdIdx, 2);
+    }
+}
+
+import "../../../inject";
+
+import * as http from "http";
+import { logErrors } from "../../../errors";
+import { Querysub } from "../../../4-querysub/QuerysubController";
+import { MCPIndexedLogs } from "./MCPIndexedLogs";
+import { formatTime } from "socket-function/src/formatting/format";
+
+const DEFAULT_MCP_HTTP_PORT = 4487;
+
+const PROTOCOL_VERSION = "2025-03-26";
+const SERVER_INFO = { name: "querysub-indexed-logs", version: "0.1.0" };
+
+const TOOL_DEFS = [
+    {
+        name: "search",
+        description: `Search the indexed logs (across log/info/warn/error) on one machine for rows matching a query, projected to the requested columns.
+
+Returns { allColumns, results, files: { <loggerName>: {total, scanned} } }. If a \`limitHit\` field is present, results were truncated by the limit and a \`note\` will explain. The fields are absent when results are complete. Truncation is NOT missing data — to see more, raise the limit or narrow the time range.
+
+\`allColumns\` is the union of every key seen on any returned row, so callers can pick additional columns for follow-up calls.
+
+Query syntax (case-insensitive substring match by default):
+  | — OR. \`cat|dog\` matches if either substring is present.
+  & — AND. \`error&timeout\` matches if both are present (in any order, anywhere).
+  * — ordered wildcard. \`cat*ate\` matches "cat ate my bird" but NOT "cate"; segments must appear in order with no overlap. (\`cat&ate\` would match "cate".)
+  Whitespace around operators is trimmed. No negation is supported — the index is block-level, so a NOT would yield false positives. Express things as positive signals instead.
+
+Note: each segment between operators ideally has at least 4 contiguous characters (the indexer uses 4-byte units). Shorter segments still match correctly, but won't narrow the index, so all blocks have to be opened.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                machine: { type: "string", description: "machineId, or \"local\" for the machine running this MCP server" },
+                startTime: { type: ["number", "string"], description: "epoch ms or any string Date can parse (no-tz strings are local time)" },
+                endTime: { type: ["number", "string"], description: "epoch ms or any string Date can parse; must be at least 1 minute in the past" },
+                direction: { type: "string", enum: ["fromStart", "fromEnd"] },
+                columns: { type: "array", items: { type: "string" }, description: "Which fields to project onto each row. Use [] to get just metadata; use allColumns from a prior result to pick more." },
+                limit: { type: "number", default: 100 },
+            },
+            required: ["query", "machine", "startTime", "endTime", "direction", "columns"],
+        },
+    },
+];
+
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id?: number | string | null;
+    method: string;
+    params?: unknown;
+};
+
+type JsonRpcResponse = {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: { code: number; message: string; data?: unknown };
+};
+
+let nextRequestSeq = 1;
+
+async function handleJsonRpc(body: string, mcp: MCPIndexedLogs): Promise<JsonRpcResponse | undefined> {
+    let req: JsonRpcRequest;
+    try {
+        req = JSON.parse(body);
+    } catch (e) {
+        return errorResponse(null, -32700, `Parse error: ${(e as Error).message}`);
+    }
+    if (req.jsonrpc !== "2.0" || typeof req.method !== "string") {
+        return errorResponse(req.id ?? null, -32600, `Invalid request`);
+    }
+    // Notifications have no id and expect no response.
+    let isNotification = req.id === undefined;
+
+    let seq = nextRequestSeq++;
+    let label = req.method === "tools/call"
+        ? `${req.method}/${(req.params as { name?: string } | undefined)?.name ?? "?"}`
+        : req.method;
+    let startTime = Date.now();
+    console.log(`[mcp #${seq}] start ${label}${isNotification ? " (notification)" : ""}`);
+
+    try {
+        let result = await dispatch(req.method, req.params, mcp);
+        console.log(`[mcp #${seq}] end ${label} ok in ${formatTime(Date.now() - startTime)}`);
+        if (isNotification) return undefined;
+        return { jsonrpc: "2.0", id: req.id ?? null, result };
+    } catch (e) {
+        console.error(`[mcp #${seq}] end ${label} error in ${formatTime(Date.now() - startTime)}:`, (e as Error).stack ?? e);
+        if (isNotification) return undefined;
+        return errorResponse(req.id ?? null, -32000, (e as Error).message ?? String(e));
+    }
+}
+
+async function dispatch(method: string, params: unknown, mcp: MCPIndexedLogs): Promise<unknown> {
+    if (method === "initialize") {
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: SERVER_INFO,
+        };
+    }
+    if (method === "tools/list") {
+        return { tools: TOOL_DEFS };
+    }
+    if (method === "tools/call") {
+        let p = (params ?? {}) as { name?: string; arguments?: Record<string, unknown> };
+        let toolName = p.name;
+        let args = p.arguments ?? {};
+        let result: unknown;
+        if (toolName === "search") {
+            result = await mcp.search(args as Parameters<MCPIndexedLogs["search"]>[0]);
+        } else {
+            throw new Error(`Unknown tool ${toolName}`);
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+    }
+    if (method === "ping") {
+        return {};
+    }
+    // Lifecycle notifications (notifications/initialized, notifications/cancelled, ...).
+    if (method.startsWith("notifications/")) {
+        return {};
+    }
+    throw new Error(`Unknown method ${method}`);
+}
+
+function errorResponse(id: number | string | null, code: number, message: string): JsonRpcResponse {
+    return { jsonrpc: "2.0", id, error: { code, message } };
+}
+
+async function main() {
+    let mcp = new MCPIndexedLogs();
+
+    let portIdx = process.argv.indexOf("--mcp-port");
+    let port = portIdx >= 0 && process.argv[portIdx + 1]
+        ? Number(process.argv[portIdx + 1])
+        : DEFAULT_MCP_HTTP_PORT;
+
+    let server = http.createServer((req, res) => {
+        if (req.method !== "POST") {
+            res.statusCode = 405;
+            res.end();
+            return;
+        }
+        let chunks: Buffer[] = [];
+        req.on("data", c => chunks.push(c));
+        req.on("end", async () => {
+            let body = Buffer.concat(chunks).toString("utf8");
+            let response = await handleJsonRpc(body, mcp);
+            if (response === undefined) {
+                // Notification — no body expected.
+                res.statusCode = 204;
+                res.end();
+                return;
+            }
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify(response));
+        });
+        req.on("error", e => {
+            console.error(`MCP request error:`, (e as Error).stack ?? e);
+            res.statusCode = 500;
+            res.end();
+        });
+    });
+
+    await new Promise<void>((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, () => resolve());
+    });
+    console.log(`MCPIndexedLogs HTTP server listening on http://127.0.0.1:${port}`);
+
+    await Querysub.hostService("MCPIndexedLogs");
+}
+
+main().catch(console.error);

package/src/diagnostics/logs/diskLogger.ts

@@ -19,6 +19,9 @@ if (isNode()) {
         const { logGitHashes } = await import("./logGitHashes");
         await logGitHashes();
     }));
+    setImmediate(() => {
+        void getLoggers2Async();
+    });
 }
 
 let loggingToDiskDisabled = false;

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

@@ -543,7 +543,8 @@ class ErrorNotificationData {
         }
         SocketFunction.onNextDisconnect(controllerNodeId, () => {
             ErrorNotificationData.ensureWatchingErrorsHTTP.reset();
-        });
+            // No need for handling, I think? I believe a refresh of the page will just reconnect automatically.
+        }, "iKnowThatServerNodeIdsMayReconnect_andIHandleReconnections");
         await ErrorNotificationServiceBase.nodes[controllerNodeId].watchUnmatchedErrorsSERVICE();
     });
 

package/src/diagnostics/managementPages.tsx

@@ -29,6 +29,7 @@ import { delay } from "socket-function/src/batching";
 import { currentViewParam, selectedServiceIdParam } from "../deployManager/urlParams";
 import { FunctionCallInfo } from "./FunctionCallInfo";
 import { PathDistributionInfo } from "./PathDistributionInfo";
+import { ValuePathWarning } from "./ValuePathWarning";
 import { isCurrentUserSuperUser } from "../user-implementation/userData";
 
 export const managementPageURL = new URLParam("managementpage", "");
@@ -366,7 +367,10 @@ class ManagementRoot extends qreact.Component {
                             <ATag values={[{ param: managementPageURL, value: page.componentName }]}>{page.title}</ATag>
                         )}
                         {isCurrentUserSuperUser() && <FunctionCallInfo />}
-                        {isCurrentUserSuperUser() && <PathDistributionInfo />}
+                        {isCurrentUserSuperUser() && <div className={css.vbox(4)}>
+                            <PathDistributionInfo />
+                            <ValuePathWarning />
+                        </div>}
                     </div>
                     {currentPage &&
                         <div

package/src/library-components/SyncedController.ts

@@ -203,7 +203,8 @@ export function getSyncedController<T extends {
                     }
                     delete syncedData()[id][nodeId];
                 });
-            });
+                // Reconnection is just the user making another call
+            }, "iKnowThatServerNodeIdsMayReconnect_andIHandleReconnections");
         }
         return new Proxy({}, {
             get: (target, fncNameUntyped) => {