anchor.diff:    }
   }
   
  -class MultiplexerCacheHit implements TraceEvent {
  -  const MultiplexerCacheHit();
  +class MultiplexerCacheHitEvent implements TraceEvent {
  +  factory MultiplexerCacheHitEvent() => const MultiplexerCacheHitEvent._private();
  +
  +  const MultiplexerCacheHitEvent._private();
   
     String toString() => 'streamy.multiplexer.cache.hit';
   }
   
  -class MultiplexerCacheMiss implements TraceEvent {
  -  const MultiplexerCacheMiss();
  +class MultiplexerCacheMissEvent implements TraceEvent {
  +  factory MultiplexerCacheMissEvent() => const MultiplexerCacheMissEvent._private();
  +
  +  const MultiplexerCacheMissEvent._private();
   
     String toString() => 'streamy.multiplexer.cache.miss';
   }
  +
  +class MultiplexerRpcSendEvent implements TraceEvent {
  +  factory MultiplexerRpcSendEvent() => const MultiplexerRpcSendEvent._private();
  +
  +  const MultiplexerRpcSendEvent._private();
  +
  +  String toString() => 'streamy.multiplexer.rpc.send';
  +}
  +
  +class MultiplexerRpcCancelEvent implements TraceEvent {
  +  factory MultiplexerRpcCancelEvent() => const MultiplexerRpcCancelEvent._private();
  +
  +  const MultiplexerRpcCancelEvent._private();
  +
  +  String toString() => 'streamy.multiplexer.rpc.cancel';
  +}
  +
   
   /// A [RequestHandler] which wraps [Multiplexer] and adds a few
   /// utility methods to delegate to it.
  
positive.code:       Future pending;
        if (!_inFlightRequests.containsKey(request)) {
          var completer = new Completer();
          var sub = _delegate.handle(request, trace).listen(completer.complete)
            ..onError(completer.completeError);
          var cancel = () {
            // The pending future will never complete.
            sub.cancel();
  
  
negative.code:       .then((cached) {
          // If there actually was an entity response, send it to the client.
          if (cached != null) {
            trace.record(new MultiplexerCacheHitEvent());
            active.submit(new Response(cached.entity, Source.CACHE, cached.ts));
          } else {
            trace.record(new MultiplexerCacheMissEvent());
          }
          var ts = new DateTime.now().millisecondsSinceEpoch;  // TODO: not testable
          // If we don't need to issue an rpc
  