Add isolate tag-profile and better handling of errors

runtime/bin/vmservice/client/lib/src/service/object.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of service;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
@@ skipping 35 matching lines @@
 
   @observable String name;
   @observable String vmName;
 
   /// Creates an empty [ServiceObject].
   ServiceObject._empty(this._owner);
 
   /// Creates a [ServiceObject] initialized from [map].
   factory ServiceObject._fromMap(ServiceObjectOwner owner,
                                  ObservableMap map) {
+    if (map == null) {
+      return null;
+    }
     if (!_isServiceMap(map)) {
       Logger.root.severe('Malformed service object: $map');
     }
     assert(_isServiceMap(map));
     var type = _stripRef(map['type']);
     var obj = null;
     assert(type != 'VM');
     switch (type) {
       case 'Code':
         obj = new Code._empty(owner);
         break;
       case 'Error':
-        obj = new ServiceError._empty(owner);
+        obj = new DartError._empty(owner);
         break;
       case 'Isolate':
         obj = new Isolate._empty(owner);
         break;
+      case 'ServiceError':
+        obj = new ServiceError._empty(owner);
+        break;
+      case 'ServiceException':
+        obj = new ServiceException._empty(owner);
+        break;
       case 'Script':
         obj = new Script._empty(owner);
         break;
       default:
         obj = new ServiceMap._empty(owner);
     }
     obj.update(map);
     return obj;
   }
 
@@ skipping 78 matching lines @@
   @observable String architecture = 'unknown';
   @observable double uptime = 0.0;
 
   VM() : super._empty(null) {
     name = 'vm';
     vmName = 'vm';
     _cache['vm'] = this;
     update(toObservable({'id':'vm', 'type':'@VM'}));
   }
 
+  final StreamController<ServiceException> exceptions =
+      new StreamController.broadcast();
+  final StreamController<ServiceError> errors =
+      new StreamController.broadcast();
+
   static final RegExp _currentIsolateMatcher = new RegExp(r'isolates/\d+');
-  static final RegExp _currentObjectMatcher = new RegExp(r'isolates/\d+(/|$)');
+  static final RegExp _currentObjectMatcher = new RegExp(r'isolates/\d+/');
   static final String _isolatesPrefix = 'isolates/';
 
   String _parseObjectId(String id) {
     Match m = _currentObjectMatcher.matchAsPrefix(id);
     if (m == null) {
       return null;
     }
     return m.input.substring(m.end);
   }
 
@@ skipping 58 matching lines @@
     // Cache miss.  Get the object from the vm directly.
     return getAsMap(id).then((ObservableMap map) {
         var obj = new ServiceObject._fromMap(this, map);
         if (obj.canCache) {
           _cache.putIfAbsent(id, () => obj);
         }
         return obj;
       });
   }
 
-  /// Gets [id] as an [ObservableMap] from the service directly.
+  /// Gets [id] as an [ObservableMap] from the service directly. If
+  /// an error occurs, the future is completed as an error with a
+  /// ServiceError or ServiceException. Therefore any chained then() calls
+  /// will only receive a map encoding a valid ServiceObject.
   Future<ObservableMap> getAsMap(String id) {
     return getString(id).then((response) {
       try {
-        var map = JSON.decode(response);
-        return toObservable(map);
+        var map = toObservable(JSON.decode(response));
+        // Verify that the top level response is a service map.
+        if (!_isServiceMap(map)) {
+          return new Future.error(
+                new ServiceObject._fromMap(this, toObservable({
+            'type': 'ServiceException',
+            'id': '',
+            'kind': 'FormatException',
+            'response': map,
+            'message': 'Top level service responses must be service maps.',
+          })));
+        }
+        // Preemptively capture ServiceError and ServiceExceptions.
+        if (map['type'] == 'ServiceError') {
+          return new Future.error(new ServiceObject._fromMap(this, map));
+        } else if (map['type'] == 'ServiceException') {
+          return new Future.error(new ServiceObject._fromMap(this, map));
+        }
+        // map is now guaranteed to be a non-error/exception ServiceObject.
+        return map;
       } catch (e, st) {
-        return toObservable({
-          'type': 'Error',
+        print(e);
+        print(st);
+        return new Future.error(
+              new ServiceObject._fromMap(this, toObservable({
+          'type': 'ServiceException',
           'id': '',
-          'kind': 'DecodeError',
-          'message': '$e',
-        });
+          'kind': 'DecodeException',
+          'response': response,
+          'message': 'Could not decode JSON: $e',
+        })));
       }
     }).catchError((error) {
-      return toObservable({
-        'type': 'Error',
-        'id': '',
-        'kind': 'LastResort',
-        'message': '$error'
-      });
-    });
+      // ServiceError, forward to VM's ServiceError stream.
+      errors.add(error);
+      return new Future.error(error);
+    }, test: (e) => e is ServiceError).catchError((exception) {
+      // ServiceException, forward to VM's ServiceException stream.
+      exceptions.add(exception);
+      return new Future.error(exception);
+    }, test: (e) => e is ServiceException);
   }
 
   /// Get [id] as a [String] from the service directly. See [getAsMap].
   Future<String> getString(String id);
 
   void _update(ObservableMap map, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _loaded = true;
@@ skipping 19 matching lines @@
     }
     // Update the individual isolates asynchronously.
     newIsolateCache.forEach((isolateId, isolate) {
       isolate.reload();
     });
 
     _isolateCache = newIsolateCache;
   }
 }
 
+/// Snapshot in time of tag counters.
+class TagProfileSnapshot {
+  final double seconds;
+  final List<int> counters;
+  int get sum => _sum;
+  int _sum = 0;
+  TagProfileSnapshot(this.seconds, int countersLength)
+      : counters = new List<int>(countersLength);
+
+  /// Set [counters] and update [sum].
+  void set(List<int> counters) {
+    this.counters.setAll(0, counters);
+    for (var i = 0; i < this.counters.length; i++) {
+      _sum += this.counters[i];
+    }
+  }
+
+  /// Set [counters] with the delta from [counters] to [old_counters]
+  /// and update [sum].
+  void delta(List<int> counters, List<int> old_counters) {
+    for (var i = 0; i < this.counters.length; i++) {
+      this.counters[i] = counters[i] - old_counters[i];
+      _sum += this.counters[i];
+    }
+  }
+
+  /// Update [counters] with new maximum values seen in [counters].
+  void max(List<int> counters) {
+    for (var i = 0; i < counters.length; i++) {
+      var c = counters[i];
+      this.counters[i] = this.counters[i] > c ? this.counters[i] : c;
+    }
+  }
+
+  /// Zero [counters].
+  void zero() {
+    for (var i = 0; i < counters.length; i++) {
+      counters[i] = 0;
+    }
+  }
+}
+
+class TagProfile {
+  final List<String> names = new List<String>();
+  final List<TagProfileSnapshot> snapshots = new List<TagProfileSnapshot>();
+  double get updatedAtSeconds => _seconds;
+  double _seconds;
+  TagProfileSnapshot _maxSnapshot;
+  int _historySize;
+  int _countersLength = 0;
+
+  TagProfile(this._historySize);
+
+  void _processTagProfile(double seconds, ObservableMap tagProfile) {
+    _seconds = seconds;
+    var counters = tagProfile['counters'];
+    if (names.length == 0) {
+      // Initialization.
+      names.addAll(tagProfile['names']);
+      _countersLength = tagProfile['counters'].length;
+      for (var i = 0; i < _historySize; i++) {
+        var snapshot = new TagProfileSnapshot(0.0, _countersLength);
+        snapshot.zero();
+        snapshots.add(snapshot);
+      }
+      // The counters monotonically grow, keep track of the maximum value.
+      _maxSnapshot = new TagProfileSnapshot(0.0, _countersLength);
+      _maxSnapshot.set(counters);
+      return;
+    }
+    var snapshot = new TagProfileSnapshot(seconds, _countersLength);
+    // We snapshot the delta from the current counters to the maximum counter
+    // values.
+    snapshot.delta(counters, _maxSnapshot.counters);
+    _maxSnapshot.max(counters);
+    snapshots.add(snapshot);
+    // Only keep _historySize snapshots.
+    if (snapshots.length > _historySize) {
+      snapshots.removeAt(0);
+    }
+  }
+}
+
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner {
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
 
   String get link => _id;
   String get hashLink => '#/$_id';
 
   @observable bool pausedOnStart = false;
   @observable bool pausedOnExit = false;
   @observable bool running = false;
   @observable bool idle = false;
 
   Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
+  final TagProfile tagProfile = new TagProfile(20);
 
-  Isolate._empty(ServiceObjectOwner owner) : super._empty(owner);
+  Isolate._empty(ServiceObjectOwner owner) : super._empty(owner) {
+    assert(owner is VM);
+  }
 
   /// Creates a link to [id] relative to [this].
   @reflectable String relativeLink(String id) => '${this.id}/$id';
   /// Creates a relative link to [id] with a '#/' prefix.
   @reflectable String relativeHashLink(String id) => '#/${relativeLink(id)}';
 
   static const TAG_ROOT_ID = 'code/tag-0';
 
   /// Returns the Code object for the root tag.
   Code tagRoot() {
@@ skipping 67 matching lines @@
     }
     // Build the object from the map directly.
     obj = new ServiceObject._fromMap(this, map);
     if (obj.canCache) {
       _cache[id] = obj;
     }
     return obj;
   }
 
   Future<ServiceObject> get(String id) {
+    // Do not allow null ids or empty ids.
+    assert(id != null && id != '');
     var obj = _cache[id];
     if (obj != null) {
       return obj.reload();
     }
     // Cache miss.  Get the object from the vm directly.
     return vm.getAsMap(relativeLink(id)).then((ObservableMap map) {
         var obj = new ServiceObject._fromMap(this, map);
         if (obj.canCache) {
           _cache.putIfAbsent(id, () => obj);
         }
@@ skipping 12 matching lines @@
   @observable final Map<String, double> timers =
       toObservable(new Map<String, double>());
 
   @observable int newHeapUsed = 0;
   @observable int oldHeapUsed = 0;
   @observable int newHeapCapacity = 0;
   @observable int oldHeapCapacity = 0;
 
   @observable String fileAndLine;
 
+  @observable DartError error;
+
   void _update(ObservableMap map, bool mapIsRef) {
     mainPort = map['mainPort'];
     name = map['name'];
     vmName = map['name'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     _upgradeCollection(map, isolate);
     if (map['rootLib'] == null ||
@@ skipping 28 matching lines @@
     newHeapUsed = map['heap']['usedNew'];
     oldHeapUsed = map['heap']['usedOld'];
     newHeapCapacity = map['heap']['capacityNew'];
     oldHeapCapacity = map['heap']['capacityOld'];
 
     // Isolate status
     pausedOnStart = map['pausedOnStart'];
     pausedOnExit = map['pausedOnExit'];
     running = map['topFrame'] != null;
     idle = !pausedOnStart && !pausedOnExit && !running;
+    error = map['error'];
+  }
+
+  Future<TagProfile> updateTagProfile() {
+    return vm.getAsMap(relativeLink('profile/tag')).then((ObservableMap m) {
+      var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
+      tagProfile._processTagProfile(seconds, m);
+      return tagProfile;
+    });
   }
 
   @reflectable CodeTrieNode profileTrieRoot;
   // The profile trie is serialized as a list of integers. Each node
   // is recreated by consuming some portion of the list. The format is as
   // follows:
   // [0] index into codeTable of code object.
   // [1] tick count (number of times this stack frame occured).
   // [2] child node count
   // Reading the trie is done by recursively reading the tree depth-first
@@ skipping 91 matching lines @@
   bool deliverChanges() => _map.deliverChanges();
   void notifyChange(ChangeRecord record) => _map.notifyChange(record);
   notifyPropertyChange(Symbol field, Object oldValue, Object newValue) =>
       _map.notifyPropertyChange(field, oldValue, newValue);
   void observed() => _map.observed();
   void unobserved() => _map.unobserved();
   Stream<List<ChangeRecord>> get changes => _map.changes;
   bool get hasObservers => _map.hasObservers;
 }
 
+/// A [DartError] is peered to a Dart Error object.
+class DartError extends ServiceObject {
+  DartError._empty(ServiceObject owner) : super._empty(owner);
+
+  @observable String kind;
+  @observable String message;
+  @observable ServiceMap exception;
+  @observable ServiceMap stacktrace;
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    kind = map['kind'];
+    message = map['message'];
+    exception = new ServiceObject._fromMap(owner, map['exception']);
+    stacktrace = new ServiceObject._fromMap(owner, map['stacktrace']);
+    name = 'DartError $kind';
+    vmName = name;
+  }
+}
+
+/// A [ServiceError] is an error that was triggered in the service
+/// server or client. Errors are prorammer mistakes that could have
+/// been prevented, for example, requesting a non-existant path over the
+/// service.
 class ServiceError extends ServiceObject {
   ServiceError._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   @observable String kind;
   @observable String message;
 
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     kind = map['kind'];
     message = map['message'];
     name = 'ServiceError $kind';
     vmName = name;
   }
+}
 
-  // TODO: stackTrace?
+/// A [ServiceException] is an exception that was triggered in the service
+/// server or client. Exceptions are events that should be handled,
+/// for example, an isolate went away or the connection to the VM was lost.
+class ServiceException extends ServiceObject {
+  ServiceException._empty(ServiceObject owner) : super._empty(owner);
+
+  @observable String kind;
+  @observable String message;
+  @observable dynamic response;
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    kind = map['kind'];
+    message = map['message'];
+    response = map['response'];
+    name = 'ServiceException $kind';
+    vmName = name;
+  }
 }
 
 class ScriptLine {
   @reflectable final int line;
   @reflectable final String text;
   ScriptLine(this.line, this.text);
 }
 
 class Script extends ServiceObject {
   @reflectable final lines = new ObservableList<ScriptLine>();
@@ skipping 362 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }