Diagnostic status reporting (#24932).

pkg/analysis_server/lib/src/status/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.status.get_handler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/domain_completion.dart';
+import 'package:analysis_server/src/domain_diagnostic.dart';
 import 'package:analysis_server/src/domain_execution.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_index.dart';
 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:analysis_server/src/utilities/average.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart' show AnalysisContextImpl;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide AnalysisCache, AnalysisContextImpl, AnalysisTask;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 51 matching lines @@
    * 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 diagnostic information.
+   */
+  static const String DIAGNOSTIC_PATH = '/diagnostic';
+
+  /**
    * 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';
 
   /**
@@ skipping 43 matching lines @@
   /**
    * 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");
 
   /**
+   * Rolling average of calls to get diagnostics.
+   */
+  Average _diagnosticCallAverage = new Average();
+
+  /**
    * The socket server whose status is to be reported on.
    */
   SocketServer _server;
 
   /**
    * Buffer containing strings printed by the analysis server.
    */
   List<String> _printBuffer;
 
   /**
@@ skipping 34 matching lines @@
     } 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 == DIAGNOSTIC_PATH) {
+      _returnDiagnosticInfo(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 {
       _returnUnknownRequest(request);
@@ skipping 830 matching lines @@
         } else {
           exceptions.forEach((CaughtException exception) {
             _writeException(buffer, exception);
           });
         }
       });
     });
   }
 
   /**
+   * Return a response displaying diagnostic information.
+   */
+  void _returnDiagnosticInfo(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 - Diagnostic info', [],
+          (StringBuffer buffer) {
+        _writeDiagnosticStatus(buffer);
+      });
+    });
+  }
+
+  /**
    * Return a response containing information about an element structure.
    */
   void _returnElement(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 136 matching lines @@
   }
 
   /**
    * 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);
+          _writeDiagnosticStatus(buffer);
           _writeEditStatus(buffer);
           _writeExecutionStatus(buffer);
           _writePluginStatus(buffer);
           _writeRecentOutput(buffer);
         }
       });
     });
   }
 
   /**
@@ skipping 10 matching lines @@
         buffer.write('<p>');
         buffer
             .write(makeLink(COMMUNICATION_PERFORMANCE_PATH, {}, 'Performance'));
         buffer.write('</p>');
         buffer.write('<p>');
         buffer.write(makeLink(STATUS_PATH, {}, 'Server status'));
         buffer.write('</p>');
         buffer.write('<p>');
         buffer.write(makeLink(OVERLAYS_PATH, {}, 'File overlays'));
         buffer.write('</p>');
+        buffer.write('<p>');
+        buffer.write(makeLink(DIAGNOSTIC_PATH, {}, 'Diagnostic info'));
+        buffer.write('</p>');
       });
     });
   }
 
   /**
    * Return a two digit decimal representation of the given non-negative integer
    * [value].
    */
   String _twoDigit(int value) {
     if (value < 10) {
@@ skipping 182 matching lines @@
       <p><strong># Notifications</strong> - the total number of notifications
         sent to the client with completion results for this request.
       <p><strong># Suggestions</strong> - the number of suggestions
         sent to the client in the first notification, followed by a comma,
         followed by the number of suggestions send to the client
         in the last notification. If there is only one notification,
         then there will be only one number in this column.''');
   }
 
   /**
+   * Write the status of the diagnostic domain to the given [buffer].
+   */
+  void _writeDiagnosticStatus(StringBuffer buffer) {
+    DiagnosticDomainHandler handler =
+        new DiagnosticDomainHandler(_server.analysisServer);
+
+    var request = new DiagnosticGetDiagnosticsParams().toRequest('0');
+
+    var stopwatch = new Stopwatch();
+    stopwatch.start();
+    var response = handler.handleRequest(request);
+    stopwatch.stop();
+
+    int elapsedMs = stopwatch.elapsedMilliseconds;
+    _diagnosticCallAverage.addSample(elapsedMs);
+
+    buffer.write('<h3>Timing</h3>');
+
+    buffer.write('<p>');
+    buffer.write('getDiagnostic (last call): $elapsedMs (ms)');
+    buffer.write('<p>');
+    buffer.write('getDiagnostic (rolling average): '
+        '${_diagnosticCallAverage.value} (ms)');
+    buffer.write('<p>&nbsp;');
+
+    var json = response.toJson()[Response.RESULT];
+    List contexts = json['contexts'];
+    for (var context in contexts) {
+      buffer.write('<p>');
+      buffer.write('<h3>${context["name"]}</h3>');
+      buffer.write('<p>');
+      buffer.write('explicitFileCount: ${context["explicitFileCount"]}');
+      buffer.write('<p>');
+      buffer.write('implicitFileCount: ${context["implicitFileCount"]}');
+      buffer.write('<p>');
+      buffer.write('workItemQueueLength: ${context["workItemQueueLength"]}');
+      buffer.write('<p>');
+      buffer.write('workItemQueueLengthAverage: '
+          '${context["workItemQueueLengthAverage"]}');
+      buffer.write('<p>&nbsp;');
+    }
+  }
+
+  /**
    * Write the status of the edit domain (on the main status page) to the given
    * [buffer].
    */
   void _writeEditStatus(StringBuffer buffer) {
     buffer.write('<h3>Edit Domain</h3>');
     _writeTwoColumns(buffer, (StringBuffer buffer) {
       buffer.write('<p><b>Performance Data</b></p>');
       buffer.write('<p>');
       buffer.write(makeLink(COMPLETION_PATH, {}, 'Completion data'));
       buffer.write('</p>');
@@ skipping 483 matching lines @@
    */
   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>';
   }
 }