socket-function 0.38.0 → 0.40.0

package/SocketFunction.ts

@@ -16,6 +16,7 @@ import "./SetProcessVariables";
 import cborx from "cbor-x";
 import { setFlag } from "./require/compileFlags";
 import { isNode } from "./src/misc";
+import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount } from "./src/CallFactory";
 
 /** Always shim Date.now(), because we usually DO want an accurate time... */
 setImmediate(async () => {
@@ -84,8 +85,43 @@ export class SocketFunction {
         return caller;
     }
 
+    public static harvestFailedCallCount = () => harvestFailedCallCount();
+    public static getPendingCallCount = () => getPendingCallCount();
+    public static harvestCallTimes = () => harvestCallTimes();
+
     // NOTE: We use callbacks we don't run into issues with cyclic dependencies
     //  (ex, using a hook in a controller where the hook also calls the controller).
+    /*
+        export const DiskLoggerController = SocketFunction.register(
+            // Can be anything, but should be unique amongst other controllers on your server.
+            "DiskLoggerController-f76a6fdf-3bd5-4bd4-a183-55a8be0a5a32",
+            // Contains the functions that can be exposed, which must all be async.
+            //  Only those listed below will be exposed.
+            new DiskLoggerControllerBase(),
+            () => ({
+                // Only functions listed here will be exposed
+                getRemoteLogFiles: {},
+                getRemoteLogBuffer: {
+                    compress: true,
+                    // SocketFunctionClientHook[]
+                    clientHooks: [
+                        (x) => {
+                            // If overrideResult is set, it skips the call and returns overrideResult
+                            x.overrideResult = Buffer.from(...);
+                        }
+                    ]
+                },
+            }),
+            () => ({
+                // Default hooks for all functions
+                // SocketFunctionHook[]
+                hooks: [assertIsManagementUser],
+            }),
+            {
+                // Additionaly flags
+            }
+        );
+    */
     public static register<
         ClassInstance extends object,
         Shape extends SocketExposedShape<{
@@ -213,10 +249,22 @@ export class SocketFunction {
             let hookResult = await runClientHooks(call, shapeObj as Exclude<SocketExposedShape[""], undefined>, callFactory.connectionId);
 
             if ("overrideResult" in hookResult) {
-                return hookResult.overrideResult;
+                for (let callback of hookResult.onResult) {
+                    await callback(hookResult.overrideResult);
+                }
+                if ("overrideResult" in hookResult) {
+                    return hookResult.overrideResult;
+                }
             }
 
-            return await callFactory.performCall(call);
+            let result = await callFactory.performCall(call);
+            for (let callback of hookResult.onResult) {
+                await callback(result);
+            }
+            if ("overrideResult" in hookResult) {
+                return hookResult.overrideResult;
+            }
+            return result;
         } finally {
             time = Date.now() - time;
             if (SocketFunction.logMessages) {
@@ -374,10 +422,10 @@ export class SocketFunction {
         return SocketFunction.connect({ address: location.hostname, port: +location.port || 443 });
     }
 
-    public static addGlobalHook(hook: SocketFunctionHook<SocketExposedInterface>) {
+    public static addGlobalHook(hook: SocketFunctionHook) {
         registerGlobalHook(hook as SocketFunctionHook);
     }
-    public static addGlobalClientHook(hook: SocketFunctionClientHook<SocketExposedInterface>) {
+    public static addGlobalClientHook(hook: SocketFunctionClientHook) {
         registerGlobalClientHook(hook as SocketFunctionClientHook);
     }
 }

package/SocketFunctionTypes.ts

@@ -35,8 +35,13 @@ export type FunctionFlags = {
 };
 export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
     [functionName in keyof ExposedType]?: FunctionFlags & {
-        hooks?: SocketFunctionHook<ExposedType>[];
-        clientHooks?: SocketFunctionClientHook<ExposedType>[];
+        // NOTE: Due tohow register is called we can't use ExposedType[functionName] here,
+        //  because we didn'tt use the double call pattern. Maybe we will later,
+        //  but the type benefits are marginal. Args and overrideResult can be typed,
+        //  but 99% of the time those are used by generic helper functions anyways,
+        //  which only want unknowns anyways.
+        hooks?: SocketFunctionHook[];
+        clientHooks?: SocketFunctionClientHook[];
         noDefaultHooks?: boolean;
         /** BUG: I think this is broken if it is on the default hooks function? */
         noClientHooks?: boolean;
@@ -53,25 +58,36 @@ export interface FullCallType<FncT extends FncType = FncType, FncName extends st
     nodeId: string;
 }
 
-export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
-    (config: HookContext<ExposedType>): MaybePromise<void>;
+export interface SocketFunctionHook {
+    (config: HookContext): MaybePromise<void>;
     /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
-    clientHook?: SocketFunctionClientHook<ExposedType>;
+    clientHook?: SocketFunctionClientHook;
 }
-export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+export type HookContext = {
     call: FullCallType;
     // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
+    //  - It is important we continue evaluating hooks, in case some later hooks check permissions
+    //      and throw. We wouldn't want a caching layer to accidentally avoid a permissions check.
     overrideResult?: unknown;
+    // Is called on a result, even if it is from overrideResult
+    //  Maybe further mutate overrideResult, or even add it
+    onResult: ((result: unknown) => MaybePromise<void>)[];
 };
 
-export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
+export type ClientHookContext = {
     call: FullCallType;
-    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
+    // If the result is overriden, we STOP evaluating hooks and do not perform the final call
+    //  - We stop evaluating hooks, because other hooks might end up making unnecessary calls,
+    //      which won't be needed, because we aren't calling the server. There is no security issue,
+    //      because the clientside checks are never security checks (how could they be, the client
+    //      can't authorize itself...)
     overrideResult?: unknown;
+    // Is called on a result, even if it is from overrideResult
+    onResult: ((result: unknown) => MaybePromise<void>)[];
     connectionId: { nodeId: string };
 };
-export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
-    (config: ClientHookContext<ExposedType>): MaybePromise<void>;
+export interface SocketFunctionClientHook {
+    (config: ClientHookContext): MaybePromise<void>;
 }
 
 export interface SocketRegisterType<ExposedType = any> {

package/package.json

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

package/src/CallFactory.ts

@@ -1,7 +1,7 @@
 import { CallerContext, CallerContextBase, CallType, FullCallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import { getCallFlags, performLocalCall, shouldCompressCall } from "./callManager";
-import { convertErrorStackToError, formatNumberSuffixed, isBufferType, isNode, list } from "./misc";
+import { convertErrorStackToError, formatNumberSuffixed, isBufferType, isNode, list, timeInHour, timeInMinute } from "./misc";
 import { createWebsocketFactory, getTLSSocket } from "./websocketFactory";
 import { SocketFunction } from "../SocketFunction";
 import * as tls from "tls";
@@ -10,7 +10,7 @@ import debugbreak from "debugbreak";
 import { lazy } from "./caching";
 import { red, yellow } from "./formatting/logColors";
 import { isSplitableArray, markArrayAsSplitable } from "./fixLargeNetworkCalls";
-import { delay, runInSerial } from "./batching";
+import { delay, runInfinitePoll, runInSerial } from "./batching";
 import { formatNumber, formatTime } from "./formatting/format";
 import zlib from "zlib";
 import pako from "pako";
@@ -68,6 +68,30 @@ export interface SenderInterface {
     ping?(): void;
 }
 
+let pendingCallCount = 0;
+let harvestableFailedCalls = 0;
+const CALL_TIMES_LIMIT = 1000 * 1000 * 10;
+let harvestableCallTimes: number[] = [];
+export function harvestFailedCallCount() {
+    let count = harvestableFailedCalls;
+    harvestableFailedCalls = 0;
+    return count;
+}
+export function getPendingCallCount() {
+    return pendingCallCount;
+}
+export function harvestCallTimes() {
+    let times = harvestableCallTimes;
+    harvestableCallTimes = [];
+    return times;
+}
+runInfinitePoll(timeInMinute * 15, () => {
+    if (harvestableCallTimes.length > CALL_TIMES_LIMIT) {
+        harvestableCallTimes = harvestableCallTimes.slice(-CALL_TIMES_LIMIT);
+    }
+});
+
+
 export async function createCallFactory(
     webSocketBase: SenderInterface | undefined,
     // The node id we are connecting to (or that connected to us)
@@ -179,8 +203,13 @@ export async function createCallFactory(
             }
 
             let resultPromise = new Promise((resolve, reject) => {
+                let startTime = Date.now();
+                pendingCallCount++;
                 let callback = (result: InternalReturnType) => {
+                    pendingCallCount--;
                     pendingCalls.delete(seqNum);
+                    harvestableCallTimes.push(Date.now() - startTime);
+
                     if (result.error) {
                         reject(convertErrorStackToError(result.error));
                     } else {
@@ -225,11 +254,13 @@ export async function createCallFactory(
         function onClose(error: string) {
             callFactory.connectionId = { nodeId };
             callFactory.lastClosed = Date.now();
+            callFactory.isConnected = false;
             webSocketPromise = undefined;
             if (!canReconnect) {
                 callFactory.closedForever = true;
             }
             for (let [key, call] of pendingCalls) {
+                harvestableFailedCalls++;
                 pendingCalls.delete(key);
                 call.callback({
                     isReturn: true,

package/src/callManager.ts

@@ -51,14 +51,25 @@ export async function performLocalCall(
 
     let serverContext = await runServerHooks(call, caller, functionShape);
     if ("overrideResult" in serverContext) {
-        return serverContext.overrideResult;
+        for (let callback of serverContext.onResult) {
+            await callback(serverContext.overrideResult);
+        }
+        if ("overrideResult" in serverContext) {
+            return serverContext.overrideResult;
+        }
     }
 
     // NOTE: We purposely don't await inside _setSocketContext, so the context is reset synchronously
     let result = _setSocketContext(caller, () => {
         return controller[call.functionName](...call.args);
     });
+    for (let callback of serverContext.onResult) {
+        await callback(result);
+    }
 
+    if ("overrideResult" in serverContext) {
+        return serverContext.overrideResult;
+    }
     return await result;
 }
 
@@ -120,7 +131,7 @@ export const runClientHooks = measureWrap(async function runClientHooks(
     hooks: Exclude<SocketExposedShape[""], undefined>,
     connectionId: { nodeId: string },
 ): Promise<ClientHookContext> {
-    let context: ClientHookContext = { call: callType, connectionId };
+    let context: ClientHookContext = { call: callType, connectionId, onResult: [] };
 
     let clientHooks = hooks.clientHooks?.slice() || [];
     if (!hooks.noClientHooks) {
@@ -133,6 +144,7 @@ export const runClientHooks = measureWrap(async function runClientHooks(
     }
     for (let hook of clientHooks) {
         await hook(context);
+        // NOTE: See ClientHookContext.overrideResult for why we break here
         if ("overrideResult" in context) {
             break;
         }
@@ -146,12 +158,10 @@ export const runServerHooks = measureWrap(async function runServerHooks(
     caller: CallerContext,
     hooks: Exclude<SocketExposedShape[""], undefined>,
 ): Promise<HookContext> {
-    let hookContext: HookContext = { call: callType };
+    let hookContext: HookContext = { call: callType, onResult: [] };
     for (let hook of globalHooks.concat(hooks.hooks || [])) {
         await _setSocketContext(caller, () => hook(hookContext));
-        if ("overrideResult" in hookContext) {
-            break;
-        }
+        // NOTE: See HookContext.overrideResult for why we don't break here
     }
     return hookContext;
 });

package/src/profiling/measure.ts

@@ -30,7 +30,8 @@ const measureOverhead = 5 / 1000;
 
 const AsyncFunction = (async () => { }).constructor;
 
-const noDiskLogPrefix = "\u200C";
+// NOTE: Also hardcoded in diskLogger.ts (in querysub)
+const noDiskLogPrefix = "█ ";
 
 // TIMING: 1-5us. I have seen timing values greatly vary, but it does seem to be quite high, despite
 //  microbenchmarks saying it is slow. Perhaps it is because getOwnTime breaks the cpu pipeline,
@@ -78,6 +79,9 @@ export function measureBlock<T extends (...args: any[]) => any>(fnc: T, name?: s
 }
 
 let extraInfoGetters: (() => string | undefined)[] = [];
+/** NOTE: You should often call registerNodeMetadata for this as well. registerMeasureInfo
+ *      is for logs, while registerNodeMetadata is for the overview page.
+ */
 export function registerMeasureInfo(getInfo: () => string | undefined) {
     extraInfoGetters.push(getInfo);
 }