Implement the log retention setting

packages/devtools_app/lib/src/screens/logging/logging_screen_v2/logging_model.dart

@@ -3,9 +3,13 @@
 // found in the LICENSE file.
 
 import 'dart:async';
+import 'dart:collection';
 
+import 'package:devtools_app_shared/utils.dart';
 import 'package:flutter/foundation.dart';
 
+import '../../../shared/globals.dart';
+
 import '../../../shared/utils.dart';
 import 'logging_controller_v2.dart';
 import 'logging_table_row.dart';
@@ -17,19 +21,27 @@ import 'logging_table_v2.dart';
 /// The [LoggingTableV2] table uses variable height rows. This model caches the
 /// relevant heights and offsets so that the row heights only need to be calculated
 /// once per parent width.
-class LoggingTableModel extends ChangeNotifier {
+class LoggingTableModel extends ChangeNotifier with DisposerMixin {
   LoggingTableModel() {
     _worker = InterruptableChunkWorker(
       callback: (index) => getFilteredLogHeight(
         index,
       ),
       progressCallback: (progress) => _cacheLoadProgress.value = progress,
     );
+
+    addAutoDisposeListener(
+      preferences.logging.retentionLimit,
+      _onRetentionLimitUpdate,
+    );
+
+    _retentionLimit = preferences.logging.retentionLimit.value;
   }
 
-  final _logs = <LogDataV2>[];
-  final _filteredLogs = <LogDataV2>[];
-  final _selectedLogs = <int>{};
+  final _logs = ListQueue<LogDataV2>();
+  final _filteredLogs = ListQueue<LogDataV2>();
+  final _selectedLogs = ListQueue<LogDataV2>();
+  late int _retentionLimit;
 
   final cachedHeights = <int, double>{};
   final cachedOffets = <int, double>{};
@@ -42,12 +54,28 @@ class LoggingTableModel extends ChangeNotifier {
   ValueListenable<double?> get cacheLoadProgress => _cacheLoadProgress;
   final _cacheLoadProgress = ValueNotifier<double?>(null);
 
+  void _onRetentionLimitUpdate() {
+    _retentionLimit = preferences.logging.retentionLimit.value;
+    while (_logs.length > _retentionLimit) {
+      if (identical(_filteredLogs.first, _logs.first)) {
+        // Remove a filtered log if it is about to disapear from the _logs.
+        _filteredLogs.removeFirst();
+      }
+      _logs.removeFirst();
+    }
+
+    notifyListeners();
+  }
+
   @override
   void dispose() {
-    super.dispose();
     _cacheLoadProgress.dispose();
+    _worker.dispose();
+    super.dispose();
   }
 
+  double get tableWidth => _tableWidth;
+
   /// Update the width of the table.
   ///
   /// If different from the last width, this will flush all of the calculated heights, and recalculate their heights
@@ -62,7 +90,7 @@ class LoggingTableModel extends ChangeNotifier {
   }
 
   /// Get the filtered log at [index].
-  LogDataV2 filteredLogAt(int index) => _filteredLogs[index];
+  LogDataV2 filteredLogAt(int index) => _filteredLogs.elementAt(index);
 
   double _tableWidth = 0.0;
 
@@ -81,6 +109,15 @@ class LoggingTableModel extends ChangeNotifier {
 
     _logs.add(log);
     _filteredLogs.add(log);
+    if (_logs.length > _retentionLimit) {
+      if (identical(_logs.first, _filteredLogs.first)) {
+        // Remove a filtered log if it is about to go out of retention.
+        _filteredLogs.removeFirst();
+      }
+      // Remove the log that has just gone out of retention.
+      _logs.removeFirst();
+    }
+
     getFilteredLogHeight(
       _logs.length - 1,
     );
@@ -105,7 +142,7 @@ class LoggingTableModel extends ChangeNotifier {
     if (cachedHeight != null) return cachedHeight;
 
     return cachedHeights[index] = LoggingTableRow.calculateRowHeight(
-      _logs[index],
+      _logs.elementAt(index),
       _tableWidth,
     );
   }

packages/devtools_app/lib/src/screens/logging/logging_screen_v2/logging_table_row.dart

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'dart:math';
+
 import 'package:devtools_app_shared/ui.dart';
 import 'package:flutter/material.dart';
 
@@ -39,7 +41,7 @@ class LoggingTableRow extends StatefulWidget {
     double width,
   ) {
     final text = log.asLogDetails();
-    final maxWidth = width - _padding * 2;
+    final maxWidth = max(0.0, width - _padding * 2);
 
     final row1Height = calculateTextSpanHeight(
       TextSpan(text: text, style: detailsStyle),
@@ -49,9 +51,10 @@ class LoggingTableRow extends StatefulWidget {
     // TODO(danchevalier): Improve row2 height by manually flowing metadas into another row
     // if theyoverflow.
     final row2Height = calculateTextSpanHeight(
-      TextSpan(text: text, style: metadataStyle),
+      TextSpan(text: 'short text for now', style: metadataStyle),
       maxWidth: maxWidth,
     );
+
     return row1Height + row2Height + _padding * 2;
   }
 }
@@ -76,6 +79,7 @@ class _LoggingTableRowState extends State<LoggingTableRow> {
             padding: EdgeInsets.all(LoggingTableRow._padding),
             child: Column(
               crossAxisAlignment: CrossAxisAlignment.start,
+              mainAxisSize: MainAxisSize.min,
               children: [
                 RichText(
                   text: TextSpan(

packages/devtools_app/lib/src/screens/logging/logging_screen_v2/logging_table_v2.dart

@@ -13,6 +13,7 @@ import 'package:flutter/services.dart';
 import '../../../service/service_extension_widgets.dart';
 import '../../../shared/analytics/constants.dart' as gac;
 import '../../../shared/common_widgets.dart';
+import '../../../shared/globals.dart';
 import 'logging_model.dart';
 import 'logging_table_row.dart';
 
@@ -114,10 +115,11 @@ class _LoggingTableProgress extends StatefulWidget {
 }
 
 class _LoggingTableProgressState extends State<_LoggingTableProgress> {
-  final _progressStopwatch = Stopwatch();
   static const _millisecondsUntilCacheProgressShows = 500;
   static const _millisecondsUntilCacheProgressHelperShows = 2000;
 
+  final _progressStopwatch = Stopwatch();
+
   @override
   Widget build(BuildContext context) {
     return LayoutBuilder(
@@ -226,9 +228,16 @@ class _LoggingTableRowsState extends State<_LoggingTableRows>
   }
 }
 
-class LoggingSettingsDialogV2 extends StatelessWidget {
+class LoggingSettingsDialogV2 extends StatefulWidget {
   const LoggingSettingsDialogV2({super.key});
 
+  @override
+  State<LoggingSettingsDialogV2> createState() =>
+      _LoggingSettingsDialogV2State();
+}
+
+class _LoggingSettingsDialogV2State extends State<LoggingSettingsDialogV2> {
+  int? retentionLimit;
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
@@ -243,75 +252,104 @@ class LoggingSettingsDialogV2 extends StatelessWidget {
             'General',
           ),
           const StructuredErrorsToggle(),
+          const SizedBox(height: defaultSpacing),
+          _RententionLimitSetting(
+            theme: theme,
+            onRetentionLimitChange: (newRetentionLimit) =>
+                retentionLimit = newRetentionLimit,
+          ),
         ],
       ),
-      actions: const [
-        DialogCloseButton(),
+      actions: [
+        DialogApplyButton(
+          onPressed: () {
+            if (retentionLimit != null) {
+              // Save the new retention limit to preferences.
+              preferences.logging.retentionLimit.value = retentionLimit!;
+            }
+          },
+        ),
+        const DialogCloseButton(),
       ],
     );
   }
 }
 
-/// Shows and hides the context menu based on user gestures.
-///
-/// By default, shows the menu on right clicks and long presses.
-class _ContextMenuRegion extends StatefulWidget {
-  /// Creates an instance of [_ContextMenuRegion].
-  const _ContextMenuRegion({
-    required this.child,
-    required this.contextMenuBuilder,
+class _RententionLimitSetting extends StatefulWidget {
+  const _RententionLimitSetting({
+    required this.theme,
+    required this.onRetentionLimitChange,
   });
 
-  /// Builds the context menu.
-  final ContextMenuBuilder contextMenuBuilder;
-
-  /// The child widget that will be listened to for gestures.
-  final Widget child;
+  final ThemeData theme;
+  final void Function(int) onRetentionLimitChange;
 
   @override
-  State<_ContextMenuRegion> createState() => _ContextMenuRegionState();
+  State<_RententionLimitSetting> createState() =>
+      _RententionLimitSettingState();
 }
 
-class _ContextMenuRegionState extends State<_ContextMenuRegion> {
-  final _contextMenuController = ContextMenuController();
-
-  void _onSecondaryTapUp(TapUpDetails details) {
-    _show(details.globalPosition);
-  }
-
-  void _onTap() {
-    if (!_contextMenuController.isShown) {
-      return;
-    }
-    _hide();
-  }
-
-  void _show(Offset position) {
-    _contextMenuController.show(
-      context: context,
-      contextMenuBuilder: (BuildContext context) {
-        return widget.contextMenuBuilder(context, position);
-      },
-    );
+class _RententionLimitSettingState extends State<_RententionLimitSetting>
+    with AutoDisposeMixin {
+  void updateRetentionLimit() {
+    newRetentionLimit = preferences.logging.retentionLimit.value;
   }
 
-  void _hide() {
-    _contextMenuController.remove();
+  @override
+  void initState() {
+    super.initState();
+    preferences.logging.retentionLimit.addListener(updateRetentionLimit);
+    updateRetentionLimit();
   }
 
   @override
   void dispose() {
-    _hide();
+    preferences.logging.retentionLimit.removeListener(updateRetentionLimit);
     super.dispose();
   }
 
+  late int newRetentionLimit;
+
   @override
   Widget build(BuildContext context) {
-    return GestureDetector(
-      behavior: HitTestBehavior.opaque,
-      onSecondaryTapUp: _onSecondaryTapUp,
-      onTap: _onTap,
-      child: widget.child,
+    return Row(
+      children: [
+        Expanded(
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text(preferences.logging.retentionLimitTitle),
+              Text(
+                'Used to limit the number of log messages retained.',
+                style: widget.theme.subtleTextStyle,
+              ),
+            ],
+          ),
+        ),
+        const SizedBox(width: defaultSpacing),
+        SizedBox(
+          height: defaultTextFieldHeight,
+          width: defaultTextFieldNumberWidth,
+          child: TextField(
+            style: widget.theme.regularTextStyle,
+            decoration: singleLineDialogTextFieldDecoration,
+            controller: TextEditingController(
+              text: newRetentionLimit.toString(),
+            ),
+            inputFormatters: <TextInputFormatter>[
+              // Only positive integers.
+              FilteringTextInputFormatter.allow(
+                RegExp(r'^[1-9][0-9]*'),
+              ),
+            ],
+            onChanged: (String text) {
+              final newValue = int.parse(text);
+              newRetentionLimit = newValue;
+              widget.onRetentionLimitChange(newValue);
+            },
+          ),
+        ),
+      ],
     );
   }
 }

packages/devtools_app/lib/src/shared/analytics/constants.dart

@@ -12,6 +12,7 @@ part 'constants/_debugger_constants.dart';
 part 'constants/_deep_links_constants.dart';
 part 'constants/_extension_constants.dart';
 part 'constants/_memory_constants.dart';
+part 'constants/_logging_constants.dart';
 part 'constants/_performance_constants.dart';
 part 'constants/_vs_code_sidebar_constants.dart';
 part 'constants/_inspector_constants.dart';

packages/devtools_app/lib/src/shared/analytics/constants/_logging_constants.dart

@@ -0,0 +1,11 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+part of '../constants.dart';
+
+// ignore: avoid_classes_with_only_static_members, requires refactor.
+/// Logging event constants specific for logging screen.
+class LoggingEvent {
+  static const changeRetentionLimit = 'changeRetentionLimit';
+}

packages/devtools_app/lib/src/shared/preferences/_logging_preferences.dart

@@ -0,0 +1,38 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+part of 'preferences.dart';
+
+class LoggingPreferencesController extends DisposableController
+    with AutoDisposeControllerMixin {
+  final retentionLimitTitle = 'Limit for the number of logs retained.';
+
+  /// The number of logs to retain on the logging table.
+  final retentionLimit = ValueNotifier<int>(_defaultRetentionLimit);
+
+  static const _defaultRetentionLimit = 3000;
+
+  static const _retentionLimitStorageId = 'logging.retentionLimit';
+
+  Future<void> init() async {
+    addAutoDisposeListener(
+      retentionLimit,
+      () {
+        storage.setValue(
+          _retentionLimitStorageId,
+          retentionLimit.value.toString(),
+        );
+
+        ga.select(
+          gac.logging,
+          gac.LoggingEvent.changeRetentionLimit,
+          value: retentionLimit.value,
+        );
+      },
+    );
+    retentionLimit.value =
+        int.tryParse(await storage.getValue(_retentionLimitStorageId) ?? '') ??
+            _defaultRetentionLimit;
+  }
+}