reimplemented callstack - making it crossplatform

Author: pmunin

src/node/callStack.test.ts src/callStack.test.tssrc/node/callStack.test.ts renamed to src/callStack.test.ts

@@ -1,4 +1,4 @@
-import { TryCatchFinallyHooksBuilder } from "../TryCatchFinallyHooks"
+import { TryCatchFinallyHooksBuilder } from "./TryCatchFinallyHooks"
 import { callStack } from './callStack'
 import { AsyncResource, AsyncLocalStorage } from 'node:async_hooks'
 
@@ -7,13 +7,13 @@ function createTrack(log:any){
   .add(callStack)
   .add({
     onTry(ctx) {
-      log("onTry", [...ctx.callstack.actions.map(c=>c.args.name), ctx.args.name].join('/'))
+      log("onTry", [...ctx.callstack.map(c=>c.args.name), ctx.args.name].join('/'))
       return {
         onFinally() {
-          log("onFinally",[...ctx.callstack.actions.map(c=>c.args.name), ctx.args.name].join('/'))
+          log("onFinally",[...ctx.callstack.map(c=>c.args.name), ctx.args.name].join('/'))
         },
         onCatch() {
-          log("onCatch",[...ctx.callstack.actions.map(c=>c.args.name), ctx.args.name].join('/'))
+          log("onCatch",[...ctx.callstack.map(c=>c.args.name), ctx.args.name].join('/'))
         }
       }
     }
@@ -22,7 +22,8 @@ function createTrack(log:any){
 
 
 test("callstack", ()=>{
-  const log = jest.fn((...args:any[])=>console.log(...args))
+  //const log = jest.fn((...args:any[])=>console.log(...args))
+  const log = jest.fn()
   const track = createTrack(log)
 
   const myChildFunc = jest.fn(track.asFunctionWrapper({name:"MyChildFunc"})((a:number,b:number)=>{
@@ -48,7 +49,8 @@ test("callstack", ()=>{
 
 test("callstack async",async ()=>{
   const amountOfParallels = 2
-  const log = jest.fn((...args:any[])=>console.log("async",...args))
+  //const log = jest.fn((...args:any[])=>console.log("async",...args))
+  const log = jest.fn()
   const track = createTrack(log)
 
   const asyncStr = new AsyncLocalStorage<any>()
@@ -84,20 +86,23 @@ test("callstack async",async ()=>{
 
 function delay(ms:number){return new Promise(r=>setTimeout(r,ms))}
 
-test.only("callstack recursive fiboncci", ()=>{
-  const log = jest.fn((...args:any[])=>console.log(...args))
+test("callstack recursive sync", ()=>{
+  //const log = jest.fn((...args:any[])=>console.log(...args))
+  const log = jest.fn()
   const track = createTrack(log)
 
-  const fib = jest.fn(track.asFunctionWrapper({name:"fib"})(function(n:number):number{
+  const myRecFunc = jest.fn(track.asFunctionWrapper({name:"myRecFunc"})(function(n:number):number{
     if(n<=1) return 1
-    return fib(n-1)+fib(n-2)
+    return 1+myRecFunc(n-1)
   }))
 
-  const actRes =fib(3)
-  const expRes = 1+ 1+2 + 1+2+3
+  const actRes =myRecFunc(3)
+  const expRes = 1 + 1 + 1
   expect(actRes).toBe(expRes)
-  expect(fib).toHaveBeenCalledTimes(1+2+3)
-  expect(log).toHaveBeenCalledTimes((1+2+3)*2)
+  expect(myRecFunc).toHaveBeenCalledTimes(3)
+  expect(log).toHaveBeenCalledTimes((3)*2)
+  expect(log).toHaveBeenNthCalledWith(1, "onTry", "myRecFunc")
+  expect(log).toHaveBeenNthCalledWith(2, "onTry", "myRecFunc/myRecFunc")
 })
 
 // test.skip('async hooks',async ()=>{

src/callStack.ts

@@ -0,0 +1,95 @@
+import { ITryCatchFinallyHook } from "./TryCatchFinallyHooks";
+
+/**
+ * This is a callstack tracker, which provides Stack of Called Function Context - works both for async and sync call stacks
+ * Works both on node and browser
+ * 
+ * How it works:
+ * Each context (action invocation) is assigned with unique id (callId)
+ * We track global list of contexts objects that are currently active (between try and finally).
+ * During onTry Context.func (that is about to be invoked) is replaced with a special function wrapper that has assigned unique name `callstack_callId:<context.callId>`.
+ * Now those function names in Error.captureCallstack() can be associated context.callstack.callId via list of context objects that are currently active.
+ * 
+ * If you don't see actions in your callstack, increase Error.stackTraceLimit
+ */
+
+const callPrefix = 'callstack_callId:'
+
+export type CallstackContext = { args: { name?: string;}, name:string, id: string, callstack: CallstackContext[] };
+
+export const callStack: ITryCatchFinallyHook<CallstackContext> = {
+  onTry(ctx) {
+    if(!ctx.name)
+      ctx.name = ctx.args.name || ctx.func.name || '<anonymous>'
+    
+    if(!ctx.id)
+      ctx.id = Math.random().toString(16).slice(2)
+    getOrUpdateAllActiveContexts(actions=>[...actions, ctx])
+    
+
+    const origFunc = ctx.func
+    const callstackCallWrapper = function (this:any,...args:any) { return origFunc.apply(this, args) }
+    Object.defineProperty(callstackCallWrapper, 'name', {value:callPrefix+ctx.id})
+    ctx.func = callstackCallWrapper
+
+    Object.defineProperty(ctx, 'callstack', { 
+      get() {
+        const contextsMap = new Map(getOrUpdateAllActiveContexts().map(ctx=>[ctx.id, ctx]))
+        const actionCallIdStack = getActionCallIdsStack()
+        return actionCallIdStack.map(ctxId=>contextsMap.get(ctxId)!)
+      }
+    });
+    
+    return {
+      onFinally() {
+        getOrUpdateAllActiveContexts(ctxs=>ctxs.filter(c=>c!=ctx))
+      },
+      lastInQueue: true
+    };
+  }
+};
+
+function prepareActionStackTrace(error: Error, stack: NodeJS.CallSite[]): string[] {
+  return stack
+    .map(s=>s.getFunctionName()!)
+    .filter(s=>s?.startsWith(callPrefix))
+    .map(s=>s.slice(callPrefix.length))
+}
+
+function getActionCallIdsStack():string[]
+{
+  const prepStackOld = Error.prepareStackTrace
+  try
+  {
+    Error.prepareStackTrace = prepareActionStackTrace
+    const resObj: { stack?: string[]} = {}
+    Error.captureStackTrace(resObj)
+    return resObj.stack as string[]
+  }
+  finally{
+    Error.prepareStackTrace = prepStackOld
+  }
+}
+
+
+const allActiveContexts// mimicking AsyncLocalStorage
+ = {
+  _items:undefined as CallstackContext[]|undefined,
+  getStore():CallstackContext[]|undefined{
+    return [...this._items||[]]
+  },
+  enterWith(items:CallstackContext[]){
+    this._items = items||[]
+  }
+ }
+
+function getOrUpdateAllActiveContexts(update?:(old:CallstackContext[])=>undefined|CallstackContext[]):CallstackContext[]{
+  const store = [...allActiveContexts.getStore()||[]]
+  if(update)
+  {
+    const res = update(store)
+    if(res) allActiveContexts.enterWith(res);
+    return res || store
+  }
+  return store
+}

src/example/tracker.ts

@@ -1,4 +1,4 @@
-import { callStack } from "../node/callStack";
+import { callStack } from "../callStack";
 import { logOnFinally } from "./logOnFinally";
 import { measureDuration } from "../measureDuration";
 import { TryCatchFinallyHooksBuilder, ContextOf } from "../TryCatchFinallyHooks";

src/node/callStack.ts

@@ -1,7 +1,8 @@
-export type FunctionContext<TFunc extends (...args: any[]) => any = (...args: any[]) => any> = {
+export type FunctionContext<TFunc extends (this:any, ...args: any[]) => any = (this:any,...args: any[]) => any> = {
   func: TFunc
   funcWrapper: TFunc  
   funcArgs: Parameters<TFunc>
+  funcThis?: ThisParameterType<TFunc>
   funcOutcome?: FunctionExecutionOutcome<TFunc>
 }
 
@@ -16,14 +17,14 @@ export type FunctionInterceptors<TFunc extends (this:any, ...args: any[]) => any
 }
 
 export function createTryCatchFinally<TFunc extends (this:any, ...args: any[]) => any, TContext extends {}>(
-  fn: TFunc,
+  func: TFunc,
   interceptors: FunctionInterceptors<TFunc, TContext>
 ): TFunc {
   type Ctx = FunctionContext<TFunc> & TContext
   let funcWrapper:TFunc = function tryCatchFinallyWrapper(...funcArgs) {
     let isAsync = false
     let funcRes: ReturnType<TFunc>;
-    let ctx: Ctx = <FunctionContext<TFunc>> { func: fn, funcArgs, funcWrapper } as any
+    let ctx: Ctx = <FunctionContext<TFunc>> { func, funcArgs, funcWrapper, funcThis: this } as any
     let tryRes: ReturnType<NonNullable<typeof interceptors.onTry>> = {} as any;
     let onCatch = 'onCatch' in interceptors ? interceptors.onCatch : undefined;
     let onFinally = 'onFinally' in interceptors ? interceptors.onFinally : undefined;
@@ -35,7 +36,7 @@ export function createTryCatchFinally<TFunc extends (this:any, ...args: any[]) =
       if('onCatch' in tryRes) onCatch = tryRes.onCatch
       if('onFinally' in tryRes) onFinally = tryRes.onFinally
 
-      funcRes = ctx.func?.apply(this,funcArgs);
+      funcRes = ctx.func?.apply(ctx.funcThis,ctx.funcArgs);
       isAsync = isPromise(funcRes);
       ctx.funcOutcome = { type: 'success', result: funcRes as Awaited<ReturnType<TFunc>> };
       if (!isAsync) {
@@ -77,7 +78,7 @@ export function createTryCatchFinally<TFunc extends (this:any, ...args: any[]) =
       }
     }
   } as TFunc;
-  Object.defineProperty(funcWrapper, 'name', { value: funcWrapper.name+'_'+(fn.name||'anonymous') });
+  Object.defineProperty(funcWrapper, 'name', { value: funcWrapper.name+'_'+(func.name||'anonymous') });
   return funcWrapper
 }