Add support for reporting plugin data to instrumentation

pkg/analyzer/lib/instrumentation/instrumentation.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 analyzer.instrumentation.instrumentation;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/task/model.dart';
@@ skipping 57 matching lines @@
   static final InstrumentationService NULL_SERVICE =
       new InstrumentationService(null);
 
   static const String TAG_ANALYSIS_TASK = 'Task';
   static const String TAG_ERROR = 'Err';
   static const String TAG_EXCEPTION = 'Ex';
   static const String TAG_FILE_READ = 'Read';
   static const String TAG_LOG_ENTRY = 'Log';
   static const String TAG_NOTIFICATION = 'Noti';
   static const String TAG_PERFORMANCE = 'Perf';
+  static const String TAG_PLUGIN_ERROR = 'PluginErr';
+  static const String TAG_PLUGIN_EXCEPTION = 'PluginEx';
   static const String TAG_PLUGIN_NOTIFICATION = 'PluginNoti';
   static const String TAG_PLUGIN_REQUEST = 'PluginReq';
   static const String TAG_PLUGIN_RESPONSE = 'PluginRes';
+  static const String TAG_PLUGIN_TIMEOUT = 'PluginTo';
   static const String TAG_REQUEST = 'Req';
   static const String TAG_RESPONSE = 'Res';
   static const String TAG_SUBPROCESS_START = 'SPStart';
   static const String TAG_SUBPROCESS_RESULT = 'SPResult';
   static const String TAG_VERSION = 'Ver';
   static const String TAG_WATCH_EVENT = 'Watch';
 
   /**
    * The instrumentation server used to communicate with the server, or `null`
    * if instrumentation data should not be logged.
@@ skipping 106 matching lines @@
    */
   void logPerformance(String kind, Stopwatch sw, String message) {
     sw.stop();
     String elapsed = sw.elapsedMilliseconds.toString();
     if (_instrumentationServer != null) {
       _instrumentationServer
           .log(_join([TAG_PERFORMANCE, kind, elapsed, message]));
     }
   }
 
+  /**
+   * Log the fact that an error, described by the given [message], was reported
+   * by the given [plugin].
+   */
+  void logPluginError(
+      PluginData plugin, String code, String message, String stackTrace) {
+    List<String> fields = <String>[TAG_PLUGIN_ERROR];
+    fields.add(code ?? '');
+    fields.add(message ?? '');
+    fields.add(stackTrace ?? '');
+    plugin.addToFields(fields);
+    _instrumentationServer.log(_join(fields));

[scheglov, 2017/04/19 17:46:59]

Why don't we check for null in this method?

[Brian Wilkerson, 2017/04/19 18:01:13]

Done

+  }
+
+  /**
+   * Log that the given non-priority [exception] was thrown, with the given
+   * [stackTrace] by the given [plugin].
+   */
+  void logPluginException(
+      PluginData plugin, dynamic exception, StackTrace stackTrace) {
+    if (_instrumentationServer != null) {
+      List<String> fields = <String>[
+        TAG_PLUGIN_EXCEPTION,
+        _toString(exception),
+        _toString(stackTrace)
+      ];
+      plugin.addToFields(fields);
+      _instrumentationServer.log(_join(fields));
+    }
+  }
+
   void logPluginNotification(Uri pluginUri, String notification) {
     if (_instrumentationServer != null) {
       _instrumentationServer.log(
           _join([TAG_PLUGIN_NOTIFICATION, _toString(pluginUri), notification]));
     }
   }
 
   void logPluginRequest(Uri pluginUri, String request) {
     if (_instrumentationServer != null) {
       _instrumentationServer
           .log(_join([TAG_PLUGIN_REQUEST, _toString(pluginUri), request]));
     }
   }
 
   void logPluginResponse(Uri pluginUri, String response) {
     if (_instrumentationServer != null) {
       _instrumentationServer
           .log(_join([TAG_PLUGIN_RESPONSE, _toString(pluginUri), response]));
     }
   }
 
   /**
+   * Log that the given [plugin] took too long to execute the given [request].
+   */
+  void logPluginTimeout(PluginData plugin, String request) {
+    if (_instrumentationServer != null) {
+      List<String> fields = <String>[TAG_PLUGIN_TIMEOUT, request];
+      plugin.addToFields(fields);
+      _instrumentationServer.log(_join(fields));
+    }
+  }
+
+  /**
    * Log that the given priority [exception] was thrown, with the given
    * [stackTrace].
    */
   void logPriorityException(dynamic exception, StackTrace stackTrace) {
     if (_instrumentationServer != null) {
       String message = _toString(exception);
       String trace = _toString(stackTrace);
       _instrumentationServer
           .logWithPriority(_join([TAG_EXCEPTION, message, trace]));
     }
@@ skipping 182 matching lines @@
     }
   }
 
   @override
   Future shutdown() async {
     for (InstrumentationServer server in _servers) {
       await server.shutdown();
     }
   }
 }
+
+/**
+ * Information about a plugin.
+ */
+class PluginData {
+  /**
+   * The path to the plugin.
+   */
+  final String path;
+
+  /**
+   * The name of the plugin.
+   */
+  final String name;
+
+  /**
+   * The version of the plugin.
+   */
+  final String version;
+
+  /**
+   * Initialize a newly created set of data about a plugin.
+   */
+  PluginData(this.path, this.name, this.version);
+
+  /**
+   * Add the information about the plugin to the list of [fields] to be sent to
+   * the instrumentation server.
+   */
+  void addToFields(List<String> fields) {
+    fields.add(path);
+    if (name != null) {
+      fields.add(name);
+    }
+    if (version != null) {
+      fields.add(version);
+    }
+  }
+}