Collapse successful GET messages together.

lib/src/log.dart

 // Copyright (c) 2012, 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.
 
 /// Message logging.
 library pub.log;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 30 matching lines @@
 
 /// The list of recorded log messages. Will only be recorded if
 /// [recordTranscript()] is called.
 Transcript<Entry> _transcript;
 
 /// The currently-animated progress indicator, if any.
 ///
 /// This will also be in [_progresses].
 Progress _animatedProgress;
 
+/// The Timer used to coalesce a number of collapsible messages.
+///
+/// This is `null` if no collapsible messages are waiting to be displayed.
+Timer _collapsibleTimer;
+
+/// The queue of collapsible messages waiting to be displayed.
+final _collapsibleMessages = [];
+
 final _cyan = getSpecial('\u001b[36m');
 final _green = getSpecial('\u001b[32m');
 final _magenta = getSpecial('\u001b[35m');
 final _red = getSpecial('\u001b[31m');
 final _yellow = getSpecial('\u001b[33m');
 final _gray = getSpecial('\u001b[1;30m');
 final _none = getSpecial('\u001b[0m');
 final _noColor = getSpecial('\u001b[39m');
 final _bold = getSpecial('\u001b[1m');
 
@@ skipping 141 matching lines @@
 void io(message) => write(Level.IO, message);
 
 /// Logs [message] at [Level.SOLVER].
 void solver(message) => write(Level.SOLVER, message);
 
 /// Logs [message] at [Level.FINE].
 void fine(message) => write(Level.FINE, message);
 
 /// Logs [message] at [level].
 void write(Level level, message) {
+  // Don't allow interleaving collapsible messages with other kinds.
+  if (_collapsibleTimer != null) _flushCollapsible();
+
   message = message.toString();
   var lines = splitLines(message);
 
   // Discard a trailing newline. This is useful since StringBuffers often end
   // up with an extra newline at the end from using [writeln].
   if (lines.isNotEmpty && lines.last == "") {
     lines.removeLast();
   }
 
   var entry = new Entry(level, lines.map(format).toList());
@@ skipping 180 matching lines @@
   _numMutes++;
 }
 
 /// Resumes animating any ongoing progress once all calls to [muteProgress]
 /// have made their matching [unmuteProgress].
 void unmuteProgress() {
   assert(_numMutes > 0);
   _numMutes--;
 }
 
+/// Logs a collapsible [message].
+///
+/// If a number of collapsible messages are printed in short succession, they
+/// are collapsed to just showing the first one followed by a count of the
+/// elided ones. Avoids spamming the output with not-very-interesting output.
+///
+/// Internally, every time this is called, a time is set (or reset). When it
+/// fires, any collapsible messages enqueued since the last time it fired are
+/// displayed.
+void collapsible(String message) {

[nweiz, 2015/07/31 22:42:35]

Rather than only printing this once the timeout has elapsed, why not print it
immediately and use \r to dynamically update the hidden message count (at least
on non-Windows OSes)?

[Bob Nystrom, 2015/08/03 21:51:02]

I thought about that, but the output lines can be unexpectedly long and "\r"
gets super flaky in that case. I figured this would be simpler and more
reliable.

[nweiz, 2015/08/03 22:11:10]

Since this is pub, we should be able to safely use Stdout.terminalColumns to
check if that's possible. I'd really like to avoid just printing *no output* for
a long period of time.

[Bob Nystrom, 2015/08/05 21:25:39]

Tried a different approach based on our discussion.

+  // Only collapse messages when the output is not verbose.
+  if (verbosity._loggers[Level.MESSAGE] != _logToStdout) {
+    write(Level.MESSAGE, message);
+    return;
+  }
+
+  // Reset the timer.
+  if (_collapsibleTimer != null) _collapsibleTimer.cancel();
+
+  _collapsibleMessages.add(message);
+  _collapsibleTimer = new Timer(new Duration(milliseconds: 100),

[nweiz, 2015/07/31 22:42:35]

Consider making this duration a top-level constant.

[Bob Nystrom, 2015/08/03 21:51:02]

Done.

+      _flushCollapsible);
+}
+
+/// Displays any queued collapsible messages.
+void _flushCollapsible() {
+  if (_collapsibleMessages.isEmpty) return;
+
+  if (_collapsibleTimer != null) {
+    _collapsibleTimer.cancel();
+    _collapsibleTimer = null;
+  }
+
+  if (_collapsibleMessages.length == 1) {
+    message(_collapsibleMessages.single);
+  } else {
+    var trailing = gray("(and ${_collapsibleMessages.length - 1} more...)");
+    message("${_collapsibleMessages.first} $trailing");
+  }
+
+  _collapsibleMessages.clear();
+}
+
 /// Wraps [text] in the ANSI escape codes to make it bold when on a platform
 /// that supports that.
 ///
 /// Use this to highlight the most important piece of a long chunk of text.
 ///
 /// This is disabled under [withPrejudice] since all text is bold with
 /// prejudice.
 String bold(text) => withPrejudice ? text : "$_bold$text$_none";
 
 /// Wraps [text] in the ANSI escape codes to make it gray when on a platform
@@ skipping 116 matching lines @@
     this.message(errorJson);
   }
 
   /// Encodes [message] to JSON and prints it if JSON output is enabled.
   void message(message) {
     if (!enabled) return;
 
     print(JSON.encode(message));
   }
 }