Question

Instead of having to create a custom logger for TRACE, e.g. following what methods were called and what classes were instantiated, is there an easy way to make all methods under a class log themselves? This is for a node.js application.

class MyClass

  constructor: () ->
    console.log 'MyClass:constructor'

  doThat: () ->
    console.log 'MyClass:doThat'

exports.MyClass = MyClass

myClass = new MyClass()
myClass.doThat()

If I had my way, you’d see 4 log messages instead of 2 (thus having to write less code to trace what’s happening).

Answer 1

I recently needed to implement something like this to trace some complicated OO-recursive stuff. Basically, i wanted to make a method “traceable” without polluting it too much; so maybe the solution could be applied here too.

First, add a function that makes other functions traceable:

Function::trace = do ->
  makeTracing = (ctorName, fnName, fn) ->
    (args...) ->
      console.log "#{ctorName}:#{fnName}"
      fn.apply @, args
  (arg) ->
    for own name, fn of arg 
      @prototype[name] = makeTracing @name, name, fn

Then, to use it, just add a @trace before each method you want to trace:

class MyClass
  @trace methodA: ->
    @methodB 42

  @trace methodB: ->
    console.log "method b called with #{n}"

Or add @trace only once and then indent all the traceable methods one more level:

class MyClass
  @trace 
    methodA: ->
      @methodB 42

    methodB: (n) ->
      console.log "method b called with #{n}"

As you can see trace is kind of abusing CoffeeScript’s syntax. method: -> 'foo' inside a class MyClass is interpreted a method definition. But @trace method: -> 'foo' is interpreted a calling the trace function of MyClass (which is a Function instance, to which we’ve added the trace function) passing it a literal object with one method key. In JavaScript it would be something like this.trace({method: function() {return 'foo';}}).

The trace function will just take that object and iterate it’s keys (the method names) and values (the methods) and add functions to the MyClass prototype that log their calls and in turn call the original methods.

Anyway, the output of (new MyClass).methodA() will be:

MyClass:methodA
MyClass:methodB
method b called with 42

This solution doesn’t work for constructors though, as they are not just normal methods.

You can get quite fancy with this. You can also log the arguments passed to each method, the return value, and even add indentation for nested calls if you so desire (the resulting traces can then be very helpful if you need to debug a complex problem =D).

---

Update: as a more interesting example, here’s a mini-version of the typical composite pattern example, geometrical figures and groups of figures: http://jsfiddle.net/2YuE7/ with a more interesting tracing function. All figures understand the move method. If we have this composite figure and call move on it:

f = new Composite [
  new Rectangle 5, 10, 3, 4
  new Composite [
    new Circle 0, 0, 2
    new Circle 0, 0, 4
    new Circle 0, 0, 6
  ]
]

f.move 2, 3

The trace output is:

(Composite[Rectangle[5,10,3,4],Composite[Circle[0,0,2],Circle[0,0,4],Circle[0,0,6]]]).move(2, 3)
| (Rectangle[5,10,3,4]).move(2, 3)
| -> Rectangle[7,13,3,4]
| (Composite[Circle[0,0,2],Circle[0,0,4],Circle[0,0,6]]).move(2, 3)
| | (Circle[0,0,2]).move(2, 3)
| | -> Circle[2,3,2]
| | (Circle[0,0,4]).move(2, 3)
| | -> Circle[2,3,4]
| | (Circle[0,0,6]).move(2, 3)
| | -> Circle[2,3,6]
| -> Composite[Circle[2,3,2],Circle[2,3,4],Circle[2,3,6]]
-> Composite[Rectangle[7,13,3,4],Composite[Circle[2,3,2],Circle[2,3,4],Circle[2,3,6]]]