Add support for capturing a session log for a short time

Adds a new logging sink that supports an in-memory storage of events for
a subset of the whole server session. This is support for being able to
add 'start' and 'stop' buttons to the insight pages, which will allow
us and users to capture a smaller number of log entries.

Change-Id: Ia562e4da7b09c11ad9191c24cb85102970e1b116
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/461901
Reviewed-by: Keerti Parthasarathy <keertip@google.com>
Commit-Queue: Brian Wilkerson <brianwilkerson@google.com>
Reviewed-by: Jake Macdonald <jakemac@google.com>

Author: bwilkerson

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

@@ -335,10 +335,12 @@ class Driver implements ServerStarter {
     // Initialize the session logging service.
     var sessionLogFilePath = results.option(sessionLogOption);
     _sessionLogger = SessionLogger();
+    var inMemorySink = SessionLoggerInMemorySink(maxBufferLength: 256);
+    _sessionLogger.sink = inMemorySink;
     if (sessionLogFilePath != null) {
-      _sessionLogger.sink = SessionLoggerFileSink(sessionLogFilePath);
-      _sessionLogger.logCommandLine(arguments: arguments);
+      inMemorySink.nextLogger = SessionLoggerFileSink(sessionLogFilePath);
     }
+    _sessionLogger.logCommandLine(arguments: arguments);
 
     int? diagnosticServerPort;
     var portValue =

pkg/analysis_server/tool/log_player/log_entry.dart renamed to pkg/analysis_server/lib/src/session_logger/log_entry.dart

@@ -2,9 +2,6 @@
 // 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.
 
-/// @docImport 'log.dart';
-library;
-
 import 'package:analysis_server/src/session_logger/entry_keys.dart' as key;
 import 'package:analysis_server/src/session_logger/entry_kind.dart';
 import 'package:analysis_server/src/session_logger/process_id.dart';
@@ -43,6 +40,13 @@ extension type Message(JsonMap map) {
   /// Whether this message is a request for the server to exit.
   bool get isExit => method == 'exit';
 
+  /// Whether this message is a request for the server to initialize itself.
+  bool get isInitialize => method == 'initialize';
+
+  /// Whether this message is a notification to the server indicating that the
+  /// client is initialized.
+  bool get isInitialized => method == 'initialized';
+
   /// Whether this message is a request from the server to log a message.
   bool get isLogMessage => method == 'window/logMessage';
 

pkg/analysis_server/lib/src/session_logger/session_logger.dart

@@ -17,7 +17,7 @@ class SessionLogger {
   void logCommandLine({required List<String> arguments}) {
     sink?.writeLogEntry({
       key.time: DateTime.now().millisecondsSinceEpoch,
-      key.kind: EntryKind.message.name,
+      key.kind: EntryKind.commandLine.name,
       key.argList: arguments,
     });
   }

pkg/analysis_server/lib/src/session_logger/session_logger_sink.dart

@@ -5,6 +5,7 @@
 import 'dart:convert';
 import 'dart:io';
 
+import 'package:analysis_server/src/session_logger/log_entry.dart';
 import 'package:analysis_server/src/session_logger/process_id.dart';
 
 /// A sink for a session logger that will write entries to a file.
@@ -32,27 +33,87 @@ class SessionLoggerFileSink extends SessionLoggerSink {
 }
 
 /// A sink for a session logger that will write entries to an in-memory buffer.
-class SessionLoggerMemorySink extends SessionLoggerSink {
-  /// The maximum number of entries stored in the [buffer].
+class SessionLoggerInMemorySink extends SessionLoggerSink {
+  /// The maximum number of entries stored in the [_sessionBuffer].
   int maxBufferLength;
 
-  /// The buffer in which entries are stored.
-  List<JsonMap> buffer = [];
+  /// Whether entries should be captured in the buffer.
+  bool _capturingEntries = false;
+
+  /// A session logger to which requests should be forwarded, or `null` if there
+  /// is no logger to forward requests to.
+  SessionLoggerSink? nextLogger;
+
+  /// The buffer in which initialization related entries are stored.
+  final List<LogEntry> _initializationBuffer = [];
+
+  /// The buffer in which normal entries are stored.
+  final List<LogEntry> _sessionBuffer = [];
 
   /// Initialize a newly created sink to store up to [maxBufferLength] entries.
-  SessionLoggerMemorySink(this.maxBufferLength);
+  SessionLoggerInMemorySink({required this.maxBufferLength});
 
   @override
   Future<void> close() async {
-    // There's nothing to do in this case.
+    await nextLogger?.close();
+  }
+
+  /// Stops the capturing of entries.
+  void startCapture() {
+    _capturingEntries = true;
+  }
+
+  /// Stops the capturing of entries and returns a list of the entries that were
+  /// captured.
+  ///
+  /// The list includes necessary initialization entries that might have
+  /// occurred before the capture was started.
+  List<LogEntry> stopCapture() {
+    _capturingEntries = false;
+    var capturedEntries = [..._initializationBuffer, ..._sessionBuffer];
+    _sessionBuffer.clear();
+    return capturedEntries;
   }
 
   @override
   void writeLogEntry(JsonMap entry) {
-    if (buffer.length > maxBufferLength) {
-      buffer.removeAt(0);
+    nextLogger?.writeLogEntry(entry);
+    var logEntry = LogEntry(entry);
+    if (_isInitializationEntry(logEntry)) {
+      _initializationBuffer.add(logEntry);
+      return;
+    }
+    if (_capturingEntries) {
+      if (_sessionBuffer.length > maxBufferLength) {
+        _sessionBuffer.removeAt(0);
+      }
+      _sessionBuffer.add(logEntry);
+    } else {
+      // TODO(brianwilkerson): We also need to collect the most recent messages
+      //  related to which directories are open in the workspace and which files
+      //  are priority files. These should be in separate lists so that we can
+      //  flush messages that are no longer required in order to reproduce the
+      //  captured messages.
+    }
+  }
+
+  /// Returns whether the [entry] is an initialization entry.
+  ///
+  /// An initialization entry is defined as an entry that would need to be
+  /// replayed in order to make the captured entries make sense.
+  ///
+  /// Initialization entries are captured even when [captureEntries] is `false`.
+  bool _isInitializationEntry(LogEntry entry) {
+    if (entry.isCommandLine) return true;
+    if (entry.isMessage) {
+      // TODO(brianwilkerson): This list is incomplete in two ways.
+      //  1. It does not support the legacy protocol.
+      //  2. It does not capture entries that indicate the state of either the
+      //     workspace or the priority files.
+      var message = entry.message;
+      return message.isInitialize || message.isInitialized;
     }
-    buffer.add(entry);
+    return false;
   }
 }
 

pkg/analysis_server/tool/log_player/log.dart

@@ -4,10 +4,9 @@
 
 import 'dart:convert';
 
+import 'package:analysis_server/src/session_logger/log_entry.dart';
 import 'package:analyzer/file_system/file_system.dart';
 
-import 'log_entry.dart';
-
 /// The content of a log file.
 class Log {
   /// The entries in the log.

pkg/analysis_server/tool/log_player/log_player.dart

@@ -2,10 +2,10 @@
 // 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 'package:analysis_server/src/session_logger/log_entry.dart';
 import 'package:analysis_server/src/session_logger/process_id.dart';
 
 import 'log.dart';
-import 'log_entry.dart';
 import 'server_driver.dart';
 
 /// An object used to play back the messages in a log.

pkg/analysis_server/tool/log_player/server_driver.dart

@@ -7,8 +7,7 @@ import 'dart:io';
 
 import 'package:analysis_server/lsp_protocol/protocol.dart' show jsonRpcVersion;
 import 'package:analysis_server/src/server/driver.dart';
-
-import 'log_entry.dart';
+import 'package:analysis_server/src/session_logger/log_entry.dart';
 
 /// The driver used to communicate with the analysis server.
 class ServerDriver {