socket-function 0.12.16 → 0.13.0

package/SocketFunction.ts

@@ -91,6 +91,13 @@ export class SocketFunction {
             /** @noAutoExpose If true SocketFunction.expose(Controller) must be called explicitly. */
             noAutoExpose?: boolean;
             statics?: Statics;
+            /** Skip timing functions calls. Useful if a lot of functions have wait time that
+                    is unrelated to processing, and therefore their timings won't be useful.
+                    - Also useful if our auto function wrapping code is breaking functionality,
+                        such as if you have a singleton function which you compare with ===,
+                        which will breaks because we replaced it with a wrapped measure function.
+            */
+            noFunctionMeasure?: boolean;
         }
     ): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics {
         let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);
@@ -101,14 +108,20 @@ export class SocketFunction {
             for (let value of Object.values(shape)) {
                 if (!value) continue;
                 value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
-                value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
+                if (value.noDefaultHooks) {
+                    value.hooks = [...(value.hooks || [])];
+                } else {
+                    value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
+                }
                 value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;
             }
             return shape as any as SocketExposedShape;
         });
 
         void Promise.resolve().then(() => {
-            registerClass(classGuid, instance as SocketExposedInterface, getShape());
+            registerClass(classGuid, instance as SocketExposedInterface, getShape(), {
+                noFunctionMeasure: config?.noFunctionMeasure,
+            });
         });
 
         let nodeProxy = getCallProxy(classGuid, async (call) => {

package/SocketFunctionTypes.ts

@@ -22,15 +22,22 @@ export type SocketExposedInterfaceClass = {
     new(): unknown;
     prototype: unknown;
 };
+export type FunctionFlags = {
+    compress?: boolean;
+
+    /** Indicates with the same input, we give the same output, forever,
+     *      independent of code changes. This only works for data storage.
+     */
+    dataImmutable?: boolean;
+
+    /** Allows overriding SocketFunction.MAX_MESSAGE_SIZE for responses from this function. */
+    responseLimit?: number;
+};
 export type SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
-    [functionName in keyof ExposedType]?: {
-        compress?: boolean;
-        /** Indicates with the same input, we give the same output, forever,
-         *      independent of code changes. This only works for data storage.
-         */
-        dataImmutable?: boolean;
+    [functionName in keyof ExposedType]?: FunctionFlags & {
         hooks?: SocketFunctionHook<ExposedType>[];
         clientHooks?: SocketFunctionClientHook<ExposedType>[];
+        noDefaultHooks?: boolean;
     };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.12.16",
+	"version": "0.13.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -14,7 +14,7 @@
 		"pako": "^2.1.0",
 		"preact": "^10.10.6",
 		"typenode": "^5.4.1",
-		"ws": "^8.8.0"
+		"ws": "^8.17.1"
 	},
 	"optionalDependencies": {
 		"rdtsc-now": "^0.4.2"

package/src/CallFactory.ts

@@ -1,7 +1,7 @@
 import { CallerContext, CallerContextBase, CallType, FullCallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
-import { performLocalCall, shouldCompressCall } from "./callManager";
-import { convertErrorStackToError, formatNumberSuffixed, isNode, list } from "./misc";
+import { getCallFlags, performLocalCall, shouldCompressCall } from "./callManager";
+import { convertErrorStackToError, formatNumberSuffixed, isBufferType, isNode, list } from "./misc";
 import { createWebsocketFactory, getTLSSocket } from "./websocketFactory";
 import { SocketFunction } from "../SocketFunction";
 import * as tls from "tls";
@@ -12,8 +12,11 @@ import { red, yellow } from "./formatting/logColors";
 import { isSplitableArray, markArrayAsSplitable } from "./fixLargeNetworkCalls";
 import { delay, runInSerial } from "./batching";
 import { formatNumber, formatTime } from "./formatting/format";
+import zlib from "zlib";
 import pako from "pako";
 import { setFlag } from "../require/compileFlags";
+import { measureFnc, measureWrap } from "./profiling/measure";
+import { MaybePromise } from "./types";
 setFlag(require, "pako", "allowclient", true);
 
 // NOTE: If it is too low, and too many servers disconnect, we can easily spend 100% of our time
@@ -51,7 +54,7 @@ export interface CallFactory {
 export interface SenderInterface {
     nodeId?: string;
     // Only set AFTER "open" (if set at all, as in the browser we don't have access to the socket).
-    socket?: tls.TLSSocket;
+    _socket?: tls.TLSSocket;
 
     send(data: string | Buffer): void;
 
@@ -201,8 +204,11 @@ export async function createCallFactory(
                     console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tREMOTE CALL\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);
                 }
             }
-            await send(data);
-
+            // If sending OR resultPromise throws, we want to error out. This solves some issues with resultPromise
+            //      erroring out first, which is before we await it, which makes NodeJS angry (unhandled promise rejection).
+            //      Also, technically, we could receive the result before we finish sending, in which case, we might
+            //      as well return it immediately.
+            await Promise.race([send(data), resultPromise]);
             return await resultPromise;
         }
     };
@@ -246,12 +252,12 @@ export async function createCallFactory(
             // NOTE: No more logging, as we throw, so the caller should be logging the
             //  error (or swallowing it, if that is what it wants to do).
             //console.log(`Websocket error for ${niceConnectionName}`, e.message);
-            onClose(`Connection error for ${niceConnectionName}: ${e.message}`);
+            onClose(new Error(`Connection error for ${niceConnectionName}: ${e.message}`).stack!);
         });
 
         newWebSocket.addEventListener("close", async () => {
             //console.log(`Websocket closed ${niceConnectionName}`);
-            onClose(`Connection closed to ${niceConnectionName}`);
+            onClose(new Error(`Connection closed to ${niceConnectionName}`).stack!);
         });
 
         newWebSocket.addEventListener("message", onMessage);
@@ -269,9 +275,10 @@ export async function createCallFactory(
                 newWebSocket.addEventListener("close", () => resolve());
                 newWebSocket.addEventListener("error", () => resolve());
             });
-        } else if (newWebSocket.readyState !== 1 /* OPEN */) {
-            onClose(`Websocket received in closed state`);
+        } else if (newWebSocket.readyState === 1 /* OPEN */) {
             callFactory.isConnected = true;
+        } else {
+            onClose(new Error(`Websocket received in closed state`).stack!);
         }
     }
 
@@ -285,6 +292,7 @@ export async function createCallFactory(
         bufferLengths?: number[];
         metadata: Omit<InternalReturnType, "result">;
     };
+    let sendInSerial = runInSerial(async (val: () => Promise<void>) => val());
     async function sendRaw(data: (string | Buffer)[]) {
         if (!webSocketPromise) {
             if (canReconnect) {
@@ -294,9 +302,30 @@ export async function createCallFactory(
             }
         }
         let webSocket = await webSocketPromise;
-        for (let d of data) {
-            webSocket.send(d);
-        }
+        await sendInSerial(async () => {
+            for (let d of data) {
+                if (d.length > 1000 * 1000 * 10) {
+                    console.log(`Sending large packet ${formatNumber(d.length)}B to ${nodeId} at ${Date.now()}`);
+                }
+
+                // NOTE: If our latency is 500ms, with 10MB/s, then we need a high water
+                //  mark of at least 5MB, otherwise our connection is slowed down.
+                //  - Using the actual high water mark is too difficult, as we receive incoming connections.
+                //      This is also easier to configure, and we can dynamically change it if we have to.
+                // NOTE: In practice we only hit this when sending large Buffers (~30MB), so low values
+                //  are equivalent to waiting for drain. We want to avoid waiting for drain, so we use a high value.
+                const maxWriteBuffer = 128 * 1024 * 1024;
+                webSocket.send(d);
+
+                let socket = webSocket._socket;
+                if (socket) {
+                    while (socket.writableLength > maxWriteBuffer) {
+                        // NOTE: Waiting 1ms probably waits more like 16ms.
+                        await new Promise(r => setTimeout(r, 1));
+                    }
+                }
+            }
+        });
     }
     async function send(data: Buffer[]) {
         await sendRaw([
@@ -321,6 +350,7 @@ export async function createCallFactory(
                     }
                 }
                 data = fitBuffers;
+                header.bufferCount = fitBuffers.length;
             } else {
                 throw new Error(`Cannot send large amounts of data unless we are returning Buffer or Buffer[]`);
             }
@@ -366,7 +396,7 @@ export async function createCallFactory(
                     let lenLeft = len;
                     let buffers: Buffer[] = [];
                     while (lenLeft > 0) {
-                        let buf = currentBuffers.pop();
+                        let buf = currentBuffers.shift();
                         if (!buf) {
                             throw new Error(`Not enough buffers received.`);
                         }
@@ -413,7 +443,7 @@ export async function createCallFactory(
         if (call.isReturn) {
             let callbackObj = pendingCalls.get(call.seqNum);
             if (time > SocketFunction.WIRE_WARN_TIME) {
-                console.log(red(`Slow parse, took ${time}ms to parse ${resultSize} bytes, for receieving result of call to ${callbackObj?.call.classGuid}.${callbackObj?.call.functionName}`));
+                console.log(red(`Slow parse, took ${time}ms to parse ${resultSize} bytes, for receiving result of call to ${callbackObj?.call.classGuid}.${callbackObj?.call.functionName}`));
             }
             if (!callbackObj) {
                 console.log(`Got return for unknown call ${call.seqNum} (created at time ${new Date(call.seqNum)})`);
@@ -468,14 +498,15 @@ export async function createCallFactory(
                 let { result, ...remaining } = response;
                 await sendWithHeader(result, { type: "Buffer[]", bufferCount: result.length, metadata: remaining });
             } else {
+                const LIMIT = getCallFlags(call)?.responseLimit || SocketFunction.MAX_MESSAGE_SIZE * 1.5;
                 let result: Buffer[] = await SocketFunction.WIRE_SERIALIZER.serialize(response);
                 let totalResultSize = result.map(x => x.length).reduce((a, b) => a + b, 0);
-                if (totalResultSize > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {
+                if (totalResultSize > LIMIT) {
                     response = {
                         isReturn: true,
                         result: undefined,
                         seqNum: call.seqNum,
-                        error: new Error(`Response too large to send (${call.classGuid}.${call.functionName}, size: ${formatNumber(totalResultSize)} > ${formatNumber(SocketFunction.MAX_MESSAGE_SIZE)}). If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or consider fragmenting data at an application level, because sending large data will cause large lag spikes for other clients using this server. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`).stack,
+                        error: new Error(`Response too large to send. Return Buffer[] to exceed the limits, or set responseLimit when registering the collection. ${call.classGuid}.${call.functionName}, size: ${formatNumber(totalResultSize)} > ${formatNumber(SocketFunction.MAX_MESSAGE_SIZE)}. If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`).stack,
                     };
                     result = await SocketFunction.WIRE_SERIALIZER.serialize(response);
                 }
@@ -490,14 +521,18 @@ export async function createCallFactory(
             if (typeof message === "object" && "data" in message) {
                 message = message.data;
             }
+            // Extra clienside parsing is required
             if (!isNode()) {
-                if (message instanceof Blob) {
-                    // We need to force the results to be in serial, otherwise strings leapfrog
-                    //  ahead of buffers, which breaks things.
-                    message = Buffer.from(await clientsideSerial(message.arrayBuffer()));
-                } else {
-                    await clientsideSerial(Promise.resolve());
-                }
+                // Immediately start the arrayBuffer conversion. This should be fast, but...
+                //  maybe we will add more here, and so doing it in parallel might be useful.
+                let fixMessageBlob = (async () => {
+                    if (message instanceof Blob) {
+                        message = Buffer.from(await message.arrayBuffer());
+                    }
+                })();
+                // We need to force the results to be in serial, otherwise strings leapfrog
+                //  ahead of buffers, which breaks things.
+                await clientsideSerial(fixMessageBlob);
             }
             if (typeof message === "string") {
                 if (message.startsWith("{")) {
@@ -530,6 +565,9 @@ export async function createCallFactory(
                 return;
             }
             if (message instanceof Buffer) {
+                if (message.byteLength > 1000 * 1000 * 10) {
+                    console.log(`Received large packet ${formatNumber(message.byteLength)}B at ${Date.now()}`);
+                }
                 if (!pendingCall) {
                     throw new Error(`Received data without size`);
                 }
@@ -543,11 +581,13 @@ export async function createCallFactory(
             }
             throw new Error(`Unhandled data type ${typeof message}`);
         } catch (e: any) {
-            let message = e.stack || e.message || e;
+            let err = e.stack || e.message || e;
             // NOTE: I'm looking for all types of errors here (specifically, .send errors), in case
             //  there are errors I should be handling.
-            if (message.startsWith("Error: Cannot send data to") && message.includes("as the connection has closed")) {
+            if (err.startsWith("Error: Cannot send data to") && err.includes("as the connection has closed")) {
                 // This is fine, just ignore it
+            } else if (err.includes("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.")) {
+                console.error(`WebSocket data was dropped by the browser due to exceeding the Blob limit. Either you are about to run out of memory, or you hit the much lower Incognito Blob limit. This will likely break the application. To reset the memory you must close all tabs of this site. This is a bug/feature in chrome.`);
             } else {
                 debugbreak(2);
                 debugger;
@@ -559,16 +599,64 @@ export async function createCallFactory(
     return callFactory;
 }
 
+async function doStream(stream: GenericTransformStream, buffer: Buffer): Promise<Buffer> {
+    let reader = stream.readable.getReader();
+    let writer = stream.writable.getWriter();
+    let writePromise = writer.write(buffer);
+    let closePromise = writer.close();
+
+    let outputBuffers: Buffer[] = [];
+    while (true) {
+        let { value, done } = await reader.read();
+        if (done) {
+            await writePromise;
+            await closePromise;
+            return Buffer.concat(outputBuffers);
+        }
+        outputBuffers.push(Buffer.from(value));
+    }
+}
+async function unzipBase(buffer: Buffer): Promise<Buffer> {
+    if (isNode()) {
+        return new Promise((resolve, reject) => {
+            zlib.gunzip(buffer, (err: any, result: Buffer) => {
+                if (err) reject(err);
+                else resolve(result);
+            });
+        });
+    } else {
+        // NOTE: pako seems to be faster, at least clientside.
+        // TIMING: 700ms vs 1200ms
+        //  - This might just be faster for small files.
+        return Buffer.from(pako.inflate(buffer));
+        // @ts-ignore
+        // return await doStream(new DecompressionStream("gzip"), buffer);
+    }
+}
+async function zipBase(buffer: Buffer, level?: number): Promise<Buffer> {
+    if (isNode()) {
+        return new Promise((resolve, reject) => {
+            zlib.gzip(buffer, { level }, (err: any, result: Buffer) => {
+                if (err) reject(err);
+                else resolve(result);
+            });
+        });
+    } else {
+        // @ts-ignore
+        return await doStream(new CompressionStream("gzip"), buffer);
+    }
+}
 
-async function compressObj(obj: unknown): Promise<Buffer> {
+const compressObj = measureWrap(async function wireCallCompress(obj: unknown): Promise<Buffer> {
     let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
     let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
     let buffer = Buffer.concat([lengthBuffer, ...buffers]);
-    return Buffer.from(pako.gzip(buffer));
-}
-async function decompressObj(obj: Buffer): Promise<unknown> {
+    let result = await zipBase(buffer);
+    return result;
+});
+const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer): Promise<unknown> {
     try {
-        let buffer = Buffer.from(pako.ungzip(obj));
+        let buffer = await unzipBase(obj);
         let lengthBuffer = buffer.slice(0, 8);
         let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
         let buffers: Buffer[] = [];
@@ -586,4 +674,4 @@ async function decompressObj(obj: Buffer): Promise<unknown> {
         debugger;
         throw e;
     }
-}
+});