Lambda the Ultimate

CL-USER> (defvar *current-trace* nil)                                                                       
*CURRENT-TRACE*

CL-USER> (defun my-trace (function-symbol)                                                                  
           (let ((function (symbol-function function-symbol)))                                              
             (setf (symbol-function function-symbol)                                                        
                   (lambda (&rest args)                                                                     
                     (multiple-value-bind (return-values trace)                                             
                         (let (*current-trace*)                                                             
                           (declare (special *current-trace*))                                              
                           (values (multiple-value-list (apply function args))                              
                                   (nreverse *current-trace*)))                                             
                       (push `(,function-symbol ,args ,return-values ,@trace)                               
                             *current-trace*)                                                               
                       (apply #'values return-values))))))

CL-USER> (defun a (a)                                                                                       
           (1+ a))

CL-USER> (defun test (a b)                                                                                  
           (values (a a)                                                                                    
                   b))

CL-USER> (my-trace 'test)                                                                                   
#<CLOSURE (LAMBDA (&REST ARGS)) {307B9315}>
CL-USER> (my-trace 'a)                                                                                      
#<CLOSURE (LAMBDA (&REST ARGS)) {307C59C5}>

CL-USER> (test 1 2)                                                                                         
2
2
CL-USER> *current-trace*                                                                                    
((TEST (1 2) (2 2) (A (1) (2))))

You'd want to save the symbol's original function somewhere, possibly in its properties if you were lazy. I'm sure it's equally hackable in smalltalk. Generally speaking, abusing dynamic state at function calls is easy in late binded languages. It's when one wants to play with the static environment that things get messy.

Trace reification sounds like a 20-line hack for just about any aspect-oriented language, if you're into that sort of thing. Certainly in Aspect-J what you describe would be pretty trivial to implement.

Debuggers usually already provide many ways of manipulating the stack trace after e.g. a exception or breakpoint (although I do not know which ones are able to reify it...)

Since JDK 1.4 (about four years, now), all Java environments provide reified stack traces. These are available at run-time, and not just in the debugger, but are read-only to prevent security spoofing.

Quoting from Pickaxe 1st Ed. (Since it's online and I'm too lazy to type it out from 2nd):

set_trace_func(aProc)

Establishes aProc as the handler for tracing, or disables tracing if the parameter is nil. aProc takes up to six parameters: an event name, a filename, a line number, an object id, a binding, and the name of a class. aProc is invoked whenever an event occurs. Events are: c-call (call a C-language routine), c-return (return from a C-language routine), call (call a Ruby method), class (start a class or module definition), end (finish a class or module definition), line (execute code on a new line), raise (raise an exception), and return (return from a Ruby method). Tracing is disabled within the context of aProc.

Doing this in Perl 5 is fairly simple. You can easily redefine functions with symbol table manipulation. Using the built-in caller() function you can get information about how deep you are in the call chain, as well as what function called the current invocation. Tracking arguments is also trivial, as is maintaining Perl's context sensitive return values. It also doesn't suffer from the issue the Common LISP example above does because you can redefine built-in functions using the CORE:: namespace (it's tricky for sure, but possible).

The Hat tracer for Haskell gives you almost exactly what you want. Your original program is transformed into a program that computes its own trace as a data structure. (The data structure is stored in a file rather than memory, but that is mostly for efficiency, since it is so huge.) Within the trace, every reduction has a link from the redex to the reduct (result), and also backwards from the reduct to the redex (parent link). At the moment, Hat has specialised tools to view and explore the trace, but in theory you could suck it back in as a Haskell value if you wanted. (The major issue again is the size of the trace.) There is also current research on developing a relational query language over traces.

Unlike the other languages mentioned above (Java, Ruby, Perl), the Hat traces are not just stack back-traces, but truly complete records of everything the program ever did.