socket-function 1.1.43 → 1.1.44

package/index.d.ts

@@ -630,6 +630,8 @@ declare module "socket-function/src/batching" {
         shouldRetry?: (message: string) => boolean;
         minDelay?: number;
         maxDelay?: number;
+        timeout?: number;
+        warningInterval?: number;
     }): T;
     /** @deprecated Use safeLoop instead */
     export declare const throttledLoop: typeof unblockLoop;
@@ -1131,6 +1133,9 @@ declare module "socket-function/src/misc" {
     export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
     export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
     export declare function errorToWarning<T>(promise: Promise<T>): void;
+    export declare function watchSlowPromise<T>(title: string, promise: Promise<T>, config: {
+        interval?: number;
+    }): Promise<T>;
 
 }
 

package/package.json

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

package/src/batching.d.ts

@@ -32,6 +32,8 @@ export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?:
     shouldRetry?: (message: string) => boolean;
     minDelay?: number;
     maxDelay?: number;
+    timeout?: number;
+    warningInterval?: number;
 }): T;
 /** @deprecated Use safeLoop instead */
 export declare const throttledLoop: typeof unblockLoop;

package/src/batching.ts

@@ -1,6 +1,6 @@
 import { formatTime } from "./formatting/format";
 import { red } from "./formatting/logColors";
-import { PromiseObj, isNode, timeoutToError } from "./misc";
+import { PromiseObj, isNode, timeoutToError, watchSlowPromise } from "./misc";
 import { measureWrap } from "./profiling/measure";
 import { AnyFunction, Args, MaybePromise } from "./types";
 
@@ -312,18 +312,32 @@ export function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
     shouldRetry?: (message: string) => boolean;
     minDelay?: number;
     maxDelay?: number;
+    timeout?: number;
+    warningInterval?: number;
 }): T {
-    let { maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY } = config || {};
+    let {
+        maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY,
+        timeout,
+        warningInterval,
+    } = config || {};
     let expFactor = Math.max(1, Math.log(maxDelay / minDelay) / Math.log(Math.max(maxRetries, 2)));
+    let name = fnc.name || fnc.toString().slice(0, 100);
     async function runFnc(args: any[], retries: number): Promise<ReturnType<T>> {
         try {
-            return await (fnc as any)(...args);
+            let promise = (fnc as any)(...args);
+            if (timeout !== undefined) {
+                promise = timeoutToError(timeout, promise, () => new Error(`timed out after ${formatTime(timeout)}`));
+            }
+            if (warningInterval !== undefined) {
+                promise = watchSlowPromise(name, promise, { interval: warningInterval });
+            }
+            return await promise;
         } catch (e: any) {
             if (shouldRetry && !shouldRetry(String(e.stack))) {
                 throw e;
             }
             if (retries < 0) throw e;
-            console.warn(`Retrying ${fnc.name}, due to error ${String(e.stack)}`);
+            console.warn(`Retrying ${name}, due to error ${String(e.stack)}`);
             retries--;
             let curCount = maxRetries - retries;
             await delay(minDelay * expFactor ** curCount);

package/src/misc.d.ts

@@ -96,3 +96,6 @@ export declare function timeoutToError<T>(time: number, p: Promise<T>, err: () =
 export declare function timeoutToUndefined<T>(time: number, p: Promise<T>): Promise<T | undefined>;
 export declare function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>): Promise<T | undefined>;
 export declare function errorToWarning<T>(promise: Promise<T>): void;
+export declare function watchSlowPromise<T>(title: string, promise: Promise<T>, config: {
+    interval?: number;
+}): Promise<T>;

package/src/misc.ts

@@ -1,5 +1,7 @@
 import { canHaveChildren, MaybePromise } from "./types";
-import { formatNumber } from "./formatting/format";
+import { formatNumber, formatTime } from "./formatting/format";
+import { delay } from "./batching";
+import { yellow } from "./formatting/logColors";
 
 export const timeInSecond = 1000;
 export const timeInMinute = timeInSecond * 60;
@@ -458,3 +460,20 @@ export function errorToWarning<T>(promise: Promise<T>): void {
         return undefined as any;
     }) as any;
 }
+
+export function watchSlowPromise<T>(title: string, promise: Promise<T>, config: {
+    interval?: number;
+}) {
+    let { interval = 5000 } = config;
+    let fulfilled = false;
+    void promise.finally(() => fulfilled = true);
+    let startTime = Date.now();
+    void (async () => {
+        while (true) {
+            await delay(interval);
+            if (fulfilled) break;
+            console.log(`${yellow(`Slow promise running for ${formatTime(Date.now() - startTime)}`)} | ${title}`);
+        }
+    })();
+    return promise;
+}