[analysis_server] Add a diagnostic page to stream the analysis PerformanceLog

This adds a new page to the analysis server diagnostics that allow you to start/stop streaming the analyzer `PerformanceLog` to the client. This can be useful to capture a slice of this traffic (for example while typing in a file where performance feels bad) without having to enable the on-disk log which can grow very large and hard to match up with specific points in time.

Change-Id: I6bf2b891481191929593beaef813c02df5d3a0c2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/403420
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Brian Wilkerson <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>

Author: DanTup

pkg/analysis_server/lib/src/analysis_server.dart

@@ -45,7 +45,6 @@ import 'package:analysis_server/src/services/user_prompts/dart_fix_prompt_manage
 import 'package:analysis_server/src/services/user_prompts/survey_manager.dart';
 import 'package:analysis_server/src/services/user_prompts/user_prompts.dart';
 import 'package:analysis_server/src/utilities/file_string_sink.dart';
-import 'package:analysis_server/src/utilities/null_string_sink.dart';
 import 'package:analysis_server/src/utilities/process.dart';
 import 'package:analysis_server/src/utilities/request_statistics.dart';
 import 'package:analysis_server/src/utilities/tee_string_sink.dart';
@@ -204,6 +203,9 @@ abstract class AnalysisServer {
 
   final RequestStatisticsHelper? requestStatistics;
 
+  final PerformanceLog<TeeStringSink> analysisPerformanceLogger =
+      PerformanceLog<TeeStringSink>(TeeStringSink());
+
   /// Manages prompts telling the user about "dart fix".
   late final DartFixPromptManager _dartFixPrompt;
 
@@ -338,21 +340,21 @@ abstract class AnalysisServer {
     }
 
     var logName = options.newAnalysisDriverLog;
-    StringSink sink = NullStringSink();
     if (logName != null) {
       if (logName == 'stdout') {
-        sink = io.stdout;
+        analysisPerformanceLogger.sink.addSink(io.stdout);
       } else if (logName.startsWith('file:')) {
         var path = logName.substring('file:'.length);
-        sink = FileStringSink(path);
+        analysisPerformanceLogger.sink.addSink(FileStringSink(path));
       }
     }
 
     var requestStatistics = this.requestStatistics;
     if (requestStatistics != null) {
-      sink = TeeStringSink(sink, requestStatistics.perfLoggerStringSink);
+      analysisPerformanceLogger.sink.addSink(
+        requestStatistics.perfLoggerStringSink,
+      );
     }
-    var analysisPerformanceLogger = PerformanceLog(sink);
 
     byteStore = createByteStore(resourceProvider);
     fileContentCache = FileContentCache(resourceProvider);

pkg/analysis_server/lib/src/server/http_server.dart

@@ -15,6 +15,9 @@ abstract class AbstractHttpHandler {
 
   /// Handle a POST request received by the HTTP server.
   void handlePostRequest(HttpRequest request);
+
+  /// Handle a request to upgrade to a WebSocket.
+  void handleWebSocketRequest(HttpRequest request);
 }
 
 /// Instances of the class [HttpServer] implement a simple HTTP server. The
@@ -93,22 +96,16 @@ class HttpAnalysisServer {
 
   /// Attach a listener to a newly created HTTP server.
   void _handleServer(HttpServer httpServer) {
-    httpServer.listen((HttpRequest request) {
-      var updateValues = request.headers[HttpHeaders.upgradeHeader];
-      if (request.method == 'GET') {
+    httpServer.listen((HttpRequest request) async {
+      if (WebSocketTransformer.isUpgradeRequest(request) &&
+          // For WebSockets, verify we're same origin (since the browser would
+          // not).
+          request.headers.value('origin') == request.requestedUri.origin) {
+        _httpHandler.handleWebSocketRequest(request);
+      } else if (request.method == 'GET') {
         _httpHandler.handleGetRequest(request);
       } else if (request.method == 'POST') {
         _httpHandler.handlePostRequest(request);
-      } else if (updateValues != null && updateValues.contains('websocket')) {
-        // We no longer support serving analysis server communications over
-        // WebSocket connections.
-        var response = request.response;
-        response.statusCode = HttpStatus.notFound;
-        response.headers.contentType = ContentType.text;
-        response.write(
-          'WebSocket connections not supported (${request.uri.path}).',
-        );
-        unawaited(response.close());
       } else {
         _returnUnknownRequest(request);
       }

pkg/analysis_server/lib/src/status/diagnostics.dart

@@ -2,6 +2,7 @@
 // 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.
 
+import 'dart:async';
 import 'dart:convert' show JsonEncoder;
 import 'dart:developer' as developer;
 import 'dart:io';
@@ -22,6 +23,7 @@ import 'package:analysis_server/src/status/ast_writer.dart';
 import 'package:analysis_server/src/status/element_writer.dart';
 import 'package:analysis_server/src/status/pages.dart';
 import 'package:analysis_server/src/utilities/profiling.dart';
+import 'package:analysis_server/src/utilities/stream_string_stink.dart';
 import 'package:analyzer/dart/analysis/context_root.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/src/context/source.dart';
@@ -173,7 +175,6 @@ _CollectedOptionsData _collectOptionsData(AnalysisDriver driver) {
 }
 
 class AnalysisDriverTimingsPage extends DiagnosticPageWithNav
-    with PerformanceChartMixin
     implements PostablePage {
   static const _resetFormId = 'reset-driver-timers';
 
@@ -217,6 +218,47 @@ class AnalysisDriverTimingsPage extends DiagnosticPageWithNav
   }
 }
 
+class AnalysisPerformanceLogPage extends WebSocketLoggingPage {
+  AnalysisPerformanceLogPage(DiagnosticsSite site)
+    : super(
+        site,
+        'analysis-performance-log',
+        'Analysis Performance Log',
+        description: 'Realtime logging from the Analysis Performance Log',
+      );
+
+  @override
+  Future<void> generateContent(Map<String, String> params) async {
+    _writeWebSocketLogPanel();
+  }
+
+  @override
+  Future<void> handleWebSocket(WebSocket socket) async {
+    var logger = server.analysisPerformanceLogger;
+
+    // We were able to attach our temporary sink. Forward all data over the
+    // WebSocket and wait for it to close (this is done by the user clicking
+    // the Stop button or navigating away from the page).
+    var controller = StreamController<String>();
+    var sink = StreamStringSink(controller.sink);
+    try {
+      unawaited(socket.addStream(controller.stream));
+      logger.sink.addSink(sink);
+
+      // Wait for the socket to be closed so we can remove the secondary sink.
+      var completer = Completer<void>();
+      socket.listen(
+        null,
+        onDone: completer.complete,
+        onError: completer.complete,
+      );
+      await completer.future;
+    } finally {
+      logger.sink.removeSink(sink);
+    }
+  }
+}
+
 class AnalyticsPage extends DiagnosticPageWithNav {
   AnalyticsPage(DiagnosticsSite site)
     : super(
@@ -1280,6 +1322,7 @@ class DiagnosticsSite extends Site implements AbstractHttpHandler {
     pages.add(TimingPage(this));
     pages.add(ByteStoreTimingPage(this));
     pages.add(AnalysisDriverTimingsPage(this));
+    pages.add(AnalysisPerformanceLogPage(this));
 
     var profiler = ProcessProfiler.getProfilerForPlatform();
     if (profiler != null) {
@@ -1982,6 +2025,121 @@ class TimingPage extends DiagnosticPageWithNav with PerformanceChartMixin {
   }
 }
 
+/// A base class for pages that provide real-time logging over a WebSocket.
+abstract class WebSocketLoggingPage extends DiagnosticPageWithNav
+    implements WebSocketPage {
+  WebSocketLoggingPage(super.site, super.id, super.title, {super.description});
+
+  void button(String text, {String? id, String classes = '', String? onClick}) {
+    var attributes = {
+      'type': 'button',
+      if (id != null) 'id': id,
+      'class': 'btn $classes'.trim(),
+      if (onClick != null) 'onclick': onClick,
+      'value': text,
+    };
+
+    tag('input', attributes: attributes);
+  }
+
+  /// Writes an HTML tag for [tagName] with the given [attributes].
+  ///
+  /// If [gen] is supplied, it is executed to write child content to [buf].
+  void tag(
+    String tagName, {
+    Map<String, String>? attributes,
+    void Function()? gen,
+  }) {
+    buf.write('<$tagName');
+    if (attributes != null) {
+      for (var MapEntry(:key, :value) in attributes.entries) {
+        buf.write(' $key="${escape(value)}"');
+      }
+    }
+    buf.write('>');
+    gen?.call();
+    buf.writeln('</$tagName>');
+  }
+
+  /// Writes Start/Stop/Clear buttons and associated scripts to connect and
+  /// disconnect a websocket back to this page, along with a panel to show
+  /// any output received from the server over the WebSocket.
+  void _writeWebSocketLogPanel() {
+    // Add buttons to start/stop logging. Using "position: sticky" so they're
+    // always visible even when scrolled.
+    tag(
+      'div',
+      attributes: {
+        'style':
+            'position: sticky; top: 10px; text-align: right; margin-bottom: 20px;',
+      },
+      gen: () {
+        button(
+          'Start Logging',
+          id: 'btnStartLog',
+          classes: 'btn-danger',
+          onClick: 'startLogging()',
+        );
+        button(
+          'Stop Logging',
+          id: 'btnStopLog',
+          classes: 'btn-danger',
+          onClick: 'stopLogging()',
+        );
+        button('Clear', onClick: 'clearLog()');
+      },
+    );
+
+    // Write the log container.
+    pre(() {
+      tag('code', attributes: {'id': 'logContent'});
+    });
+
+    // Write the scripts to connect/disconnect the websocket and display the
+    // data.
+    buf.write('''
+<script>
+  let logContent = document.getElementById('logContent');
+  let btnEnable = document.getElementById('btnEnable');
+  let btnDisable = document.getElementById('btnDisable');
+  let socket;
+
+  function clearLog(data) {
+    logContent.textContent = '';
+  }
+
+  function append(data) {
+    logContent.appendChild(document.createTextNode(data));
+  }
+
+  function startLogging() {
+    append("Connecting...\\n");
+    socket = new WebSocket("${this.path}");
+    socket.addEventListener("open", (event) => {
+      append("Connected!\\n");
+    });
+    socket.addEventListener("close", (event) => {
+      append("Disconnected!\\n");
+      stopLogging();
+    });
+    socket.addEventListener("message", (event) => {
+      append(event.data);
+    });
+    btnEnable.disabled = true;
+    btnDisable.disabled = false;
+  }
+
+  function stopLogging() {
+    socket?.close(1000, 'User closed');
+    socket = undefined;
+    btnEnable.disabled = false;
+    btnDisable.disabled = true;
+  }
+</script>
+''');
+  }
+}
+
 class _CollectedOptionsData {
   final Set<String> lints = <String>{};
   final Set<String> plugins = <String>{};

pkg/analysis_server/lib/src/status/pages.dart

@@ -246,6 +246,24 @@ abstract class Site {
     });
   }
 
+  Future<void> handleWebSocketRequest(HttpRequest request) async {
+    var path = request.uri.path;
+
+    await _tryHandleRequest(request, (response, queryParameters) async {
+      var page = _getPage(path);
+      if (page == null) {
+        await respond(request, createUnknownPage(path), HttpStatus.notFound);
+        return;
+      } else if (page is WebSocketPage) {
+        var webSocket = await WebSocketTransformer.upgrade(request);
+        await (page as WebSocketPage).handleWebSocket(webSocket);
+        await webSocket.done;
+      } else {
+        throw 'Method not supported';
+      }
+    });
+  }
+
   Future<void> respond(
     HttpRequest request,
     Page page, [
@@ -316,11 +334,22 @@ abstract class Site {
         );
       } catch (e, st) {
         var response = request.response;
-        response.statusCode = HttpStatus.internalServerError;
-        response.headers.contentType = ContentType.text;
-        response.write('$e\n\n$st');
+        try {
+          response.statusCode = HttpStatus.internalServerError;
+          response.headers.contentType = ContentType.text;
+          response.write('$e\n\n$st');
+        } catch (_) {
+          // We may fail to send the above if the request that errored had
+          // already caused the HTTP headers to be flushed (this can happen
+          // after a WebSocket upgrade, for example).
+        }
         unawaited(response.close());
       }
     }
   }
 }
+
+abstract interface class WebSocketPage {
+  /// Handles a WebSocket connection to the page.
+  Future<void> handleWebSocket(WebSocket socket);
+}

pkg/analysis_server/lib/src/utilities/stream_string_stink.dart

@@ -0,0 +1,32 @@
+// Copyright (c) 2025, 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.
+
+import 'dart:async';
+
+/// A [StringSink] that writes into a StreamSink<String>.
+class StreamStringSink implements StringSink {
+  final StreamSink<String> _sink;
+
+  StreamStringSink(this._sink);
+
+  @override
+  void write(Object? obj) {
+    _sink.add('$obj');
+  }
+
+  @override
+  void writeAll(Iterable<dynamic> objects, [String separator = '']) {
+    _sink.add(objects.join(separator));
+  }
+
+  @override
+  void writeCharCode(int charCode) {
+    _sink.add(String.fromCharCode(charCode));
+  }
+
+  @override
+  void writeln([Object? obj = '']) {
+    _sink.add('$obj\n');
+  }
+}