Add log support to debugger

runtime/observatory/lib/src/elements/debugger.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.
 
 library debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/cli.dart';
 import 'package:observatory/debugger.dart';
 import 'package:observatory/service.dart';
+import 'package:logging/logging.dart';
 import 'package:polymer/polymer.dart';
 
 // TODO(turnidge): Move Debugger, DebuggerCommand to debugger library.
 abstract class DebuggerCommand extends Command {
   ObservatoryDebugger debugger;
 
   DebuggerCommand(this.debugger, name, children)
       : super(name, children);
 
   String get helpShort;
@@ skipping 319 matching lines @@
   String helpShort =
       'Continue running the isolate until it reaches the next source location';
 
   String helpLong =
       'Continue running the isolate until it reaches the next source '
       'location.\n'
       '\n'
       'Syntax: step\n';
 }
 
+class LogCommand extends DebuggerCommand {
+  LogCommand(Debugger debugger) : super(debugger, 'log', []);
+
+  Future run(List<String> args) async {
+    if (args.length == 0) {
+      debugger.console.print(
+          'Current log level: '
+          '${debugger._consolePrinter._minimumLogLevel.name}');
+      return new Future.value(null);
+    }
+    if (args.length > 1) {
+      debugger.console.print("log expects zero or one arguments");
+      return new Future.value(null);
+    }
+    var level = _findLevel(args[0]);
+    if (level == null) {
+      debugger.console.print('No such log level: ${args[0]}');
+      return new Future.value(null);
+    }
+    debugger._consolePrinter._minimumLogLevel = level;
+    debugger.console.print('Set log level to: ${level.name}');
+    return new Future.value(null);
+  }
+
+  Level _findLevel(String levelName) {
+    levelName = levelName.toUpperCase();
+    for (var level in Level.LEVELS) {
+      if (level.name == levelName) {
+        return level;
+      }
+    }
+    return null;
+  }
+
+  Future<List<String>> complete(List<String> args) {
+    if (args.length != 1) {
+      return new Future.value([args.join('')]);
+    }
+    var prefix = args[0].toUpperCase();
+    var result = <String>[];
+    for (var level in Level.LEVELS) {
+      if (level.name.startsWith(prefix)) {
+        result.add(level.name);
+      }
+    }
+    return new Future.value(result);
+  }
+
+  String helpShort =
+      'Control which log messages are displayed';
+
+  String helpLong =
+      'Get or set the minimum log level that should be displayed.\n'
+      '\n'
+      'Log levels (in ascending order): ALL, FINEST, FINER, FINE, CONFIG, '
+      'INFO, WARNING, SEVERE, SHOUT, OFF\n'
+      '\n'
+      'Default: OFF\n'
+      '\n'
+      'Syntax: log          '
+      '# Display the current minimum log level.\n'
+      '        log <level>  '
+      '# Set the minimum log level to <level>.\n'
+      '        log OFF      '
+      '# Display no log messages.\n'
+      '        log ALL      '
+      '# Display all log messages.\n';
+}
+
 class AsyncNextCommand extends DebuggerCommand {
   AsyncNextCommand(Debugger debugger) : super(debugger, 'anext', []) {
   }
 
   Future run(List<String> args) async {
     if (debugger.isolatePaused()) {
       var event = debugger.isolate.pauseEvent;
       if (event.asyncContinuation == null) {
         debugger.console.print("No async continuation at this location");
       } else {
@@ skipping 115 matching lines @@
     // TODO - fix DebuggerLocation complete
     return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Add a breakpoint by source location or function name';
 
   String helpLong =
       'Add a breakpoint by source location or function name.\n'
       '\n'
       'Syntax: break                       '
-      '- Break at the current position\n'
+      '# Break at the current position\n'
       '        break <line>                '
-      '- Break at a line in the current script\n'
+      '# Break at a line in the current script\n'
       '                                    '
       '  (e.g \'break 11\')\n'
       '        break <line>:<col>          '
-      '- Break at a line:col in the current script\n'
+      '# Break at a line:col in the current script\n'
       '                                    '
       '  (e.g \'break 11:8\')\n'
       '        break <script>:<line>       '
-      '- Break at a line:col in a specific script\n'
+      '# Break at a line:col in a specific script\n'
       '                                    '
       '  (e.g \'break test.dart:11\')\n'
       '        break <script>:<line>:<col> '
-      '- Break at a line:col in a specific script\n'
+      '# Break at a line:col in a specific script\n'
       '                                    '
       '  (e.g \'break test.dart:11:8\')\n'
       '        break <function>            '
-      '- Break at the named function\n'
+      '# Break at the named function\n'
       '                                    '
       '  (e.g \'break main\' or \'break Class.someFunction\')\n';
 }
 
 class ClearCommand extends DebuggerCommand {
   ClearCommand(Debugger debugger) : super(debugger, 'clear', []);
 
   Future run(List<String> args) {
     if (args.length > 1) {
       debugger.console.print('not implemented');
@@ skipping 44 matching lines @@
     }
     return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Remove a breakpoint by source location or function name';
 
   String helpLong =
       'Remove a breakpoint by source location or function name.\n'
       '\n'
       'Syntax: clear                       '
-      '- Clear at the current position\n'
+      '# Clear at the current position\n'
       '        clear <line>                '
-      '- Clear at a line in the current script\n'
+      '# Clear at a line in the current script\n'
       '                                    '
       '  (e.g \'clear 11\')\n'
       '        clear <line>:<col>          '
-      '- Clear at a line:col in the current script\n'
+      '# Clear at a line:col in the current script\n'
       '                                    '
       '  (e.g \'clear 11:8\')\n'
       '        clear <script>:<line>       '
-      '- Clear at a line:col in a specific script\n'
+      '# Clear at a line:col in a specific script\n'
       '                                    '
       '  (e.g \'clear test.dart:11\')\n'
       '        clear <script>:<line>:<col> '
-      '- Clear at a line:col in a specific script\n'
+      '# Clear at a line:col in a specific script\n'
       '                                    '
       '  (e.g \'clear test.dart:11:8\')\n'
       '        clear <function>            '
-      '- Clear at the named function\n'
+      '# Clear at the named function\n'
       '                                    '
       '  (e.g \'clear main\' or \'clear Class.someFunction\')\n';
 }
 
 // TODO(turnidge): Add argument completion.
 class DeleteCommand extends DebuggerCommand {
   DeleteCommand(Debugger debugger) : super(debugger, 'delete', []);
 
   Future run(List<String> args) {
     if (args.length < 1) {
@@ skipping 275 matching lines @@
   }
 
   String helpShort = 'Refresh debugging information of various sorts';
 
   String helpLong =
       'Refresh debugging information of various sorts.\n'
       '\n'
       'Syntax: refresh <subcommand>\n';
 }
 
-class _VMStreamPrinter {
+class _ConsoleStreamPrinter {
   ObservatoryDebugger _debugger;
 
-  _VMStreamPrinter(this._debugger);
-
+  _ConsoleStreamPrinter(this._debugger);
+  Level _minimumLogLevel = Level.OFF;
   String _savedStream;
   String _savedIsolate;
   String _savedLine;
   List<String> _buffer = [];
 
   void onEvent(String streamName, ServiceEvent event) {
+    if (event.kind == ServiceEvent.kLogging) {
+      // Check if we should print this log message.
+      if (event.logRecord['level'].value < _minimumLogLevel.value) {
+        return;
+      }
+    }
     String isolateName = event.isolate.name;
     // If we get a line from a different isolate/stream, flush
     // any pending output, even if it is not newline-terminated.
     if ((_savedIsolate != null && isolateName != _savedIsolate) ||
         (_savedStream != null && streamName != _savedStream)) {
        flush();
     }
-    String data = event.bytesAsString;
-    bool hasNewline = data.endsWith('\n');
+    String data;
+    bool hasNewline;
+    if (event.kind == ServiceEvent.kLogging) {
+      data = event.logRecord["message"].valueAsString;
+      hasNewline = true;
+    } else {
+      data = event.bytesAsString;
+      hasNewline = data.endsWith('\n');
+    }
     if (_savedLine != null) {
        data = _savedLine + data;
       _savedIsolate = null;
       _savedStream = null;
       _savedLine = null;
     }
     var lines = data.split('\n').where((line) => line != '').toList();
     if (lines.isEmpty) {
       return;
     }
@@ skipping 65 matching lines @@
         new StepCommand(this),
         new AsyncNextCommand(this),
         new FinishCommand(this),
         new BreakCommand(this),
         new SetCommand(this),
         new ClearCommand(this),
         new DeleteCommand(this),
         new InfoCommand(this),
         new IsolateCommand(this),
         new RefreshCommand(this),
+        new LogCommand(this),
     ]);
-    _stdioPrinter = new _VMStreamPrinter(this);
+    _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
   VM get vm => page.app.vm;
 
   void updateIsolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
       if ((exceptions != iso.exceptionsPauseInfo) &&
           (iso.exceptionsPauseInfo != null)) {
         exceptions = iso.exceptionsPauseInfo;
@@ skipping 230 matching lines @@
           _reportBreakpointEvent(event);
         }
         break;
 
       case ServiceEvent.kIsolateStart:
       case ServiceEvent.kGraph:
       case ServiceEvent.kGC:
       case ServiceEvent.kInspect:
         break;
 
+      case ServiceEvent.kLogging:
+        _consolePrinter.onEvent(event.logRecord['level'].name, event);
+        break;
+
       default:
         console.print('Unrecognized event: $event');
         break;
     }
   }
 
-  _VMStreamPrinter _stdioPrinter;
+  _ConsoleStreamPrinter _consolePrinter;
 
   void flushStdio() {
-    _stdioPrinter.flush();
+    _consolePrinter.flush();
   }
 
   void onStdout(ServiceEvent event) {
-    _stdioPrinter.onEvent('stdout', event);
+    _consolePrinter.onEvent('stdout', event);
   }
 
   void onStderr(ServiceEvent event) {
-    _stdioPrinter.onEvent('stderr', event);
+    _consolePrinter.onEvent('stderr', event);
   }
 
   static String _commonPrefix(String a, String b) {
     int pos = 0;
     while (pos < a.length && pos < b.length) {
       if (a.codeUnitAt(pos) != b.codeUnitAt(pos)) {
         break;
       }
       pos++;
     }
@@ skipping 73 matching lines @@
   ObservatoryDebugger debugger = new ObservatoryDebugger();
 
   DebuggerPageElement.created() : super.created() {
     debugger.page = this;
   }
 
   Future<StreamSubscription> _isolateSubscriptionFuture;
   Future<StreamSubscription> _debugSubscriptionFuture;
   Future<StreamSubscription> _stdoutSubscriptionFuture;
   Future<StreamSubscription> _stderrSubscriptionFuture;
+  Future<StreamSubscription> _logSubscriptionFuture;
 
   @override
   void attached() {
     super.attached();
 
     var navbarDiv = $['navbarDiv'];
     var stackDiv = $['stackDiv'];
     var splitterDiv = $['splitterDiv'];
     var cmdDiv = $['commandDiv'];
 
@@ skipping 17 matching lines @@
     debugger.init();
 
     _isolateSubscriptionFuture =
         app.vm.listenEventStream(VM.kIsolateStream, debugger.onEvent);
     _debugSubscriptionFuture =
         app.vm.listenEventStream(VM.kDebugStream, debugger.onEvent);
     _stdoutSubscriptionFuture =
         app.vm.listenEventStream(VM.kStdoutStream, debugger.onStdout);
     _stderrSubscriptionFuture =
         app.vm.listenEventStream(VM.kStderrStream, debugger.onStderr);
-
+    _logSubscriptionFuture =
+        app.vm.listenEventStream(Isolate.kLoggingStream, debugger.onEvent);
     // Turn on the periodic poll timer for this page.
     pollPeriod = const Duration(milliseconds:100);
 
     onClick.listen((event) {
       // Random clicks should focus on the text box.  If the user selects
       // a range, don't interfere.
       var selection = window.getSelection();
       if (selection == null || selection.type == 'Caret') {
         debugger.input.focus();
       }
     });
   }
 
   void onPoll() {
     debugger.flushStdio();
   }
 
   @override
   void detached() {
+    debugger.isolate = null;
     cancelFutureSubscription(_isolateSubscriptionFuture);
     _isolateSubscriptionFuture = null;
     cancelFutureSubscription(_debugSubscriptionFuture);
     _debugSubscriptionFuture = null;
     cancelFutureSubscription(_stdoutSubscriptionFuture);
     _stdoutSubscriptionFuture = null;
     cancelFutureSubscription(_stderrSubscriptionFuture);
     _stderrSubscriptionFuture = null;
+    cancelFutureSubscription(_logSubscriptionFuture);
+    _logSubscriptionFuture = null;
     super.detached();
   }
 }
 
 @CustomTag('debugger-stack')
 class DebuggerStackElement extends ObservatoryElement {
   @published Isolate isolate;
   @observable bool hasStack = false;
   @observable bool hasMessages = false;
   @observable bool isSampled = false;
@@ skipping 455 matching lines @@
         }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }