socket-function 1.0.5 → 1.1.0

package/index.d.ts

@@ -262,7 +262,7 @@ declare module "socket-function/mobx/UrlParam" {
 declare module "socket-function/mobx/observer" {
     import type preact from "preact";
     import { Reaction } from "mobx";
-    export declare function observer<T extends {
+    /** @deprecated Use the version from sliftutils instead. */ export declare function observer<T extends {
         new (...args: any[]): {
             render(): preact.ComponentChild;
             forceUpdate(callback?: () => void): void;
@@ -528,6 +528,23 @@ declare module "socket-function/src/JSONLACKS/JSONLACKS.generated.js" {
     export function parse(text: string): unknown;
 }
 
+declare module "socket-function/src/Zip" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { MaybePromise } from "socket-function/src/types";
+    export declare class Zip {
+        static gzip(buffer: Buffer, level?: number): Promise<Buffer>;
+        static gzipSync(buffer: Buffer, level?: number): Buffer;
+        static gunzip(buffer: Buffer): MaybePromise<Buffer>;
+        static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
+        static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
+        static gunzipSync(buffer: Buffer): Buffer;
+        private static gunzipUntrackedSync;
+        static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
+    }
+
+}
+
 declare module "socket-function/src/args" {
     export declare const getArgs: {
         (): {
@@ -1042,6 +1059,7 @@ declare module "socket-function/src/profiling/measure" {
         entries: {
             [name: string]: ProfileEntry;
         };
+        creator: string;
     }
     export declare function createMeasureProfile(): MeasureProfile;
     export declare function addToMeasureProfile(base: MeasureProfile, other: MeasureProfile): void;

package/mobx/observer.d.ts

@@ -1,6 +1,6 @@
 import type preact from "preact";
 import { Reaction } from "mobx";
-export declare function observer<T extends {
+/** @deprecated Use the version from sliftutils instead. */ export declare function observer<T extends {
     new (...args: any[]): {
         render(): preact.ComponentChild;
         forceUpdate(callback?: () => void): void;

package/mobx/observer.tsx

@@ -2,13 +2,14 @@ import type preact from "preact";
 import { setFlag } from "../require/compileFlags";
 
 import { observable, Reaction } from "mobx";
+import { measureBlock } from "socket-function/src/profiling/measure";
 
 setFlag(require, "mobx", "allowclient", true);
 setFlag(require, "preact", "allowclient", true);
 
 let globalConstructOrder = 0;
 
-export function observer<
+/** @deprecated Use the version from sliftutils instead. */export function observer<
     T extends {
         new(...args: any[]): {
             render(): preact.ComponentChild;
@@ -42,7 +43,9 @@ export function observer<
         render() {
             let output: preact.ComponentChild;
             this.reaction.track(() => {
-                output = super.render();
+                measureBlock(() => {
+                    output = super.render();
+                }, `${name}|render`);
             });
             return output;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.0.5",
+	"version": "1.1.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/require.ts

@@ -659,7 +659,7 @@ export function requireMain() {
         // NOTE: All on one line, so we don't break sourcemaps by TOO much. We could also parse
         //  the sourcemap and adjust it, but... it is much easier to just not change the line counts.
         return eval(
-            `(function ${debugName}(exports, require, module, __filename, __dirname, importDynamic) {${contents}\n })`
+            `(function ${debugName}(exports, require, module, __filename, __dirname, importDynamic) {"use strict";${contents}\n })`
         );
     }
 

package/src/CallFactory.ts

@@ -15,8 +15,9 @@ 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 { measureFnc, measureWrap, registerMeasureInfo } from "./profiling/measure";
 import { MaybePromise } from "./types";
+import { Zip } from "./Zip";
 setFlag(require, "pako", "allowclient", true);
 
 // NOTE: If it is too low, and too many servers disconnect, we can easily spend 100% of our time
@@ -158,9 +159,13 @@ export async function createCallFactory(
             let data: Buffer[];
             let originalArgs = call.args;
             let time = Date.now();
+            let sendStats: CompressionStats = {
+                uncompressedSize: 0,
+                compressedSize: 0,
+            };
             try {
                 if (shouldCompressCall(fullCall)) {
-                    fullCall.args = await compressObj(fullCall.args) as any;
+                    fullCall.args = await compressObj(fullCall.args, sendStats) as any;
                     fullCall.isArgsCompressed = true;
                 }
                 let dataMaybePromise = SocketFunction.WIRE_SERIALIZER.serialize(fullCall);
@@ -169,6 +174,15 @@ export async function createCallFactory(
                 } else {
                     data = dataMaybePromise;
                 }
+                if (!sendStats.compressedSize) {
+                    let totalSize = 0;
+                    for (let d of data) {
+                        totalSize += d.length;
+                    }
+                    sendStats.uncompressedSize = totalSize;
+                    sendStats.compressedSize = totalSize;
+                }
+                addSendStats(sendStats);
             } catch (e: any) {
                 throw new Error(`Error serializing data for call ${call.classGuid}.${call.functionName}\n${e.stack}`);
             }
@@ -475,6 +489,15 @@ export async function createCallFactory(
             callback(resultSize);
         }
 
+        let receiveStats: CompressionStats = {
+            uncompressedSize: resultSize,
+            compressedSize: resultSize,
+        };
+        let sendStats: CompressionStats = {
+            uncompressedSize: 0,
+            compressedSize: 0,
+        };
+
         if (call.isReturn) {
             let callbackObj = pendingCalls.get(call.seqNum);
             if (parseTime > SocketFunction.WIRE_WARN_TIME) {
@@ -489,13 +512,13 @@ export async function createCallFactory(
                 console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
             }
             if (call.isResultCompressed) {
-                call.result = await decompressObj(call.result as Buffer);
+                call.result = await decompressObj(call.result as Buffer, receiveStats);
                 call.isResultCompressed = false;
             }
             callbackObj.callback(call);
         } else {
             if (call.isArgsCompressed) {
-                call.args = await decompressObj(call.args as any as Buffer) as any;
+                call.args = await decompressObj(call.args as any as Buffer, sendStats) as any;
                 call.isArgsCompressed = false;
             }
             if (call.functionName === "changeIdentity") {
@@ -592,7 +615,7 @@ export async function createCallFactory(
                     console.log(`DUR\t${(formatTime(timeTaken)).padEnd(6, " ")}\tFINISH\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
                 }
                 if (shouldCompressCall(call)) {
-                    response.result = await compressObj(response.result) as any;
+                    response.result = await compressObj(response.result, sendStats) as any;
                     response.isResultCompressed = true;
                 }
             } catch (e: any) {
@@ -611,11 +634,17 @@ export async function createCallFactory(
                 }
             }
 
+            let size = 0;
+
             if (response.result instanceof Buffer) {
                 let { result, ...remaining } = response;
+                size = result.length;
                 await sendWithHeader([result], { type: "Buffer", bufferCount: 1, metadata: remaining });
             } else if (Array.isArray(response.result) && response.result.every(x => x instanceof Buffer)) {
                 let { result, ...remaining } = response;
+                for (let r of result) {
+                    size += r.length;
+                }
                 await sendWithHeader(result, { type: "Buffer[]", bufferCount: result.length, metadata: remaining });
             } else {
                 const LIMIT = getCallFlags(call)?.responseLimit || SocketFunction.MAX_MESSAGE_SIZE * 1.5;
@@ -630,9 +659,21 @@ export async function createCallFactory(
                     };
                     result = await SocketFunction.WIRE_SERIALIZER.serialize(response);
                 }
+                for (let r of result) {
+                    size += r.length;
+                }
                 await send(result);
             }
+
+            // If we have no size, then it's probably uncompressed
+            if (!sendStats.compressedSize) {
+                sendStats.compressedSize = size;
+                sendStats.uncompressedSize = size;
+            }
         }
+
+        addSendStats(sendStats);
+        addReceiveStats(receiveStats);
     }
 
     let clientsideSerial = runInSerial(async <T>(val: Promise<T>) => val);
@@ -717,63 +758,49 @@ 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);
-    }
+
+
+let uncompressedSent = 0;
+let compressedSent = 0;
+let uncompressedReceived = 0;
+let compressedReceived = 0;
+
+let sendCount = 0;
+let receiveCount = 0;
+
+function addSendStats(stats: CompressionStats) {
+    uncompressedSent += stats.uncompressedSize;
+    compressedSent += stats.compressedSize;
+    sendCount++;
 }
-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);
-    }
+function addReceiveStats(stats: CompressionStats) {
+    uncompressedReceived += stats.uncompressedSize;
+    compressedReceived += stats.compressedSize;
+    receiveCount++;
 }
+// Register this late as I don't want it to appear before the memory register info, which is use more useful than the network one. 
+setImmediate(() => {
+    registerMeasureInfo(() => `NET => ${formatNumber(compressedSent)}B (${formatNumber(uncompressedSent)}B/${formatNumber(sendCount)}) / <= ${formatNumber(compressedReceived)}B (${formatNumber(uncompressedReceived)}B/${formatNumber(receiveCount)})`);
+});
 
-const compressObj = measureWrap(async function wireCallCompress(obj: unknown): Promise<Buffer> {
+type CompressionStats = {
+    uncompressedSize: number;
+    compressedSize: number;
+};
+
+const compressObj = measureWrap(async function wireCallCompress(obj: unknown, stats: CompressionStats): 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]);
-    let result = await zipBase(buffer);
+    stats.uncompressedSize += buffer.length;
+    let result = await Zip.gzip(buffer);
+    stats.compressedSize += result.length;
     return result;
 });
-const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer): Promise<unknown> {
-    let buffer = await unzipBase(obj);
+// Assumes the caller already added the obj.length to both the uncompressedSize and compressedSize, and is just looking to update the uncompressedSize to be larger according to the size after we uncompress
+const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer, stats: CompressionStats): Promise<unknown> {
+    let buffer = await Zip.gunzip(obj);
+    stats.uncompressedSize += buffer.length - obj.length;
     let lengthBuffer = buffer.slice(0, 8);
     let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
     let buffers: Buffer[] = [];
@@ -782,5 +809,6 @@ const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer)
         buffers.push(buffer.slice(offset, offset + length));
         offset += length;
     }
-    return await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
+    let result = await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
+    return result;
 });

package/src/Zip.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { MaybePromise } from "./types";
+export declare class Zip {
+    static gzip(buffer: Buffer, level?: number): Promise<Buffer>;
+    static gzipSync(buffer: Buffer, level?: number): Buffer;
+    static gunzip(buffer: Buffer): MaybePromise<Buffer>;
+    static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
+    static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
+    static gunzipSync(buffer: Buffer): Buffer;
+    private static gunzipUntrackedSync;
+    static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
+}

package/src/Zip.ts

@@ -0,0 +1,113 @@
+import { isNode } from "./misc";
+import { measureFnc } from "./profiling/measure";
+import zlib from "zlib";
+import * as pako from "pako";
+
+import { setFlag } from "../require/compileFlags";
+import { MaybePromise } from "./types";
+setFlag(require, "pako", "allowclient", true);
+
+const SYNC_THRESHOLD_BYTES = 100_000_000;
+
+export class Zip {
+    @measureFnc
+    public static async gzip(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);
+        }
+    }
+    @measureFnc
+    public static gzipSync(buffer: Buffer, level?: number): Buffer {
+        if (isNode()) {
+            return Buffer.from(zlib.gzipSync(buffer, { level }));
+        }
+        return Buffer.from(pako.deflate(buffer));
+    }
+    public static gunzip(buffer: Buffer): MaybePromise<Buffer> {
+        // Switch to the synchronous version if the buffer is small. This is a lot faster in Node.js and clientside.
+        //  - On tests of random small amounts of data, this seems to be up to 7X faster (on node). However, on non-random data, on the actual data we're using, it seems to be almost 50 times faster. So... definitely worth it...
+        if (buffer.length < SYNC_THRESHOLD_BYTES) {
+            let time = Date.now();
+            let result = Zip.gunzipSync(buffer);
+            let duration = Date.now() - time;
+            if (duration > 50) {
+                // Wait, so we don't lock up the main thread. And if we already wait it 50ms, then waiting for one frame is marginal, even client-side. 
+                return ((async () => {
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                    return result;
+                }))();
+            }
+            return result;
+        }
+        return Zip.gunzipAsyncBase(buffer);
+    }
+    @measureFnc
+    public static async gunzipAsyncBase(buffer: Buffer): Promise<Buffer> {
+        return Zip.gunzipUntracked(buffer);
+    }
+    // A base function, so we can avoid instrumentation for batch calls
+    public static async gunzipUntracked(buffer: Buffer): Promise<Buffer> {
+        if (isNode()) {
+            return await new Promise<Buffer>((resolve, reject) => {
+                zlib.gunzip(buffer, (err: any, result: Buffer) => {
+                    if (err) reject(err);
+                    else resolve(result);
+                });
+            });
+        }
+        return await doStream(new DecompressionStream("gzip"), buffer);
+    }
+
+    @measureFnc
+    public static gunzipSync(buffer: Buffer): Buffer {
+        return this.gunzipUntrackedSync(buffer);
+    }
+    private static gunzipUntrackedSync(buffer: Buffer): Buffer {
+        if (isNode()) {
+            return Buffer.from(zlib.gunzipSync(buffer));
+        }
+        return Buffer.from(pako.inflate(buffer));
+    }
+
+    @measureFnc
+    public static async gunzipBatch(buffers: Buffer[]): Promise<Buffer[]> {
+        let time = Date.now();
+        buffers = await Promise.all(buffers.map(x => {
+            if (x.length < SYNC_THRESHOLD_BYTES) {
+                return this.gunzipUntrackedSync(x);
+            }
+            return this.gunzipUntracked(x);
+        }));
+        time = Date.now() - time;
+        let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);
+        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);
+        return buffers;
+    }
+}
+
+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));
+    }
+
+}

package/src/profiling/measure.d.ts

@@ -47,6 +47,7 @@ export interface MeasureProfile {
     entries: {
         [name: string]: ProfileEntry;
     };
+    creator: string;
 }
 export declare function createMeasureProfile(): MeasureProfile;
 export declare function addToMeasureProfile(base: MeasureProfile, other: MeasureProfile): void;

package/src/profiling/measure.ts

@@ -100,6 +100,7 @@ export function startMeasure(): {
         startTime: now,
         endTime: now,
         entries: Object.create(null),
+        creator: new Error().stack || "",
     };
     let openAtStart = new Set(getOpenTimesBase());
 
@@ -316,6 +317,7 @@ export interface MeasureProfile {
     entries: {
         [name: string]: ProfileEntry;
     };
+    creator: string;
 }
 export function createMeasureProfile(): MeasureProfile {
     let now = Date.now();
@@ -323,6 +325,7 @@ export function createMeasureProfile(): MeasureProfile {
         startTime: now,
         endTime: now,
         entries: Object.create(null),
+        creator: new Error().stack || "",
     };
 }