Polymer transformer logs now show on the frontend for pub serve.

pkg/polymer/lib/src/build/wrapped_logger.dart

Index: pkg/polymer/lib/src/build/wrapped_logger.dart
diff --git a/pkg/polymer/lib/src/build/wrapped_logger.dart b/pkg/polymer/lib/src/build/wrapped_logger.dart
new file mode 100644
index 0000000000000000000000000000000000000000..aca6c342d4f508bcf3af197ad8a8846850ecfd32
--- /dev/null
+++ b/pkg/polymer/lib/src/build/wrapped_logger.dart
@@ -0,0 +1,100 @@
+library polymer.src.build.wrapped_logger;

[Siggi Cherem (dart-lang), 2014/08/01 21:48:29]

+ copyright here too

[jakemac, 2014/08/04 19:49:59]

Done.

+
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:barback/barback.dart';
+
+import 'common.dart' as common;
+
+/// A simple class to wrap one TransformLogger with another one that writes all
+/// logs to a file and then forwards the calls to the child.
+class WrappedLogger implements TransformLogger {
+  Transform _transform;
+  List<Map> _logs = new List<Map>();
+
+  bool convertErrorsToWarnings;
+
+  WrappedLogger(this._transform, {this.convertErrorsToWarnings: false});
+
+  void info(String message, {AssetId asset, Span span}) {
+    _transform.logger.info(message, asset: asset, span: span);
+    _addLog(asset, LogLevel.INFO, message, span);
+  }
+
+  void fine(String message, {AssetId asset, Span span}) {
+    _transform.logger.fine(message, asset: asset, span: span);
+    _addLog(asset, LogLevel.FINE, message, span);
+  }
+
+  void warning(String message, {AssetId asset, Span span}) {
+    _transform.logger.warning(message, asset: asset, span: span);
+    _addLog(asset, LogLevel.WARNING, message, span);
+  }
+
+  void error(String message, {AssetId asset, Span span}) {
+    if (convertErrorsToWarnings) {
+      _transform.logger.warning(message, asset: asset, span: span);
+    } else {
+      _transform.logger.error(message, asset: asset, span: span);
+    }
+    _addLog(asset, LogLevel.ERROR, message, span);
+  }
+
+  /// Outputs the log data to a JSON serialized file.
+  Future writeOutput() {
+    return getNextLogAssetPath().then((path) {
+      _transform.addOutput(new Asset.fromString(path, JSON.encode(_logs)));
+    });
+  }
+
+  // Each phase outputs a new log file with an incrementing # appended, this
+  // figures out the next # to use.

[Siggi Cherem (dart-lang), 2014/08/01 21:31:53]

include a TODO that this is a workaround because of a bug in aggregate
transformers?  maybe include a link to the actual bug?

[jakemac, 2014/08/04 19:49:59]

This just seemed easier to work with, I started going down the
AggregateTransformer route but I would have ended up making all our transforms
AggregateTransforms and was simpler to just keep the logic all within this
class. Technically I did have to create the extra transform at the end as well
though.... maybe we should talk offline about it.

+  Future<String> getNextLogAssetPath([int nextNumber = 1]) {
+    var nextAssetPath = _transform.primaryInput.id.addExtension(
+        '${common.LOG_EXTENSION}.$nextNumber');
+    return _transform.hasInput(nextAssetPath).then((exists) {
+      if (!exists) return nextAssetPath;
+      return getNextLogAssetPath(++nextNumber);

[Siggi Cherem (dart-lang), 2014/08/01 21:31:53]

interesting ... another idea, but I'm not convinced if what I'm suggesting is
any better, so totally up to you.

we could have an enum of number IDs we expect to use (one per phase). Then the
name would be fixed:

  import_inliner  always generates file._buildLog.3

so you wouldn't need to find what is the next available log. 

Below, combine would have to check every fixed Id, rather than iterating until a
number doesn't exist. 

[jakemac, 2014/08/04 19:49:59]

I think I like just the incrementing number approach since it means we don't
have to update anything here to add this logger to different transforms. I
looked briefly and it doesn't look like calling hasInput actually attempts to
read a file from disk or anything, its just looking up an ID in a map so it
should be really quick. 

+    });
+  }
+
+  // Combines all existing ._buildLogs.* files into a single ._buildLogs file.
+  static Future combineLogFiles(
+      Transform transform, [int nextNumber = 1, List<Map> logs]) {
+    if (logs == null) logs = new List<Map>();
+    var primaryInputId = transform.primaryInput.id;
+    var nextAssetPath =
+        primaryInputId.addExtension('${common.LOG_EXTENSION}.$nextNumber');
+    return transform.readInputAsString(nextAssetPath).then(
+        (data) {
+          logs.addAll(JSON.decode(data));
+          return combineLogFiles(transform, ++nextNumber, logs);
+        },
+        onError: (_) {
+          transform.addOutput(new Asset.fromString(
+              primaryInputId.addExtension(common.LOG_EXTENSION),
+              JSON.encode(logs)));
+        });
+  }
+
+  void _addLog(AssetId assetId, LogLevel level, String message, Span span) {
+    var data = {
+        'level': level.name,
+        'message': message,
+    };
+    if (assetId != null) {
+      data['assetId'] = {
+          'package': assetId.package,
+          'path': assetId.path,
+      };
+    }
+    if (span != null) {
+      data['span'] = {
+          'location': span.formatLocation,
+          'text': new HtmlEscape().convert(span.text),
+      };
+    }
+    _logs.add(data);
+  }
+}