socket-function 1.2.29 → 1.2.31

package/SocketFunctionTypes.d.ts

@@ -62,6 +62,10 @@ export type ClientHookContext = {
 };
 export interface SocketFunctionClientHook {
     (config: ClientHookContext): MaybePromise<void>;
+    /** Set on hooks which are called so frequently (or are so trivial) that the measurement overhead
+     *      and profiling noise outweighs the value of measuring them.
+     */
+    noMeasure?: boolean;
 }
 export interface SocketRegisterType<ExposedType = any> {
     _classGuid: string;

package/SocketFunctionTypes.ts

@@ -92,6 +92,10 @@ export type ClientHookContext = {
 };
 export interface SocketFunctionClientHook {
     (config: ClientHookContext): MaybePromise<void>;
+    /** Set on hooks which are called so frequently (or are so trivial) that the measurement overhead
+     *      and profiling noise outweighs the value of measuring them.
+     */
+    noMeasure?: boolean;
 }
 
 export interface SocketRegisterType<ExposedType = any> {

package/index.d.ts

@@ -194,6 +194,10 @@ declare module "socket-function/SocketFunctionTypes" {
     };
     export interface SocketFunctionClientHook {
         (config: ClientHookContext): MaybePromise<void>;
+        /** Set on hooks which are called so frequently (or are so trivial) that the measurement overhead
+         *      and profiling noise outweighs the value of measuring them.
+         */
+        noMeasure?: boolean;
     }
     export interface SocketRegisterType<ExposedType = any> {
         _classGuid: string;

package/package.json

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

package/src/CallFactory.ts

@@ -316,7 +316,7 @@ export async function createCallFactory(
         registerOnce();
         callFactory.receivedInitializeState = undefined;
 
-        function onClose(error: string) {
+        function onClose(message: string) {
             // We try various connections, and if they fail, we will just try other node IDs until we finally do connect, and then we stick with that nodeId, and when it disconnects we need to handle disconnections normally.
             if (skipCloseHandling && !hasEverConnected) {
                 return;
@@ -335,7 +335,7 @@ export async function createCallFactory(
                 call.callback({
                     isReturn: true,
                     result: undefined,
-                    error: error,
+                    error: `Call failed for ${call.call.classGuid}.${call.call.functionName}: ${message}`,
                     seqNum: call.call.seqNum,
                 });
             }
@@ -353,12 +353,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(new Error(`Connection error for ${niceConnectionName}: ${e.message}`).stack!);
+            onClose(`Connection error for ${niceConnectionName}: ${e.message}`);
         });
 
         newWebSocket.addEventListener("close", async () => {
             //console.log(`Websocket closed ${niceConnectionName}`);
-            onClose(new Error(`Connection closed to ${niceConnectionName}`).stack!);
+            onClose(`Connection closed to ${niceConnectionName}`);
         });
 
         newWebSocket.addEventListener("message", onMessage);
@@ -381,7 +381,7 @@ export async function createCallFactory(
             callFactory.isConnected = true;
             hasEverConnected = true;
         } else {
-            onClose(new Error(`Websocket received in closed state`).stack!);
+            onClose(`Websocket received in closed state`);
         }
 
         if (callFactory.lastClosed && callFactory.isConnected) {

package/src/callManager.ts

@@ -147,9 +147,13 @@ export const runClientHooks = measureWrap(async function runClientHooks(
     }
     for (let hook of clientHooks) {
         let time = Date.now();
-        await measureBlock(async () => {
+        if (hook.noMeasure) {
             await hook(context);
-        }, `clientHook|${hook.name || hook.toString().slice(0, 100)}`);
+        } else {
+            await measureBlock(async () => {
+                await hook(context);
+            }, `clientHook|${hook.name || hook.toString().slice(0, 100)}`);
+        }
         let now = Date.now();
         time = now - time;
         if (time > 500 && now - startupTime > 60_000) {

package/src/misc.ts

@@ -15,7 +15,11 @@ export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
 export function convertErrorStackToError(error: string): Error {
     let errorObj = new Error();
     errorObj.stack = String(error);
-    errorObj.message = String(error).split("\n")[0].slice("Error: ".length);
+    let message = String(error).split("\n")[0];
+    if (message.startsWith("Error: ")) {
+        message = message.slice("Error: ".length);
+    }
+    errorObj.message = message;
     return errorObj;
 }