Simple tracing using ES Proxies

proxy-trace.js

import assert from 'assert'

const tracer = async obj => {
  const trace = {}
  let order = []

  const object = new Proxy(obj, {
    get (target, prop) {
      order = order.concat(prop)
      trace[prop] = Reflect.has(trace, prop) ? trace[prop] + 1 : 1
      return Reflect.get(target, prop)
    }
  })
  
  return {
    object,
    getTrace: async () => trace,
    getOrder: async () => order
  }
}

const runner = async () => {
  const test = {
    one: async () => true,
    two: async () => true,
    three: async () => true
  }

  Object.defineProperty(test, 'run', {
    value: async obj => {
      await obj.one()
      await obj.three()
      await obj.two()
      await obj.one()
    }
  })

  const { object, getTrace, getOrder } = await tracer(test)

  await test.run(object)

  return {
    order: await getOrder(),
    trace: await getTrace()
  }
}

runner().then(({ order, trace }) => {
  assert.deepEqual(order, [
    'methodOne',
    'methodThree',
    'methodTwo',
    'methodOne'
  ])
  assert.deepEqual(trace, {
    methodOne: 2,
    methodThree: 1,
    methodTwo: 1
  })
})