Make instrumentation data structure more regular

pkg/analysis_server/tool/instrumentation/log/log.dart

 // Copyright (c) 2016, 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.
 
 /**
  * A representation of the contents of an instrumentation log.
  */
 import 'dart:convert';
 import 'dart:math' as math;
 
@@ skipping 144 matching lines @@
   void _appendDetails(StringBuffer buffer) {
     super._appendDetails(buffer);
     for (String component in components) {
       buffer.write(component);
       buffer.write('<br>');
     }
   }
 }
 
 /**
+ * A log entry representing an PluginErr entry.
+ */
+class GenericPluginEntry extends GenericEntry with PluginEntryMixin {
+  /**
+   * The components describing the plugin associated with this entry.
+   */
+  final List<String> pluginData;
+
+  /**
+   * Initialize a newly created log entry.
+   */
+  GenericPluginEntry(int index, int timeStamp, String entryKind,
+      List<String> components, this.pluginData)
+      : super(index, timeStamp, entryKind, components);
+}
+
+/**
  * A representation of an instrumentation log.
  */
 class InstrumentationLog {
   /**
    * The paths of the log files containing the entries.
    */
   List<String> logFilePaths;
 
   /**
    * The entries in the instrumentation log.
@@ skipping 369 matching lines @@
         _format(buffer, newIndent, element);
         buffer.write('<br>');
       });
       buffer.write(indent);
       buffer.write(']');
     }
   }
 }
 
 /**
+ * A log entry representing a communication between the server and a plugin.
+ */
+abstract class JsonBasedPluginEntry extends JsonBasedEntry
+    with PluginEntryMixin {
+  /**
+   * The components describing the plugin associated with this entry.
+   */
+  final List<String> pluginData;
+
+  /**
+   * Initialize a newly created entry to have the given [timeStamp] and
+   * [notificationData] and to be associated with the plugin with the given
+   * [pluginData].
+   */
+  JsonBasedPluginEntry(
+      int index, int timeStamp, Map notificationData, this.pluginData)
+      : super(index, timeStamp, notificationData);
+}
+
+/**
  * A single entry in an instrumentation log.
  */
 abstract class LogEntry {
   /**
    * The character used to separate fields within an entry.
    */
   static final int fieldSeparator = ':'.codeUnitAt(0);
 
   /**
    * A regular expression that will match the beginning of a valid log entry.
@@ skipping 68 matching lines @@
       } else if (entryKind == InstrumentationService.TAG_FILE_READ) {
         // Fall through
       } else if (entryKind == InstrumentationService.TAG_LOG_ENTRY) {
         // Fall through
       } else if (entryKind == InstrumentationService.TAG_NOTIFICATION) {
         Map requestData = JSON.decode(components[2]);
         return new NotificationEntry(index, timeStamp, requestData);
       } else if (entryKind == InstrumentationService.TAG_PERFORMANCE) {
         // Fall through
       } else if (entryKind == InstrumentationService.TAG_PLUGIN_ERROR) {
-        return new PluginErrorEntry(
-            index, timeStamp, entryKind, components[2], components.sublist(3));
+        return new PluginErrorEntry(index, timeStamp, entryKind,
+            components.sublist(2, 4), components.sublist(4));
       } else if (entryKind == InstrumentationService.TAG_PLUGIN_EXCEPTION) {
-        return new PluginExceptionEntry(
-            index, timeStamp, entryKind, components[2], components.sublist(3));
+        return new PluginExceptionEntry(index, timeStamp, entryKind,
+            components.sublist(2, 5), components.sublist(5));
       } else if (entryKind == InstrumentationService.TAG_PLUGIN_NOTIFICATION) {
-        Map requestData = JSON.decode(components[3]);
+        Map requestData = JSON.decode(components[2]);
         return new PluginNotificationEntry(
-            index, timeStamp, components[2], requestData);
+            index, timeStamp, requestData, components.sublist(3));
       } else if (entryKind == InstrumentationService.TAG_PLUGIN_REQUEST) {
-        Map requestData = JSON.decode(components[3]);
+        Map requestData = JSON.decode(components[2]);
         return new PluginRequestEntry(
-            index, timeStamp, components[2], requestData);
+            index, timeStamp, requestData, components.sublist(3));
       } else if (entryKind == InstrumentationService.TAG_PLUGIN_RESPONSE) {
-        Map responseData = JSON.decode(components[3]);
+        Map responseData = JSON.decode(components[2]);
         return new PluginResponseEntry(
-            index, timeStamp, components[2], responseData);
+            index, timeStamp, responseData, components.sublist(3));
       } else if (entryKind == InstrumentationService.TAG_PLUGIN_TIMEOUT) {
-        return new PluginErrorEntry(
-            index, timeStamp, entryKind, components[2], components.sublist(3));
+        return new PluginErrorEntry(index, timeStamp, entryKind,
+            components.sublist(2, 3), components.sublist(3));
       } else if (entryKind == InstrumentationService.TAG_REQUEST) {
         Map requestData = JSON.decode(components[2]);
         return new RequestEntry(index, timeStamp, requestData);
       } else if (entryKind == InstrumentationService.TAG_RESPONSE) {
         Map responseData = JSON.decode(components[2]);
         return new ResponseEntry(index, timeStamp, responseData);
       } else if (entryKind == InstrumentationService.TAG_SUBPROCESS_START) {
         // Fall through
       } else if (entryKind == InstrumentationService.TAG_SUBPROCESS_RESULT) {
         // Fall through
@@ skipping 154 matching lines @@
     if (parameters is Map) {
       return parameters[parameterName];
     }
     return null;
   }
 }
 
 /**
  * A log entry representing a communication between the server and a plugin.
  */
-abstract class PluginEntry extends JsonBasedEntry with PluginEntryMixin {
-  /**
-   * The id of the plugin being communicated with.
-   */
-  final String pluginId;
-
-  /**
-   * Initialize a newly created entry to have the given [timeStamp] and
-   * [notificationData] and to be associated with the plugin with the given
-   * [pluginId].
-   */
-  PluginEntry(int index, int timeStamp, this.pluginId, Map notificationData)
-      : super(index, timeStamp, notificationData);
-}
-
-/**
- * A log entry representing a communication between the server and a plugin.
- */
 abstract class PluginEntryMixin {
   /**
-   * The id of the plugin being communicated with.
+   * The components describing the plugin associated with this entry.
    */
-  String get pluginId;
+  List<String> get pluginData;
+
+  /**
+   * The id of the plugin associated with this entry.
+   */
+  String get pluginId => pluginData[0];
+
+  /**
+   * The name of the plugin associated with this entry.
+   */
+  String get pluginName => pluginData[1];
+
+  /**
+   * The version of the plugin associated with this entry.
+   */
+  String get pluginVersion => pluginData[2];
 
   /**
    * Return a shortened version of the plugin id.
    */
   String get shortPluginId {
     int index = pluginId.lastIndexOf(path.separator);
     if (index > 0) {
       return pluginId.substring(index + 1);
     }
     return pluginId;
   }
 }
 
 /**
  * A log entry representing an PluginErr entry.
  */
-class PluginErrorEntry extends GenericEntry with PluginEntryMixin {
-  /**
-   * The id of the plugin that generated the error.
-   */
-  final String pluginId;
-
+class PluginErrorEntry extends GenericPluginEntry {
   /**
    * Initialize a newly created log entry.
    */
-  PluginErrorEntry(int index, int timeStamp, String entryKind, this.pluginId,
-      List<String> components)
-      : super(index, timeStamp, entryKind, components);
+  PluginErrorEntry(int index, int timeStamp, String entryKind,
+      List<String> components, List<String> pluginData)
+      : super(index, timeStamp, entryKind, components, pluginData);
 }
 
 /**
  * A log entry representing an PluginEx entry.
  */
-class PluginExceptionEntry extends GenericEntry with PluginEntryMixin {
-  /**
-   * The id of the plugin that generated the exception.
-   */
-  final String pluginId;
-
+class PluginExceptionEntry extends GenericPluginEntry {
   /**
    * Initialize a newly created log entry.
    */
   PluginExceptionEntry(int index, int timeStamp, String entryKind,
-      this.pluginId, List<String> components)
-      : super(index, timeStamp, entryKind, components);
+      List<String> components, List<String> pluginData)
+      : super(index, timeStamp, entryKind, components, pluginData);
 }
 
 /**
  * A log entry representing a notification that was sent from a plugin to the
  * server.
  */
-class PluginNotificationEntry extends PluginEntry {
+class PluginNotificationEntry extends JsonBasedPluginEntry {
   /**
    * Initialize a newly created notification to have the given [timeStamp] and
    * [notificationData].
    */
   PluginNotificationEntry(
-      int index, int timeStamp, String pluginId, Map notificationData)
-      : super(index, timeStamp, pluginId, notificationData);
+      int index, int timeStamp, Map notificationData, List<String> pluginData)
+      : super(index, timeStamp, notificationData, pluginData);
 
   /**
    * Return the event field of the notification.
    */
   String get event => data['event'];
 
   @override
   String get kind => 'PluginNoti';
 
   /**
    * Return the value of the parameter with the given [parameterName], or `null`
    * if there is no such parameter.
    */
   dynamic param(String parameterName) {
     var parameters = data['params'];
     if (parameters is Map) {
       return parameters[parameterName];
     }
     return null;
   }
 }
 
 /**
  * A log entry representing a request that was sent from the server to a plugin.
  */
-class PluginRequestEntry extends PluginEntry {
+class PluginRequestEntry extends JsonBasedPluginEntry {
   /**
    * Initialize a newly created response to have the given [timeStamp] and
    * [requestData].
    */
-  PluginRequestEntry(int index, int timeStamp, String pluginId, Map requestData)
-      : super(index, timeStamp, pluginId, requestData);
+  PluginRequestEntry(
+      int index, int timeStamp, Map requestData, List<String> pluginData)
+      : super(index, timeStamp, requestData, pluginData);
 
   /**
    * Return the id field of the request.
    */
   String get id => data['id'];
 
   @override
   String get kind => 'PluginReq';
 
   /**
@@ skipping 11 matching lines @@
       return parameters[parameterName];
     }
     return null;
   }
 }
 
 /**
  * A log entry representing a response that was sent from a plugin to the
  * server.
  */
-class PluginResponseEntry extends PluginEntry {
+class PluginResponseEntry extends JsonBasedPluginEntry {
   /**
    * Initialize a newly created response to have the given [timeStamp] and
    * [responseData].
    */
   PluginResponseEntry(
-      int index, int timeStamp, String pluginId, Map responseData)
-      : super(index, timeStamp, pluginId, responseData);
+      int index, int timeStamp, Map responseData, List<String> pluginData)
+      : super(index, timeStamp, responseData, pluginData);
 
   /**
    * Return the id field of the response.
    */
   String get id => data['id'];
 
   @override
   String get kind => 'PluginRes';
 
   /**
@@ skipping 162 matching lines @@
     int slash = context.lastIndexOf('/');
     if (slash < 0) {
       slash = context.lastIndexOf('\\');
     }
     if (slash >= 0) {
       String prefix = context.substring(0, slash);
       _target = _target.replaceAll(prefix, '...');
     }
   }
 }