Update charted to 0.4.8 and roll

packages/logging/lib/logging.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.
 
 /**
  */
 library logging;
 
 import 'dart:async';
 import 'dart:collection';
 
-/**
- * Whether to allow fine-grain logging and configuration of loggers in a
- * hierarchy. When false, all logging is merged in the root logger.
- */
+/// Whether to allow fine-grain logging and configuration of loggers in a
+/// hierarchy.
+///
+/// When false, all logging is merged in the root logger.
 bool hierarchicalLoggingEnabled = false;
 
-/**
- * Automatically record stack traces for any message of this level or above.
- * Because this is expensive, this is off by default.
- */
+/// Automatically record stack traces for any message of this level or above.
+///
+/// Because this is expensive, this is off by default.
 Level recordStackTraceAtLevel = Level.OFF;
 
-/**
- * Level for the root-logger. This will be the level of all loggers if
- * [hierarchicalLoggingEnabled] is false.
- */
+/// Level for the root-logger.
+///
+/// This will be the level of all loggers if [hierarchicalLoggingEnabled] is
+/// false.
 Level _rootLevel = Level.INFO;
 
 /**
- * Use a [Logger] to log debug messages. [Logger]s are named using a
- * hierarchical dot-separated name convention.
+ * Use a [Logger] to log debug messages.
+ *
+ * [Logger]s are named using a hierarchical dot-separated name convention.
  */
 class Logger {
   /** Simple name of this logger. */
   final String name;
 
   /** The full name of this logger, which includes the parent's full name. */
   String get fullName =>
       (parent == null || parent.name == '') ? name : '${parent.fullName}.$name';
 
   /** Parent of this logger in the hierarchy of loggers. */
@@ skipping 15 matching lines @@
    * actual instance whenever it is called with the same string name.
    */
   factory Logger(String name) {
     return _loggers.putIfAbsent(name, () => new Logger._named(name));
   }
 
   /// Creates a new detached [Logger].
   ///
   /// Returns a new [Logger] instance (unlike `new Logger`, which returns a
   /// [Logger] singleton), which doesn't have any parent or children,
-  /// and it's not a part of the global hierarchial loggers structure.
+  /// and is not a part of the global hierarchical loggers structure.
   ///
   /// It can be useful when you just need a local short-living logger,
   /// which you'd like to be garbage-collected later.
   factory Logger.detached(String name) {
     return new Logger._internal(name, null, new Map<String, Logger>());
   }
 
   factory Logger._named(String name) {
     if (name.startsWith('.')) {
       throw new ArgumentError("name shouldn't start with a '.'");
@@ skipping 37 matching lines @@
     } else {
       if (parent != null) {
         throw new UnsupportedError(
             'Please set "hierarchicalLoggingEnabled" to true if you want to '
             'change the level on a non-root logger.');
       }
       _rootLevel = value;
     }
   }
 
-  /**
-   * Returns an stream of messages added to this [Logger]. You can listen for
-   * messages using the standard stream APIs, for instance:
-   *    logger.onRecord.listen((record) { ... });
-   */
+  /// Returns a stream of messages added to this [Logger].
+  ///
+  /// You can listen for messages using the standard stream APIs, for instance:
+  ///
+  /// ```dart
+  /// logger.onRecord.listen((record) { ... });
+  /// ```
   Stream<LogRecord> get onRecord => _getStream();
 
   void clearListeners() {
     if (hierarchicalLoggingEnabled || parent == null) {
       if (_controller != null) {
         _controller.close();
         _controller = null;
       }
     } else {
       root.clearListeners();
     }
   }
 
   /** Whether a message for [value]'s level is loggable in this logger. */
   bool isLoggable(Level value) => (value >= level);
 
-  /**
-   * Adds a log record for a [message] at a particular [logLevel] if
-   * `isLoggable(logLevel)` is true.
-   *
-   * Use this method to create log entries for user-defined levels. To record a
-   * message at a predefined level (e.g. [Level.INFO], [Level.WARNING], etc) you
-   * can use their specialized methods instead (e.g. [info], [warning], etc).
-   *
-   * If [message] is a [Function], it will be lazy evaluated. Additionally, if
-   * [message] or its evaluated value is not a [String], then 'toString()' will
-   * be called on it and the result will be logged.
-   *
-   * The log record will contain a field for the zone in which this call was
-   * made.
-   * This can be advantagous if a log listener wants to handle records of
-   * different zones differently (e.g. group log records by http-request if each
-   * http-request handler runs in it's own zone).
-   */
+  /// Adds a log record for a [message] at a particular [logLevel] if
+  /// `isLoggable(logLevel)` is true.
+  ///
+  /// Use this method to create log entries for user-defined levels. To record a
+  /// message at a predefined level (e.g. [Level.INFO], [Level.WARNING], etc)
+  /// you can use their specialized methods instead (e.g. [info], [warning],
+  /// etc).
+  ///
+  /// If [message] is a [Function], it will be lazy evaluated. Additionally, if
+  /// [message] or its evaluated value is not a [String], then 'toString()' will
+  /// be called on the object and the result will be logged. The log record will
+  /// contain a field holding the original object.
+  ///
+  /// The log record will also contain a field for the zone in which this call
+  /// was made. This can be advantageous if a log listener wants to handler
+  /// records of different zones differently (e.g. group log records by HTTP
+  /// request if each HTTP request handler runs in it's own zone).
   void log(Level logLevel, message,
       [Object error, StackTrace stackTrace, Zone zone]) {
+    Object object;
     if (isLoggable(logLevel)) {
       if (message is Function) message = message();
-      if (message is! String) message = message.toString();
+      if (message is! String) {
+        object = message;
+        message = message.toString();
+      }
       if (stackTrace == null && logLevel >= recordStackTraceAtLevel) {
         try {
           throw "autogenerated stack trace for $logLevel $message";
         } catch (e, t) {
           stackTrace = t;
           if (error == null) error = e;
         }
       }
       if (zone == null) zone = Zone.current;
 
-      var record =
-          new LogRecord(logLevel, message, fullName, error, stackTrace, zone);
+      var record = new LogRecord(
+          logLevel, message, fullName, error, stackTrace, zone, object);
 
       if (hierarchicalLoggingEnabled) {
         var target = this;
         while (target != null) {
           target._publish(record);
           target = target.parent;
         }
       } else {
         root._publish(record);
       }
@@ skipping 136 matching lines @@
 }
 
 /**
  * A log entry representation used to propagate information from [Logger] to
  * individual [Handler]s.
  */
 class LogRecord {
   final Level level;
   final String message;
 
+  /** Non-string message passed to Logger. */
+  final Object object;
+
   /** Logger where this record is stored. */
   final String loggerName;
 
   /** Time when this record was created. */
   final DateTime time;
 
   /** Unique sequence number greater than all log records created before it. */
   final int sequenceNumber;
 
   static int _nextNumber = 0;
 
   /** Associated error (if any) when recording errors messages. */
   final Object error;
 
   /** Associated stackTrace (if any) when recording errors messages. */
   final StackTrace stackTrace;
 
   /** Zone of the calling code which resulted in this LogRecord. */
   final Zone zone;
 
   LogRecord(this.level, this.message, this.loggerName,
-      [this.error, this.stackTrace, this.zone])
+      [this.error, this.stackTrace, this.zone, this.object])
       : time = new DateTime.now(),
         sequenceNumber = LogRecord._nextNumber++;
 
   String toString() => '[${level.name}] $loggerName: $message';
 }