Minimal initial performance reporting

pkg/analysis_server/lib/src/get_handler.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 analysis_server.src.get_handler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 11 matching lines @@
 import 'package:analysis_server/src/services/index/store/split_store.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/src/status/ast_writer.dart';
 import 'package:analysis_server/src/status/element_writer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_general.dart';
 
 import 'analysis_server.dart';
 
 /**
  * A function that can be used to generate HTML output into the given [buffer].
  * The HTML that is generated must be valid (special characters must already be
  * encoded).
  */
 typedef void HtmlGenerator(StringBuffer buffer);
 
 /**
  * Instances of the class [GetHandler] handle GET requests.
  */
 class GetHandler {
   /**
-   * The path used to request the status of the analysis server as a whole.
+   * The path used to request overall performance information.
    */
-  static const String STATUS_PATH = '/status';
+  static const String ANALYSIS_PERFORMANCE_PATH = '/perf/analysis';
 
   /**
    * The path used to request information about a element model.
    */
   static const String AST_PATH = '/ast';
 
   /**
    * The path used to request information about the cache entry corresponding
    * to a single file.
    */
   static const String CACHE_ENTRY_PATH = '/cache_entry';
 
   /**
    * The path used to request the list of source files in a certain cache
    * state.
    */
   static const String CACHE_STATE_PATH = '/cache_state';
 
   /**
    * The path used to request code completion information.
    */
   static const String COMPLETION_PATH = '/completion';
 
   /**
+   * The path used to request communication performance information.
+   */
+  static const String COMMUNICATION_PERFORMANCE_PATH = '/perf/communication';
+
+  /**
    * The path used to request information about a specific context.
    */
   static const String CONTEXT_PATH = '/context';
 
   /**
    * The path used to request information about a element model.
    */
   static const String ELEMENT_PATH = '/element';
 
   /**
    * The path used to request information about elements with the given name.
    */
   static const String INDEX_ELEMENT_BY_NAME = '/index/element-by-name';
 
   /**
    * The path used to request an overlay contents.
    */
   static const String OVERLAY_PATH = '/overlay';
 
   /**
    * The path used to request overlays information.
    */
   static const String OVERLAYS_PATH = '/overlays';
 
   /**
-   * The path used to request overall performance information.
+   * The path used to request the status of the analysis server as a whole.
    */
-  static const String PERFORMANCE_PATH = '/performance';
-
-  /**
-   * Query parameter used to represent the cache state to search for, when
-   * accessing [CACHE_STATE_PATH].
-   */
-  static const String STATE_QUERY_PARAM = 'state';
+  static const String STATUS_PATH = '/status';
 
   /**
    * Query parameter used to represent the context to search for, when
    * accessing [CACHE_ENTRY_PATH] or [CACHE_STATE_PATH].
    */
   static const String CONTEXT_QUERY_PARAM = 'context';
 
   /**
    * Query parameter used to represent the descriptor to search for, when
    * accessing [CACHE_STATE_PATH].
@@ skipping 10 matching lines @@
    * accessing [INDEX_ELEMENT_BY_NAME].
    */
   static const String INDEX_ELEMENT_NAME = 'name';
 
   /**
    * Query parameter used to represent the source to search for, when accessing
    * [CACHE_ENTRY_PATH].
    */
   static const String SOURCE_QUERY_PARAM = 'entry';
 
+  /**
+   * Query parameter used to represent the cache state to search for, when
+   * accessing [CACHE_STATE_PATH].
+   */
+  static const String STATE_QUERY_PARAM = 'state';
+
   static final ContentType _htmlContent =
       new ContentType("text", "html", charset: "utf-8");
 
   /**
    * The socket server whose status is to be reported on.
    */
   SocketServer _server;
 
   /**
    * Buffer containing strings printed by the analysis server.
@@ skipping 25 matching lines @@
         orElse: () => null);
   }
 
   /**
    * Handle a GET request received by the HTTP server.
    */
   void handleGetRequest(HttpRequest request) {
     String path = request.uri.path;
     if (path == STATUS_PATH) {
       _returnServerStatus(request);
+    } else if (path == ANALYSIS_PERFORMANCE_PATH) {
+      _returnAnalysisPerformance(request);
     } else if (path == AST_PATH) {
       _returnAst(request);
     } else if (path == CACHE_STATE_PATH) {
       _returnCacheState(request);
     } else if (path == CACHE_ENTRY_PATH) {
       _returnCacheEntry(request);
     } else if (path == COMPLETION_PATH) {
       _returnCompletionInfo(request);
+    } else if (path == COMMUNICATION_PERFORMANCE_PATH) {
+      _returnCommunicationPerformance(request);
     } else if (path == CONTEXT_PATH) {
       _returnContextInfo(request);
     } else if (path == ELEMENT_PATH) {
       _returnElement(request);
     } else if (path == INDEX_ELEMENT_BY_NAME) {
       _returnIndexElementByName(request);
     } else if (path == OVERLAY_PATH) {
       _returnOverlayContents(request);
     } else if (path == OVERLAYS_PATH) {
       _returnOverlaysInfo(request);
-    } else if (path == PERFORMANCE_PATH) {
-      _returnPerformance(request);
     } else {
       _returnUnknownRequest(request);
     }
   }
 
   /**
    * Return the folder being managed by the given [analysisServer] that matches
    * the given [contextFilter], or `null` if there is none.
    */
   Folder _findFolder(AnalysisServer analysisServer, String contextFilter) {
@@ skipping 26 matching lines @@
       AnalysisContext context) {
     for (Folder folder in folderMap.keys) {
       if (folderMap[folder] == context) {
         return folder;
       }
     }
     return null;
   }
 
   /**
+   * Return a response displaying overall performance information.
+   */
+  void _returnAnalysisPerformance(HttpRequest request) {
+    AnalysisServer analysisServer = _server.analysisServer;
+    if (analysisServer == null) {
+      return _returnFailure(request, 'Analysis server is not running');
+    }
+    _writeResponse(request, (StringBuffer buffer) {
+      _writePage(
+          buffer,
+          'Analysis Server - Analysis Performance',
+          [],
+          (StringBuffer buffer) {
+        void writeRow(TimeCounter counter, String label) {
+          _writeRow(buffer, [counter.result, label], classes: ["right", null]);
+        }
+
+        buffer.write('<h3>Analysis Performance</h3>');
+        buffer.write('<p><b>Time spent in each phase of analysis</b></p>');
+        buffer.write(
+            '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
+        _writeRow(buffer, ['Time (in ms)', 'Analysis Phase'], header: true);
+        writeRow(PerformanceStatistics.io, 'io');
+        writeRow(PerformanceStatistics.scan, 'scan');
+        writeRow(PerformanceStatistics.parse, 'parse');
+        writeRow(PerformanceStatistics.resolve, 'resolve');
+        writeRow(PerformanceStatistics.errors, 'errors');
+        writeRow(PerformanceStatistics.hints, 'hints');
+        writeRow(PerformanceStatistics.lint, 'lint');
+        buffer.write('</table>');
+
+        Map<DataDescriptor, int> countMap = SourceEntry.unflushedCountMap;
+        buffer.write('<p><b>Number of times flushed data was re-created</b></p>');
+        if (countMap.isEmpty) {
+          buffer.write('<p>none</p>');
+        } else {
+          List<DataDescriptor> keys = countMap.keys.toList();
+          keys.sort(
+              (DataDescriptor first, DataDescriptor second) =>
+                  first.toString().compareTo(second.toString()));
+          buffer.write(
+              '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
+          _writeRow(buffer, ['Count', 'Data'], header: true);
+          for (DataDescriptor key in keys) {
+            _writeRow(
+                buffer,
+                [countMap[key], key.toString()],
+                classes: ["right", null]);
+          }
+          buffer.write('</table>');
+        }
+      });
+    });
+  }
+
+  /**
    * Return a response containing information about an AST structure.
    */
   void _returnAst(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server not running');
     }
     String contextFilter = request.uri.queryParameters[CONTEXT_QUERY_PARAM];
     if (contextFilter == null) {
       return _returnFailure(
@@ skipping 233 matching lines @@
         buffer.write('<ul>');
         links.forEach((String link) {
           buffer.write('<li>$link</li>');
         });
         buffer.write('</ul>');
       });
     });
   }
 
   /**
+   * Return a response displaying overall performance information.
+   */
+  void _returnCommunicationPerformance(HttpRequest request) {
+    AnalysisServer analysisServer = _server.analysisServer;
+    if (analysisServer == null) {
+      return _returnFailure(request, 'Analysis server is not running');
+    }
+    _writeResponse(request, (StringBuffer buffer) {
+      _writePage(
+          buffer,
+          'Analysis Server - Communication Performance',
+          [],
+          (StringBuffer buffer) {
+        buffer.write('<h3>Communication Performance</h3>');
+        _writeTwoColumns(buffer, (StringBuffer buffer) {
+          ServerPerformance perf = analysisServer.performanceDuringStartup;
+          int requestCount = perf.requestCount;
+          num averageLatency =
+              requestCount > 0 ? (perf.requestLatency / requestCount).round() : 0;
+          int maximumLatency = perf.maxLatency;
+          num slowRequestPercent =
+              requestCount > 0 ? (perf.slowRequestCount * 100 / requestCount).round() : 0;
+          buffer.write('<h4>Startup</h4>');
+          buffer.write('<table>');
+          _writeRow(
+              buffer,
+              [requestCount, 'requests'],
+              classes: ["right", null]);
+          _writeRow(
+              buffer,
+              [averageLatency, 'ms average latency'],
+              classes: ["right", null]);
+          _writeRow(
+              buffer,
+              [maximumLatency, 'ms maximum latency'],
+              classes: ["right", null]);
+          _writeRow(
+              buffer,
+              [slowRequestPercent, '% > 150 ms latency'],
+              classes: ["right", null]);
+          if (analysisServer.performanceAfterStartup != null) {
+            int startupTime =
+                analysisServer.performanceAfterStartup.startTime -
+                perf.startTime;
+            _writeRow(
+                buffer,
+                [startupTime, 'ms for initial analysis to complete']);
+          }
+          buffer.write('</table>');
+        }, (StringBuffer buffer) {
+          ServerPerformance perf = analysisServer.performanceAfterStartup;
+          if (perf == null) {
+            return;
+          }
+          int requestCount = perf.requestCount;
+          num averageLatency =
+              requestCount > 0 ? (perf.requestLatency * 10 / requestCount).round() / 10 : 0;
+          int maximumLatency = perf.maxLatency;
+          num slowRequestPercent =
+              requestCount > 0 ? (perf.slowRequestCount * 100 / requestCount).round() : 0;
+          buffer.write('<h4>Current</h4>');
+          buffer.write('<table>');
+          _writeRow(
+              buffer,
+              [requestCount, 'requests'],
+              classes: ["right", null]);
+          _writeRow(
+              buffer,
+              [averageLatency, 'ms average latency'],
+              classes: ["right", null]);
+          _writeRow(
+              buffer,
+              [maximumLatency, 'ms maximum latency'],
+              classes: ["right", null]);
+          _writeRow(
+              buffer,
+              [slowRequestPercent, '% > 150 ms latency'],
+              classes: ["right", null]);
+          buffer.write('</table>');
+        });
+      });
+    });
+  }
+
+  /**
    * Return a response displaying code completion information.
    */
   void _returnCompletionInfo(HttpRequest request) {
     String value = request.requestedUri.queryParameters['index'];
     int index = value != null ? int.parse(value, onError: (_) => 0) : 0;
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(
           buffer,
           'Analysis Server - Completion Stats',
           [],
@@ skipping 294 matching lines @@
             _overlayContents[count] = contents;
           });
         });
         buffer.write('<tr><td colspan="2">Total: $count entries.</td></tr>');
         buffer.write('</table>');
       });
     });
   }
 
   /**
-   * Return a response displaying overall performance information.
-   */
-  void _returnPerformance(HttpRequest request) {
-    AnalysisServer analysisServer = _server.analysisServer;
-    if (analysisServer == null) {
-      return _returnFailure(request, 'Analysis server is not running');
-    }
-    _writeResponse(request, (StringBuffer buffer) {
-      _writePage(
-          buffer,
-          'Analysis Server - Performance',
-          [],
-          (StringBuffer buffer) {
-        buffer.write('<h3>Communication Performance</h3>');
-        _writeTwoColumns(buffer, (StringBuffer buffer) {
-          ServerPerformance perf = analysisServer.performanceDuringStartup;
-          int requestCount = perf.requestCount;
-          num averageLatency =
-              requestCount > 0 ? (perf.requestLatency / requestCount).round() : 0;
-          int maximumLatency = perf.maxLatency;
-          num slowRequestPercent =
-              requestCount > 0 ? (perf.slowRequestCount * 100 / requestCount).round() : 0;
-          buffer.write('<h4>Startup</h4>');
-          buffer.write('<table>');
-          _writeRow(
-              buffer,
-              [requestCount, 'requests'],
-              classes: ["right", null]);
-          _writeRow(
-              buffer,
-              [averageLatency, 'ms average latency'],
-              classes: ["right", null]);
-          _writeRow(
-              buffer,
-              [maximumLatency, 'ms maximum latency'],
-              classes: ["right", null]);
-          _writeRow(
-              buffer,
-              [slowRequestPercent, '% > 150 ms latency'],
-              classes: ["right", null]);
-          if (analysisServer.performanceAfterStartup != null) {
-            int startupTime =
-                analysisServer.performanceAfterStartup.startTime -
-                perf.startTime;
-            _writeRow(
-                buffer,
-                [startupTime, 'ms for initial analysis to complete']);
-          }
-          buffer.write('</table>');
-        }, (StringBuffer buffer) {
-          ServerPerformance perf = analysisServer.performanceAfterStartup;
-          if (perf == null) {
-            return;
-          }
-          int requestCount = perf.requestCount;
-          num averageLatency =
-              requestCount > 0 ? (perf.requestLatency * 10 / requestCount).round() / 10 : 0;
-          int maximumLatency = perf.maxLatency;
-          num slowRequestPercent =
-              requestCount > 0 ? (perf.slowRequestCount * 100 / requestCount).round() : 0;
-          buffer.write('<h4>Current</h4>');
-          buffer.write('<table>');
-          _writeRow(
-              buffer,
-              [requestCount, 'requests'],
-              classes: ["right", null]);
-          _writeRow(
-              buffer,
-              [averageLatency, 'ms average latency'],
-              classes: ["right", null]);
-          _writeRow(
-              buffer,
-              [maximumLatency, 'ms maximum latency'],
-              classes: ["right", null]);
-          _writeRow(
-              buffer,
-              [slowRequestPercent, '% > 150 ms latency'],
-              classes: ["right", null]);
-          buffer.write('</table>');
-        });
-      });
-    });
-  }
-
-  /**
    * Return a response indicating the status of the analysis server.
    */
   void _returnServerStatus(HttpRequest request) {
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Status', [], (StringBuffer buffer) {
         if (_writeServerStatus(buffer)) {
           _writeAnalysisStatus(buffer);
           _writeEditStatus(buffer);
           _writeExecutionStatus(buffer);
           _writeRecentOutput(buffer);
         }
       });
     });
   }
 
   /**
    * Return an error in response to an unrecognized request received by the HTTP
    * server.
    */
   void _returnUnknownRequest(HttpRequest request) {
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server', [], (StringBuffer buffer) {
         buffer.write('<h3>Pages</h3>');
         buffer.write('<p>');
         buffer.write(makeLink(COMPLETION_PATH, {}, 'Completion data'));
         buffer.write('</p>');
         buffer.write('<p>');
-        buffer.write(makeLink(PERFORMANCE_PATH, {}, 'Performance'));
+        buffer.write(
+            makeLink(COMMUNICATION_PERFORMANCE_PATH, {}, 'Performance'));
         buffer.write('</p>');
         buffer.write('<p>');
         buffer.write(makeLink(STATUS_PATH, {}, 'Server status'));
         buffer.write('</p>');
       });
     });
   }
 
   /**
    * Return a two digit decimal representation of the given non-negative integer
@@ skipping 71 matching lines @@
           options.incrementalApi);
       _writeOption(
           buffer,
           'Preserve comments',
           options.preserveComments,
           last: true);
       buffer.write('</p>');
       int freq = AnalysisServer.performOperationDelayFreqency;
       String delay = freq > 0 ? '1 ms every $freq ms' : 'off';
       buffer.write('<p><b>perform operation delay:</b> $delay</p>');
+
+      buffer.write('<p><b>Performance Data</b></p>');
+      buffer.write('<p>');
+      buffer.write(makeLink(ANALYSIS_PERFORMANCE_PATH, {}, 'Task data'));
+      buffer.write('</p>');
     }, (StringBuffer buffer) {
       _writeSubscriptionMap(
           buffer,
           AnalysisService.VALUES,
           analysisServer.analysisServices);
     });
   }
 
   /**
    * Write performance information about a specific completion request
@@ skipping 367 matching lines @@
       } else {
         buffer.write('Inactive');
       }
       buffer.write('<br>');
       buffer.write('Version: ');
       buffer.write(AnalysisServer.VERSION);
       buffer.write('</p>');
 
       buffer.write('<p><b>Performance Data</b></p>');
       buffer.write('<p>');
-      buffer.write(makeLink(PERFORMANCE_PATH, {}, 'Communication performance'));
+      buffer.write(
+          makeLink(COMMUNICATION_PERFORMANCE_PATH, {}, 'Communication performance'));
       buffer.write('</p>');
     }, (StringBuffer buffer) {
       _writeSubscriptionList(buffer, ServerService.VALUES, services);
     });
     return true;
   }
 
   /**
    * Write a representation of the given [stackTrace] to the given [buffer].
    */
@@ skipping 133 matching lines @@
    * 'error'.
    */
   static String makeLink(String path, Map<String, String> params,
       String innerHtml, [bool hasError = false]) {
     Uri uri = new Uri(path: path, queryParameters: params);
     String href = HTML_ESCAPE.convert(uri.toString());
     String classAttribute = hasError ? ' class="error"' : '';
     return '<a href="$href"$classAttribute>$innerHtml</a>';
   }
 }