anchor.diff:  
   == Implementation
   
  -Ideally, all the events generated from this library would happen in core Node code. However, this library has been created using monkey-patching to experiment and stabalize the API before attempting to get in include in node core.
  +Ideally, all the events generated from this library would happen in core Node code. However, this library has been created using monkey-patching to experiment and stabilize the API before attempting to get in include in node core.
   
   This library provides a very small subset of the implementation in order to demonstrate the API and concept. The following Node core APIs will need to be patched for a more complete implementation:
   
  
positive.code: 
  == Objectives
  
  The goal of this library is to build a common API which allows creation of node application monitoring tools, exception management, long stack-traces, resource tracking and cleanup etc.
  
  Most of the existing libraries which provide this functionality monkey-patch the node API layer and typically use closures to maintain context across async callbacks.
  
  However when one or more than one of these libraries are used simultaniously, there are drawbacks such as:
  
  * speed degradation
  * instability
  * loss of function information such as function.length, function.toString() etc.
  
  Ideally, there would be a common API that other libraries can build upon. The Async Tracker library attempts to do just that by providing a single interface on which other librares can be built. The use-cases captured in Async Tracker include:
  
  * Associating context which is carried across async callback boundries
  * Notification when async callback is scheduled
  ** Optinally capturing significant arguments from the parent function
  * Notification of callback being triggered
  ** Optionally allow running tasks before and after the callback
  * Notification when a callback is un-scheduled (timers, etc.)
  * Notification when `Observable` object are created or released
  * Enable cleanup of `Disposable` objects
  
  It is meant as a conversation stater and I would like to discuss any missing functionality or other feedback you have around this topic.
  
  == API Overview
  
  Async Tracker has 4 core APIs:
  
  . AsyncTracker Listeners: allows developers to register an object which will be notified of events
  . AsyncTracker Observables: allows developers to instrument their classes so they trigger events when they are created or released.
  . AsyncTracker Disposables: allows developers to enable cleanup of their classes. (Zones/Domains)
  . Deferred: allows developers to wrap callback methods so thay trigger events when they are created, invoked or released.
  
  === AsyncTracker Listener interface
  
  
negative.code: 
  === AsyncTracker Trigger interface
  
  These methods are intended to be called from inside node modules and will result in corresponding functions on the listener to be triggered.
  
  [[asynctrackerdeferredcreatedfname-cbid-fdata]]
  ==== AsyncTracker.deferredCreated(fName, cbId, fData)
  