anchor.diff:  
   /// Fired when the user callback of a response is queued.
   class UserCallbackQueuedEvent implements TraceEvent {
  -  factory UserCallbackQueuedEvent() => const UserCallbackQueuedEvent._private();
  -
  -  const UserCallbackQueuedEvent._private();
  +  final Response response;
  +  final error;
  +
  +  UserCallbackQueuedEvent({this.response: null, this.error: null});
   
     String toString() => 'streamy.userCallback.start';
   }
   
   /// Fired when the user callback of a response completes.
   class UserCallbackDoneEvent implements TraceEvent {
  -  factory UserCallbackDoneEvent() => const UserCallbackDoneEvent._private();
  -
  -  const UserCallbackDoneEvent._private();
  +  final Response response;
  +  final error;
  +
  +  UserCallbackDoneEvent({this.response: null, this.error: null});
   
     String toString() => 'streamy.userCallback.done';
   }
   
   /// Fired at the beginning of an asynchronous operation that happens during a user callback.
   class UserCallbackAsyncEnterEvent implements TraceEvent {
  -  factory UserCallbackAsyncEnterEvent() => const UserCallbackAsyncEnterEvent._private();
  -
  -  const UserCallbackAsyncEnterEvent._private();
  +  final Response response;
  +  final error;
  +
  +  UserCallbackAsyncEnterEvent({this.response: null, this.error: null});
   
     String toString() => 'streamy.userCallback.async.start';
   }
   
   /// Fired at the end of an asynchronous operation that happens during a user callback.
   class UserCallbackAsyncExitEvent implements TraceEvent {
  -  factory UserCallbackAsyncExitEvent() => const UserCallbackAsyncExitEvent._private();
  -
  -  const UserCallbackAsyncExitEvent._private();
  +  final Response response;
  +  final error;
  +
  +  UserCallbackAsyncExitEvent({this.response: null, this.error: null});
   
     String toString() => 'streamy.userCallback.async.done';
   }
  
positive.code:   UserCallbackTracingTransformer() : super();
  
    void handleData(Response response, EventSink<Response> sink, Trace trace) {
      trace.record(new UserCallbackQueuedEvent());
      _openCallbacks++;
      _runZonedWithOnDone(() => sink.add(response), () {
        trace.record(new UserCallbackDoneEvent());
        _openCallbacks--;
        if (_openCallbacks == 0 && _closed && !_sentDone) {
          trace.record(new RequestOverEvent());
          _sentDone = true;
        }
      }, trace);
    }
  
    void handleError(error, EventSink<Response> sink, Trace trace) {
      trace.record(new UserCallbackQueuedEvent());
      _openCallbacks++;
      _runZonedWithOnDone(() {
        sink.addError(error);
      }, () {
        trace.record(new UserCallbackDoneEvent());
        _openCallbacks--;
        if (_openCallbacks == 0 && _closed && !_sentDone) {
          trace.record(new RequestOverEvent());
          _sentDone = true;
        }
      }, trace);
    }
  
    void handleDone(EventSink<Response> sink, Trace trace) {
  
negative.code:       }
        asyncCount++;
        parent.scheduleMicrotask(zone, () {
          trace.record(new UserCallbackAsyncEnterEvent(
              response: response, error: error));
          try {
            f();
          } finally {
            trace.record(new UserCallbackAsyncExitEvent(
                response: response, error: error));
            asyncCount--;
            if (asyncCount == 0) {
              inOnDone = true;
  