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 84 matching lines @@
       assert(serviceType == 'Error');
       return new Future.value(this);
     }
     return vm.getAsMap(link).then(update);
   }
 
   /// Update [this] using [m] as a source. [m] can be a reference.
   ServiceObject update(ObservableMap m) {
     // Assert that m is a service map.
     assert(ServiceObject.isServiceMap(m));
-    if ((m['type'] == 'Error') && (_serviceType != 'Error')) {
-      // Got an unexpected error. Don't update the object.
-      return _upgradeToServiceObject(vm, isolate, m);
-    }
     // TODO(johnmccutchan): Should we allow for a ServiceObject's id
     // or type to change?
     _id = m['id'];
     _serviceType = stripRef(m['type']);
     _update(m);
     return this;
   }
 
   // update internal state from [map]. [map] can be a reference.
   void _update(ObservableMap map);
 
   void _created() {
-    var refNotice = _ref ? ' Created from reference.' : '';
-    Logger.root.info('Created ServiceObject for \'${_id}\' with type '
-                     '\'${_serviceType}\'.' + refNotice);
   }

[turnidge, 2014/03/24 20:22:13]

Maybe just drop _created() entirely.

[Cutch, 2014/03/25 14:39:06]

Done.

 
   // ------------------------------------------------------
 
   /// Returns true if [map] is a service map. i.e. it has the following keys:
   /// 'id' and a 'type'.
   static bool isServiceMap(ObservableMap m) {
     return (m != null) && (m['id'] != null) && (m['type'] != null);
   }
 
   /// Returns true if [type] is a reference type. i.e. it begins with an
@@ skipping 29 matching lines @@
     assert(_isolates == null);
     _isolates = new IsolateList(this);
     name = "vm";
     vmName = "vm";
   }
 
   VM() : super(null, "vm", "VM") {
     _initOnce();
   }
 
+  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+(/|$)');
 
   String _parseObjectId(String id) {
     Match m = _currentObjectMatcher.matchAsPrefix(id);
     if (m == null) {
       return null;
     }
     return m.input.substring(m.end);
   }
@@ skipping 31 matching lines @@
           }
         }
       }
     } else if (id == 'vm') {
       return reload();
     } else {
       return getDirect(id);
     }
   }
 
-  /// 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 the chained then()
+  /// execution path will always receive a map encoding a ServiceObject.
   Future<ObservableMap> getAsMap(String id) {
     return getString(id).then((response) {
       try {
-        var map = JSON.decode(response);
-        Logger.root.info('Decoded $id');
-        Logger.root.info('Response $response');
-        return toObservable(map);
+        var map = toObservable(JSON.decode(response));
+        if (!ServiceObject.isServiceMap(map)) {
+          return new Future.error(
+                new ServiceException.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 ServiceError.fromMap(this, map));
+        } else if (map['type'] == 'ServiceException') {
+          return new Future.error(new ServiceException.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 ServiceException.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.
+      errors.add(error);
+      return new Future.error(error);
+    }, test: (e) => e is ServiceError).catchError((exception) {

[turnidge, 2014/03/24 20:22:13]

I hadn't seen the "test" stuff before.  Wacky!

+      // ServiceException.
+      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) {
     _ref = false;
     version = map['version'];
     architecture = map['architecture'];
     uptime = map['uptime'];
     _isolates.updateIsolates(map['isolates']);
     allIsolates.clear();
     allIsolates.addAll(_isolates.isolates.values);
   }
 }
 
+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);
+    }
+  }
+}

[turnidge, 2014/03/24 20:22:13]

What do you think of us moving the profilng helper classes out of object.dart
later?  Not for this review - would conflict too horribly with my change.

[Cutch, 2014/03/25 14:39:06]

sgtm.

+
 /// State for a running isolate.
 class Isolate extends ServiceObject {
+  final TagProfile tagProfile = new TagProfile(20);
+
   String get link => _id;
   String get hashLink => '#/$_id';
 
   @observable bool pausedOnStart = false;
   @observable bool pausedOnExit = false;
   @observable bool running = false;
   @observable bool idle = false;
 
   ScriptCache _scripts;
   /// Script cache.
@@ skipping 88 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 stickyError;
+
   void _update(ObservableMap map) {
     upgradeCollection(map, vm, this);
     mainPort = map['mainPort'];
     name = map['name'];
     if (ServiceObject.isRefType(map['type'])) {
       return;
     }
     _ref = false;
     if (map['rootLib'] == null ||
         map['timers'] == 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;
+    stickyError = map['stickyError'];
+  }
+
+  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 34 matching lines @@
     return node;
   }
 }
 
 // TODO(johnmccutchan): Make this into an IsolateCache.
 class IsolateList {
   final VM _vm;
   final isolates = new ObservableMap<String, Isolate>();
 
   IsolateList(this._vm);
-  
+
   void updateIsolates(List<Map> members) {
      // Find dead isolates.
      var deadIsolates = [];
      isolates.forEach((k, v) {
        if (!_foundIsolateInMembers(k, members)) {
          deadIsolates.add(k);
        }
      });
      // Remove them.
      deadIsolates.forEach((id) {
@@ skipping 50 matching lines @@
     isolates[id] = isolate;
     isolate.load();
     return isolate;
   }
 
   static bool _foundIsolateInMembers(String id, List<Map> members) {
     return members.any((E) => E['id'] == id);
   }
 }
 
-
 /// A [ServiceObject] which implements [ObservableMap].
 class ServiceMap extends ServiceObject implements ObservableMap {
   final ObservableMap _map = new ObservableMap();
   ServiceMap(Isolate isolate, String id, String serviceType) :
       super(isolate, id, serviceType) {
   }
 
   ServiceMap.fromMap(Isolate isolate, ObservableMap m) :
       super.fromMap(isolate, m);
 
@@ skipping 32 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;
 }
 
-class ServiceError extends ServiceObject {
-  ServiceError.fromMap(ServiceObject owner, Map m) : super.fromMap(owner, m);
+/// A [DartError] is peered to a Dart Error object.
+class DartError extends ServiceObject {
+  DartError.fromMap(ServiceObject owner, Map m) : super.fromMap(owner, m);
 
   @observable String kind;
   @observable String message;
+  @observable ServiceMap exception;
+  @observable ServiceMap stacktrace;
+
+  void _update(ObservableMap map) {
+    kind = map['kind'];
+    message = map['message'];
+    if (map['exception'] != null) {
+      exception = new ServiceMap.fromMap(owner, map['exception']);
+    } else {
+      exception = null;
+    }
+    if (map['stacktrace'] != null) {
+      stacktrace = new ServiceMap.fromMap(owner, map['stacktrace']);
+    } else {
+      stacktrace = null;
+    }
+    name = 'DartError $kind';
+    vmName = name;
+  }
+
+  // TODO: stackTrace?

[turnidge, 2014/03/24 20:22:13]

Delete this TODO?

[Cutch, 2014/03/25 14:39:06]

Done.

+}
+
+/// 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.fromMap(ServiceObject owner, Map m)
+      : super.fromMap(owner, m);
+
+  @observable String kind;
+  @observable String message;
 
   void _update(ObservableMap map) {
     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.fromMap(ServiceObject owner, Map m)
+      : super.fromMap(owner,  m);
+
+  @observable String kind;
+  @observable String message;
+  @observable dynamic response;
+
+  void _update(ObservableMap map) {
+    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 252 matching lines @@
   void _update(ObservableMap m) {
     assert(ServiceObject.isServiceMap(m));
     assert(m['id'] == _id);
     assert(ServiceObject.stripRef(m['type']) == _serviceType);
     name = m['user_name'];
     vmName = m['name'];
     kind = CodeKind.fromString(m['kind']);
     startAddress = int.parse(m['start'], radix:16);
     endAddress = int.parse(m['end'], radix:16);
     function = _upgradeToServiceObject(vm, isolate, m['function']);
-    objectPool = _upgradeToServiceObject(vm, isolate, m['object_pool']);
+    if (m['object_pool'] != null) {
+      objectPool = _upgradeToServiceObject(vm, isolate, m['object_pool']);
+    } else {
+      objectPool = null;
+    }
     var disassembly = m['disassembly'];
     if (disassembly != null) {
       _processDisassembly(disassembly);
     }
     // We are a reference if we don't have instructions and are Dart code.
     _ref = (instructions.length == 0) && (kind == CodeKind.Dart);
     hasDisassembly = (instructions.length != 0) && (kind == CodeKind.Dart);
   }
 
   @observable bool hasDisassembly = false;
@@ skipping 51 matching lines @@
 
   int _callCount(List<CodeCallCount> calls, Code code) {
     for (CodeCallCount caller in calls) {
       if (caller.code == code) {
         return caller.count;
       }
     }
     return 0;
   }
 }