querysub 0.437.0 → 0.439.0

package/src/diagnostics/trackResources.ts

@@ -1,92 +1,92 @@
-import { runInfinitePoll } from "socket-function/src/batching";
-import { lazy } from "socket-function/src/caching";
-import { formatNumber } from "socket-function/src/formatting/format";
-import { blue } from "socket-function/src/formatting/logColors";
-import { isNode } from "socket-function/src/misc";
-import { registerPeriodic } from "./periodic";
-import { registerMeasureInfo } from "socket-function/src/profiling/measure";
-import { logNodeStateStats } from "../-0-hooks/hooks";
-
-let resources: {
-    name: string;
-    getCount: () => number;
-}[] = [];
-
-export function registerResource<T extends Set<unknown> | Map<unknown, unknown> | unknown[]>(name: string, data: T): T {
-    let getCount: () => number;
-    if (Array.isArray(data)) {
-        getCount = () => data.length;
-    } else {
-        getCount = () => data.size;
-    }
-    resources.push({ name, getCount });
-    return data;
-}
-export function registerMapArrayResource<T extends Map<unknown, unknown[]>>(name: string, data: T): T {
-    let getCount = () => {
-        let sum = 0;
-        for (let value of data.values()) {
-            sum += value.length;
-        }
-        return sum;
-    };
-    resources.push({ name, getCount });
-    return data;
-}
-export function registerDynamicResource(name: string, getCount: () => number) {
-    resources.push({ name, getCount });
-}
-
-function getHeapSize() {
-    if (isNode()) {
-        let usage = process.memoryUsage();
-        // Not really the heap size, but it is more what we are looking for
-        return usage.rss;
-    } else {
-        return (window.performance as any).memory.totalJSHeapSize;
-    }
-}
-function getUsedHeapSize() {
-    if (isNode()) {
-        let usage = process.memoryUsage();
-        return usage.heapUsed + usage.arrayBuffers;
-    } else {
-        if (!window.performance) return 0;
-        return (window.performance as any).memory.usedJSHeapSize;
-    }
-}
-function getBufferUsage() {
-    if (isNode()) {
-        let usage = process.memoryUsage();
-        return usage.arrayBuffers;
-    } else {
-        return 0;
-    }
-}
-
-registerDynamicResource("Heap", getUsedHeapSize);
-registerDynamicResource("Buffers", getBufferUsage);
-registerDynamicResource("Used Memory", getHeapSize);
-
-function logResourcesNow() {
-    let resourcesWithCounts = resources.map(resource => ({ ...resource, count: resource.getCount() }));
-    resourcesWithCounts.sort((a, b) => b.count - a.count);
-    if (!isNode()) {
-        console.log(`Memory usage ${blue(formatNumber(getUsedHeapSize()) + "B")}/${blue(formatNumber(getHeapSize()) + "B")} at ${new Date().toISOString()}`);
-        for (let resource of resourcesWithCounts) {
-            if (resource.count === 0) continue;
-            console.log(`  ${resource.name}: ${formatNumber(resource.count)}`);
-        }
-    } else {
-        for (let resource of resourcesWithCounts) {
-            if (resource.count === 0) continue;
-            logNodeStateStats(resource.name, formatNumber, resource.count);
-        }
-    }
-}
-
-registerMeasureInfo(() => {
-    return `MEM ${formatNumber(getUsedHeapSize())}B+${formatNumber(getBufferUsage())}B/${formatNumber(getHeapSize())}B `;
-});
-
+import { runInfinitePoll } from "socket-function/src/batching";
+import { lazy } from "socket-function/src/caching";
+import { formatNumber } from "socket-function/src/formatting/format";
+import { blue } from "socket-function/src/formatting/logColors";
+import { isNode } from "socket-function/src/misc";
+import { registerPeriodic } from "./periodic";
+import { registerMeasureInfo } from "socket-function/src/profiling/measure";
+import { logNodeStateStats } from "../-0-hooks/hooks";
+
+let resources: {
+    name: string;
+    getCount: () => number;
+}[] = [];
+
+export function registerResource<T extends Set<unknown> | Map<unknown, unknown> | unknown[]>(name: string, data: T): T {
+    let getCount: () => number;
+    if (Array.isArray(data)) {
+        getCount = () => data.length;
+    } else {
+        getCount = () => data.size;
+    }
+    resources.push({ name, getCount });
+    return data;
+}
+export function registerMapArrayResource<T extends Map<unknown, unknown[]>>(name: string, data: T): T {
+    let getCount = () => {
+        let sum = 0;
+        for (let value of data.values()) {
+            sum += value.length;
+        }
+        return sum;
+    };
+    resources.push({ name, getCount });
+    return data;
+}
+export function registerDynamicResource(name: string, getCount: () => number) {
+    resources.push({ name, getCount });
+}
+
+function getHeapSize() {
+    if (isNode()) {
+        let usage = process.memoryUsage();
+        // Not really the heap size, but it is more what we are looking for
+        return usage.rss;
+    } else {
+        return (window.performance as any).memory.totalJSHeapSize;
+    }
+}
+function getUsedHeapSize() {
+    if (isNode()) {
+        let usage = process.memoryUsage();
+        return usage.heapUsed + usage.arrayBuffers;
+    } else {
+        if (!window.performance) return 0;
+        return (window.performance as any).memory.usedJSHeapSize;
+    }
+}
+function getBufferUsage() {
+    if (isNode()) {
+        let usage = process.memoryUsage();
+        return usage.arrayBuffers;
+    } else {
+        return 0;
+    }
+}
+
+registerDynamicResource("Heap", getUsedHeapSize);
+registerDynamicResource("Buffers", getBufferUsage);
+registerDynamicResource("Used Memory", getHeapSize);
+
+function logResourcesNow() {
+    let resourcesWithCounts = resources.map(resource => ({ ...resource, count: resource.getCount() }));
+    resourcesWithCounts.sort((a, b) => b.count - a.count);
+    if (!isNode()) {
+        console.log(`Memory usage ${blue(formatNumber(getUsedHeapSize()) + "B")}/${blue(formatNumber(getHeapSize()) + "B")} at ${new Date().toISOString()}`);
+        for (let resource of resourcesWithCounts) {
+            if (resource.count === 0) continue;
+            console.log(`  ${resource.name}: ${formatNumber(resource.count)}`);
+        }
+    } else {
+        for (let resource of resourcesWithCounts) {
+            if (resource.count === 0) continue;
+            logNodeStateStats(resource.name, formatNumber, resource.count);
+        }
+    }
+}
+
+registerMeasureInfo(() => {
+    return `MEM ${formatNumber(getUsedHeapSize())}B+${formatNumber(getBufferUsage())}B/${formatNumber(getHeapSize())}B `;
+});
+
 registerPeriodic(logResourcesNow);

package/src/diagnostics/watchdog.ts

@@ -1,121 +1,121 @@
-import { runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
-import { FormattedMeasureTable, MeasureProfile, logMeasureTable, startMeasure } from "socket-function/src/profiling/measure";
-import { logErrors } from "../errors";
-import { isNode, sort } from "socket-function/src/misc";
-import debugbreak from "debugbreak";
-import { registerPeriodic } from "./periodic";
-import { getOwnMachineId } from "../-a-auth/certs";
-import { SocketFunction } from "socket-function/SocketFunction";
-import { formatPercent, formatTime } from "socket-function/src/formatting/format";
-import { pathWatcher } from "../0-path-value-core/PathWatcher";
-import { addStatPeriodic, addStatSumPeriodic, addTimeProfileDistribution, registerNodeMetadata } from "../-0-hooks/hooks";
-import { logDisk } from "./logs/diskLogger";
-import { getDebuggerUrl } from "./listenOnDebugger";
-import { isPublic } from "../config";
-
-let lastProfile: MeasureProfile | undefined;
-
-addStatPeriodic({
-    title: "Performance|% Profiled",
-    getValue: () => {
-        if (!lastProfile) return 0;
-        let entries = Object.values(lastProfile.entries);
-        if (entries.length === 0) return 0;
-        const timeProfiled = lastProfile.endTime - lastProfile.startTime;
-
-        let timeActive = entries.map(x => x.ownTime.sum).reduce((a, b) => a + b, 0);
-        return timeActive / timeProfiled;
-    },
-    format: formatPercent,
-});
-registerNodeMetadata({
-    columnName: "Performance|Top Profiled",
-    getValue() {
-        if (!lastProfile) return "";
-        let entries = Object.values(lastProfile.entries);
-        if (entries.length === 0) return "";
-        const timeProfiled = lastProfile.endTime - lastProfile.startTime;
-
-        let rootSums = new Map<string, number>();
-        for (let entry of entries) {
-            let name = entry.name.split("|")[0];
-            let sum = rootSums.get(name) ?? 0;
-            rootSums.set(name, sum + entry.ownTime.sum);
-        }
-        let most = sort(Array.from(rootSums.entries()), x => -x[1])[0];
-        return `${endEllipsis(most[0], 26)} = ${formatPercent(most[1] / timeProfiled)}`;
-    },
-});
-addTimeProfileDistribution("Performance|Network Calls", () => SocketFunction.harvestCallTimes());
-addStatPeriodic({
-    title: "Performance|Pending Net Calls",
-    getValue: () => SocketFunction.getPendingCallCount(),
-});
-addStatSumPeriodic({
-    title: "Performance|Failed Net Calls",
-    getValue: () => SocketFunction.harvestFailedCallCount(),
-});
-addTimeProfileDistribution("Performance|Syncing", () => pathWatcher.debug_harvestSyncTimes());
-
-
-function endEllipsis(str: string, maxLength: number) {
-    if (str.length <= maxLength) return str;
-    return "..." + str.slice(-(maxLength - 3));
-}
-
-let minTimeToLog = 250;
-export function watchdogSetMinTimeToLog(_minTimeToLog: number) {
-    minTimeToLog = _minTimeToLog;
-}
-
-let measureObj = startMeasure();
-function logProfileMeasuresTimingsNow() {
-    let profile = measureObj.finish();
-    measureObj = startMeasure();
-    function diskLogMeasureObj(table: FormattedMeasureTable | undefined) {
-        if (!table) return;
-        console.info(table.title, { entries: table.entries });
-    }
-    diskLogMeasureObj(logMeasureTable(profile, {
-        name: `watchdog at ${new Date().toLocaleString()}`,
-        // NOTE: Much higher min log times, now that we are combining logs.
-        minTimeToLog: minTimeToLog,
-        thresholdInTable: 0,
-        setTitle: true
-    }));
-    diskLogMeasureObj(logMeasureTable(profile, {
-        name: `watchdog at ${new Date().toLocaleString()}`,
-        mergeDepth: 1,
-        minTimeToLog: minTimeToLog,
-    }));
-
-    if (isNode() && !isPublic()) {
-        let debuggerValue = getDebuggerUrl();
-        process.stdout.write(`\n${debuggerValue}\n`);
-    }
-
-    lastProfile = profile;
-    // if (isNode()) {
-    //     if (SocketFunction.mountedNodeId) {
-    //         console.log("Mounted as " + SocketFunction.mountedNodeId);
-    //     } else {
-    //         console.log("Not mounted");
-    //     }
-    // }
-}
-(globalThis as any).logProfileMeasuresNow = logProfileMeasuresTimingsNow;
-
-(globalThis as any).logUnfiltered = function logUnfiltered(depth = 2) {
-    let profile = measureObj.finish();
-    measureObj = startMeasure();
-    logMeasureTable(profile, {
-        name: `all logs at ${new Date().toLocaleString()}`,
-        mergeDepth: depth,
-        minTimeToLog: 0,
-        maxTableEntries: 10000000,
-        thresholdInTable: 0
-    });
-};
-
-
+import { runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { FormattedMeasureTable, MeasureProfile, logMeasureTable, startMeasure } from "socket-function/src/profiling/measure";
+import { logErrors } from "../errors";
+import { isNode, sort } from "socket-function/src/misc";
+import debugbreak from "debugbreak";
+import { registerPeriodic } from "./periodic";
+import { getOwnMachineId } from "../-a-auth/certs";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { formatPercent, formatTime } from "socket-function/src/formatting/format";
+import { pathWatcher } from "../0-path-value-core/PathWatcher";
+import { addStatPeriodic, addStatSumPeriodic, addTimeProfileDistribution, registerNodeMetadata } from "../-0-hooks/hooks";
+import { logDisk } from "./logs/diskLogger";
+import { getDebuggerUrl } from "./listenOnDebugger";
+import { isPublic } from "../config";
+
+let lastProfile: MeasureProfile | undefined;
+
+addStatPeriodic({
+    title: "Performance|% Profiled",
+    getValue: () => {
+        if (!lastProfile) return 0;
+        let entries = Object.values(lastProfile.entries);
+        if (entries.length === 0) return 0;
+        const timeProfiled = lastProfile.endTime - lastProfile.startTime;
+
+        let timeActive = entries.map(x => x.ownTime.sum).reduce((a, b) => a + b, 0);
+        return timeActive / timeProfiled;
+    },
+    format: formatPercent,
+});
+registerNodeMetadata({
+    columnName: "Performance|Top Profiled",
+    getValue() {
+        if (!lastProfile) return "";
+        let entries = Object.values(lastProfile.entries);
+        if (entries.length === 0) return "";
+        const timeProfiled = lastProfile.endTime - lastProfile.startTime;
+
+        let rootSums = new Map<string, number>();
+        for (let entry of entries) {
+            let name = entry.name.split("|")[0];
+            let sum = rootSums.get(name) ?? 0;
+            rootSums.set(name, sum + entry.ownTime.sum);
+        }
+        let most = sort(Array.from(rootSums.entries()), x => -x[1])[0];
+        return `${endEllipsis(most[0], 26)} = ${formatPercent(most[1] / timeProfiled)}`;
+    },
+});
+addTimeProfileDistribution("Performance|Network Calls", () => SocketFunction.harvestCallTimes());
+addStatPeriodic({
+    title: "Performance|Pending Net Calls",
+    getValue: () => SocketFunction.getPendingCallCount(),
+});
+addStatSumPeriodic({
+    title: "Performance|Failed Net Calls",
+    getValue: () => SocketFunction.harvestFailedCallCount(),
+});
+addTimeProfileDistribution("Performance|Syncing", () => pathWatcher.debug_harvestSyncTimes());
+
+
+function endEllipsis(str: string, maxLength: number) {
+    if (str.length <= maxLength) return str;
+    return "..." + str.slice(-(maxLength - 3));
+}
+
+let minTimeToLog = 250;
+export function watchdogSetMinTimeToLog(_minTimeToLog: number) {
+    minTimeToLog = _minTimeToLog;
+}
+
+let measureObj = startMeasure();
+function logProfileMeasuresTimingsNow() {
+    let profile = measureObj.finish();
+    measureObj = startMeasure();
+    function diskLogMeasureObj(table: FormattedMeasureTable | undefined) {
+        if (!table) return;
+        console.info(table.title, { entries: table.entries });
+    }
+    diskLogMeasureObj(logMeasureTable(profile, {
+        name: `watchdog at ${new Date().toLocaleString()}`,
+        // NOTE: Much higher min log times, now that we are combining logs.
+        minTimeToLog: minTimeToLog,
+        thresholdInTable: 0,
+        setTitle: true
+    }));
+    diskLogMeasureObj(logMeasureTable(profile, {
+        name: `watchdog at ${new Date().toLocaleString()}`,
+        mergeDepth: 1,
+        minTimeToLog: minTimeToLog,
+    }));
+
+    if (isNode() && !isPublic()) {
+        let debuggerValue = getDebuggerUrl();
+        process.stdout.write(`\n${debuggerValue}\n`);
+    }
+
+    lastProfile = profile;
+    // if (isNode()) {
+    //     if (SocketFunction.mountedNodeId) {
+    //         console.log("Mounted as " + SocketFunction.mountedNodeId);
+    //     } else {
+    //         console.log("Not mounted");
+    //     }
+    // }
+}
+(globalThis as any).logProfileMeasuresNow = logProfileMeasuresTimingsNow;
+
+(globalThis as any).logUnfiltered = function logUnfiltered(depth = 2) {
+    let profile = measureObj.finish();
+    measureObj = startMeasure();
+    logMeasureTable(profile, {
+        name: `all logs at ${new Date().toLocaleString()}`,
+        mergeDepth: depth,
+        minTimeToLog: 0,
+        maxTableEntries: 10000000,
+        thresholdInTable: 0
+    });
+};
+
+
 registerPeriodic(logProfileMeasuresTimingsNow);