querysub 0.433.0 → 0.436.0

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);

package/src/errors.ts

@@ -1,134 +1,134 @@
-import debugbreak from "debugbreak";
-import { delay } from "socket-function/src/batching";
-import { blue, red } from "socket-function/src/formatting/logColors";
-import { canHaveChildren } from "socket-function/src/types";
-
-let callstackTracking = false;
-/** WARNING: This can be VERY slow. The only way to record the callstack of some errors is to record it
- *      on promise initialization, which results in gathering callstacks even for successful promises.
- */
-export function enableCallbackTracking() {
-    callstackTracking = true;
-}
-
-function logError(e: Error, callstack: unknown) {
-    console.error(`${blue("Error from promise")}: ${red(e.stack || e.message)}`);
-    if (callstackTracking) {
-        console.log(callstack);
-    }
-}
-export function logErrors(promiseorError: Promise<unknown> | unknown | undefined) {
-    let callstack = callstackTracking && new Error().stack;
-    if (!promiseorError) return;
-    if (!canHaveChildren(promiseorError)) return;
-    if (promiseorError instanceof Promise) {
-        promiseorError.catch(e => {
-            logError(e, callstack);
-        });
-    } else {
-        if (promiseorError instanceof Error) {
-            logError(promiseorError, callstack);
-        }
-    }
-}
-export function ignoreErrors(promise: Promise<unknown>) {
-    if (!promise) return;
-    if (!promise?.catch) return;
-    promise.catch(e => { });
-}
-
-/** Logs the error as well. */
-export function errorToUndefined<T>(p: Promise<T>): Promise<T | undefined> {
-    if (!p?.catch) return p;
-    return p.catch((e) => {
-        console.error(`${blue("Error to undefined error")}: ${red(e.stack)}`);
-        return undefined;
-    });
-}
-export function errorToUndefinedSilent<T>(p: Promise<T>): Promise<T | undefined> {
-    if (!p?.catch) return Promise.resolve(undefined);
-    return p.catch((e) => {
-        return undefined;
-    });
-}
-
-export function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error) {
-    return new Promise<T>((resolve, reject) => {
-        let timeout = setTimeout(() => reject(err()), time);
-        p.then(resolve, reject).finally(() => clearTimeout(timeout));
-    });
-}
-
-// NOTE: Both errors and timeouts are converted to undefined
-export function timeoutToUndefined<T>(time: number, p: Promise<T>) {
-    return new Promise<T | undefined>((resolve, reject) => {
-        let timeout = setTimeout(() => {
-            console.error(blue(`timeoutToUndefined timed out after ${time}`));
-            resolve(undefined);
-        }, time);
-        p.then(resolve,
-            (err) => {
-                console.error(`${blue("timeoutToUndefined error")}: ${red(err.stack)}`);
-                resolve(undefined);
-            }
-        ).finally(() => clearTimeout(timeout));
-    });
-}
-export function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>) {
-    return new Promise<T | undefined>((resolve, reject) => {
-        let timeout = setTimeout(() => {
-            resolve(undefined);
-        }, time);
-        p.then(
-            resolve,
-            (err) => {
-                resolve(undefined);
-            }
-        ).finally(() => clearTimeout(timeout));
-    });
-}
-
-/** Used when accessing paid resources, so we don't rack up charges due to an error,
- *      but also so that it doesn't take forever for the initial call to run.
- */
-export async function backoffRetryLoop<T>(code: () => Promise<T>, waitTime = 5 * 1000) {
-    while (true) {
-        try {
-            return await code();
-        } catch (e: any) {
-            console.error(`Error retrying in ${waitTime}ms\n${e.stack}`);
-            await delay(waitTime);
-            waitTime *= 1.01;
-        }
-    }
-}
-
-export function errorify(error: any, messageOverride?: string) {
-    if (error instanceof Error) {
-        return error;
-    }
-    let errorObj = new Error();
-    if (typeof error === "string" && error.includes("\n")) {
-        errorObj.stack = error;
-        errorObj.message = error.split("\n")[0];
-    } else {
-        errorObj.message = error;
-        errorObj.stack = error + "\n" + errorObj.stack;
-    }
-    if (messageOverride) {
-        errorObj.message = messageOverride;
-    }
-    return errorObj;
-}
-
-export function assertValue<T>(value: T | undefined | null, message?: string): T {
-    if (value === undefined || value === null) {
-        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
-    }
-    return value;
-}
-export function assert<T>(value: T | undefined | null, message?: string): asserts value is T {
-    if (value === undefined || value === null) {
-        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
-    }
+import debugbreak from "debugbreak";
+import { delay } from "socket-function/src/batching";
+import { blue, red } from "socket-function/src/formatting/logColors";
+import { canHaveChildren } from "socket-function/src/types";
+
+let callstackTracking = false;
+/** WARNING: This can be VERY slow. The only way to record the callstack of some errors is to record it
+ *      on promise initialization, which results in gathering callstacks even for successful promises.
+ */
+export function enableCallbackTracking() {
+    callstackTracking = true;
+}
+
+function logError(e: Error, callstack: unknown) {
+    console.error(`${blue("Error from promise")}: ${red(e.stack || e.message)}`);
+    if (callstackTracking) {
+        console.log(callstack);
+    }
+}
+export function logErrors(promiseorError: Promise<unknown> | unknown | undefined) {
+    let callstack = callstackTracking && new Error().stack;
+    if (!promiseorError) return;
+    if (!canHaveChildren(promiseorError)) return;
+    if (promiseorError instanceof Promise) {
+        promiseorError.catch(e => {
+            logError(e, callstack);
+        });
+    } else {
+        if (promiseorError instanceof Error) {
+            logError(promiseorError, callstack);
+        }
+    }
+}
+export function ignoreErrors(promise: Promise<unknown>) {
+    if (!promise) return;
+    if (!promise?.catch) return;
+    promise.catch(e => { });
+}
+
+/** Logs the error as well. */
+export function errorToUndefined<T>(p: Promise<T>): Promise<T | undefined> {
+    if (!p?.catch) return p;
+    return p.catch((e) => {
+        console.error(`${blue("Error to undefined error")}: ${red(e.stack)}`);
+        return undefined;
+    });
+}
+export function errorToUndefinedSilent<T>(p: Promise<T>): Promise<T | undefined> {
+    if (!p?.catch) return Promise.resolve(undefined);
+    return p.catch((e) => {
+        return undefined;
+    });
+}
+
+export function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error) {
+    return new Promise<T>((resolve, reject) => {
+        let timeout = setTimeout(() => reject(err()), time);
+        p.then(resolve, reject).finally(() => clearTimeout(timeout));
+    });
+}
+
+// NOTE: Both errors and timeouts are converted to undefined
+export function timeoutToUndefined<T>(time: number, p: Promise<T>) {
+    return new Promise<T | undefined>((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            console.error(blue(`timeoutToUndefined timed out after ${time}`));
+            resolve(undefined);
+        }, time);
+        p.then(resolve,
+            (err) => {
+                console.error(`${blue("timeoutToUndefined error")}: ${red(err.stack)}`);
+                resolve(undefined);
+            }
+        ).finally(() => clearTimeout(timeout));
+    });
+}
+export function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>) {
+    return new Promise<T | undefined>((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            resolve(undefined);
+        }, time);
+        p.then(
+            resolve,
+            (err) => {
+                resolve(undefined);
+            }
+        ).finally(() => clearTimeout(timeout));
+    });
+}
+
+/** Used when accessing paid resources, so we don't rack up charges due to an error,
+ *      but also so that it doesn't take forever for the initial call to run.
+ */
+export async function backoffRetryLoop<T>(code: () => Promise<T>, waitTime = 5 * 1000) {
+    while (true) {
+        try {
+            return await code();
+        } catch (e: any) {
+            console.error(`Error retrying in ${waitTime}ms\n${e.stack}`);
+            await delay(waitTime);
+            waitTime *= 1.01;
+        }
+    }
+}
+
+export function errorify(error: any, messageOverride?: string) {
+    if (error instanceof Error) {
+        return error;
+    }
+    let errorObj = new Error();
+    if (typeof error === "string" && error.includes("\n")) {
+        errorObj.stack = error;
+        errorObj.message = error.split("\n")[0];
+    } else {
+        errorObj.message = error;
+        errorObj.stack = error + "\n" + errorObj.stack;
+    }
+    if (messageOverride) {
+        errorObj.message = messageOverride;
+    }
+    return errorObj;
+}
+
+export function assertValue<T>(value: T | undefined | null, message?: string): T {
+    if (value === undefined || value === null) {
+        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
+    }
+    return value;
+}
+export function assert<T>(value: T | undefined | null, message?: string): asserts value is T {
+    if (value === undefined || value === null) {
+        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
+    }
 }

package/src/forceProduction.ts

@@ -1,3 +1,3 @@
-if (typeof process === "object") {
-    process.env["NODE_ENV"] = "production";
+if (typeof process === "object") {
+    process.env["NODE_ENV"] = "production";
 }