fix: Enable logging in production

lib/features/logging/cubit/app_logs_cubit.dart

@@ -0,0 +1,119 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:bloc/bloc.dart';
+import 'package:collection/collection.dart';
+import 'package:file_picker/file_picker.dart';
+import 'package:flutter/services.dart';
+import 'package:intl/intl.dart';
+import 'package:paperless_mobile/features/logging/models/parsed_log_message.dart';
+import 'package:paperless_mobile/core/service/file_service.dart';
+import 'package:paperless_mobile/features/notifications/services/local_notification_service.dart';
+import 'package:path/path.dart' as p;
+import 'package:permission_handler/permission_handler.dart';
+import 'package:rxdart/rxdart.dart';
+part 'app_logs_state.dart';
+
+final _fileNameFormat = DateFormat("yyyy-MM-dd");
+
+class AppLogsCubit extends Cubit<AppLogsState> {
+  StreamSubscription? _fileChangesSubscription;
+  final LocalNotificationService _localNotificationService;
+  AppLogsCubit(
+    DateTime date,
+    this._localNotificationService,
+  ) : super(AppLogsStateInitial(date: date));
+
+  Future<void> loadLogs(DateTime date) async {
+    if (date == state.date) {
+      return;
+    }
+    _fileChangesSubscription?.cancel();
+    emit(AppLogsStateLoading(date: date));
+    final logDir = FileService.instance.logDirectory;
+    final availableLogs = (await logDir
+            .list()
+            .whereType<File>()
+            .where((event) => event.path.endsWith('.log'))
+            .map((e) =>
+                _fileNameFormat.parse(p.basenameWithoutExtension(e.path)))
+            .toList())
+        .sorted();
+    final logFile = _getLogfile(date);
+    if (!await logFile.exists()) {
+      emit(AppLogsStateLoaded(
+        date: date,
+        logs: [],
+        availableLogs: availableLogs,
+      ));
+    }
+    try {
+      _updateLogsFromFile(logFile, date, availableLogs);
+      _fileChangesSubscription = logFile.watch().listen((event) async {
+        if (!isClosed) {
+          _updateLogsFromFile(logFile, date, availableLogs);
+        }
+      });
+    } catch (e) {
+      emit(AppLogsStateError(
+        error: e,
+        date: date,
+      ));
+    }
+  }
+
+  void _updateLogsFromFile(
+      File file, DateTime date, List<DateTime> availableLogs) async {
+    final logs = await file.readAsLines();
+    final parsedLogs = ParsedLogMessage.parse(logs).reversed.toList();
+    emit(AppLogsStateLoaded(
+      date: date,
+      logs: parsedLogs,
+      availableLogs: availableLogs,
+    ));
+  }
+
+  Future<void> clearLogs(DateTime date) async {
+    final logFile = _getLogfile(date);
+    await logFile.writeAsString('');
+    await loadLogs(date);
+  }
+
+  Future<void> copyToClipboard(DateTime date) async {
+    final file = _getLogfile(date);
+    if (!await file.exists()) {
+      return;
+    }
+    final content = await file.readAsString();
+    Clipboard.setData(ClipboardData(text: content));
+  }
+
+  Future<void> saveLogs(DateTime date, String locale) async {
+    var formattedDate = _fileNameFormat.format(date);
+    final filename = 'paperless_mobile_logs_$formattedDate.log';
+    // final parentDir = await FilePicker.platform.getDirectoryPath(
+    //   dialogTitle: "Save log from ${DateFormat.yMd(locale).format(date)}",
+    //   initialDirectory: Platform.isAndroid
+    //       ? FileService.instance.downloadsDirectory.path
+    //       : null,
+    // );
+    // if (parentDir == null) {
+    //   return;
+    // }
+    final logFile = _getLogfile(date);
+    final parentDir = FileService.instance.downloadsDirectory;
+    final downloadedFile = await logFile.copy(p.join(parentDir.path, filename));
+    _localNotificationService.notifyFileDownload(filePath: downloadedFile.path);
+  }
+
+  File _getLogfile(DateTime date) {
+    return File(p.join(FileService.instance.logDirectory.path,
+        '${_fileNameFormat.format(date)}.log'));
+  }
+
+  @override
+  Future<void> close() async {
+    await _fileChangesSubscription?.cancel();
+    return super.close();
+  }
+}

lib/features/logging/cubit/app_logs_state.dart

@@ -0,0 +1,33 @@
+part of 'app_logs_cubit.dart';
+
+sealed class AppLogsState {
+  final DateTime date;
+  const AppLogsState({required this.date});
+}
+
+class AppLogsStateInitial extends AppLogsState {
+  const AppLogsStateInitial({required super.date});
+}
+
+class AppLogsStateLoading extends AppLogsState {
+  const AppLogsStateLoading({required super.date});
+}
+
+class AppLogsStateLoaded extends AppLogsState {
+  const AppLogsStateLoaded({
+    required super.date,
+    required this.logs,
+    required this.availableLogs,
+  });
+  final List<DateTime> availableLogs;
+  final List<ParsedLogMessage> logs;
+}
+
+class AppLogsStateError extends AppLogsState {
+  const AppLogsStateError({
+    required this.error,
+    required super.date,
+  });
+
+  final Object error;
+}

lib/features/logging/data/formatted_printer.dart

@@ -0,0 +1,45 @@
+import 'dart:convert';
+
+import 'package:collection/collection.dart';
+import 'package:flutter/material.dart';
+import 'package:intl/intl.dart';
+import 'package:logger/logger.dart';
+import 'package:paperless_mobile/features/logging/models/formatted_log_message.dart';
+
+class FormattedPrinter extends LogPrinter {
+  static final _timestampFormat = DateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+  static const _mulitlineObjectEncoder = JsonEncoder.withIndent(null);
+
+  @override
+  List<String> log(LogEvent event) {
+    final unformattedMessage = event.message;
+    final formattedMessage = switch (unformattedMessage) {
+      FormattedLogMessage m => m.format(),
+      Iterable i => _mulitlineObjectEncoder
+          .convert(i)
+          .padLeft(FormattedLogMessage.maxLength),
+      Map m => _mulitlineObjectEncoder
+          .convert(m)
+          .padLeft(FormattedLogMessage.maxLength),
+      _ => unformattedMessage.toString().padLeft(FormattedLogMessage.maxLength),
+    };
+    final formattedLevel = event.level.name
+        .toUpperCase()
+        .padRight(Level.values.map((e) => e.name.length).max);
+    final formattedTimestamp = _timestampFormat.format(event.time);
+
+    return [
+      '$formattedTimestamp\t$formattedLevel --- $formattedMessage',
+      if (event.error != null) ...[
+        "---BEGIN ERROR---",
+        event.error.toString(),
+        "---END ERROR---",
+      ],
+      if (event.stackTrace != null) ...[
+        "---BEGIN STACKTRACE---",
+        event.stackTrace.toString(),
+        "---END STACKTRACE---"
+      ],
+    ];
+  }
+}

lib/features/logging/data/logger.dart

@@ -0,0 +1,116 @@
+import 'package:logger/logger.dart';
+import 'package:paperless_mobile/features/logging/models/formatted_log_message.dart';
+
+late Logger logger;
+
+extension FormattedLoggerExtension on Logger {
+  void ft(
+    dynamic message, {
+    String className = '',
+    String methodName = '',
+    DateTime? time,
+    Object? error,
+    StackTrace? stackTrace,
+  }) {
+    final formattedMessage = FormattedLogMessage(
+      message,
+      className: className,
+      methodName: methodName,
+    );
+    log(
+      Level.trace,
+      formattedMessage,
+      time: time,
+      error: error,
+      stackTrace: stackTrace,
+    );
+  }
+
+  void fw(
+    dynamic message, {
+    String className = '',
+    String methodName = '',
+    DateTime? time,
+    Object? error,
+    StackTrace? stackTrace,
+  }) {
+    final formattedMessage = FormattedLogMessage(
+      message,
+      className: className,
+      methodName: methodName,
+    );
+    log(
+      Level.warning,
+      formattedMessage,
+      time: time,
+      error: error,
+      stackTrace: stackTrace,
+    );
+  }
+
+  void fd(
+    dynamic message, {
+    String className = '',
+    String methodName = '',
+    DateTime? time,
+    Object? error,
+    StackTrace? stackTrace,
+  }) {
+    final formattedMessage = FormattedLogMessage(
+      message,
+      className: className,
+      methodName: methodName,
+    );
+    log(
+      Level.debug,
+      formattedMessage,
+      time: time,
+      error: error,
+      stackTrace: stackTrace,
+    );
+  }
+
+  void fi(
+    dynamic message, {
+    String className = '',
+    String methodName = '',
+    DateTime? time,
+    Object? error,
+    StackTrace? stackTrace,
+  }) {
+    final formattedMessage = FormattedLogMessage(
+      message,
+      className: className,
+      methodName: methodName,
+    );
+    log(
+      Level.info,
+      formattedMessage,
+      time: time,
+      error: error,
+      stackTrace: stackTrace,
+    );
+  }
+
+  void fe(
+    dynamic message, {
+    String className = '',
+    String methodName = '',
+    DateTime? time,
+    Object? error,
+    StackTrace? stackTrace,
+  }) {
+    final formattedMessage = FormattedLogMessage(
+      message,
+      className: className,
+      methodName: methodName,
+    );
+    log(
+      Level.error,
+      formattedMessage,
+      time: time,
+      error: error,
+      stackTrace: stackTrace,
+    );
+  }
+}

lib/features/logging/data/mirrored_file_output.dart

@@ -0,0 +1,52 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:collection/collection.dart';
+import 'package:flutter/material.dart';
+import 'package:intl/intl.dart';
+import 'package:logger/logger.dart';
+import 'package:paperless_mobile/core/service/file_service.dart';
+import 'package:path/path.dart' as p;
+import 'package:synchronized/synchronized.dart';
+
+typedef f = FileOutput;
+
+class MirroredFileOutput extends LogOutput {
+  var lock = Lock();
+  MirroredFileOutput();
+
+  late final File file;
+
+  @override
+  Future<void> init() async {
+    final today = DateFormat("yyyy-MM-dd").format(DateTime.now());
+    final logDir = FileService.instance.logDirectory;
+    file = File(p.join(logDir.path, '$today.log'));
+    debugPrint("Logging files to ${file.path}.");
+    try {
+      final oldLogs = await FileService.instance.getAllFiles(logDir);
+      if (oldLogs.length > 10) {
+        oldLogs
+            .sortedBy((file) => file.lastModifiedSync())
+            .reversed
+            .skip(10)
+            .forEach((log) => log.delete());
+      }
+    } catch (e) {
+      debugPrint("Failed to delete old logs...");
+    }
+  }
+
+  @override
+  void output(OutputEvent event) async {
+    await lock.synchronized(() async {
+      for (var line in event.lines) {
+        debugPrint(line);
+        await file.writeAsString(
+          "$line${Platform.lineTerminator}",
+          mode: FileMode.append,
+        );
+      }
+    });
+  }
+}

lib/features/logging/models/formatted_log_message.dart

@@ -0,0 +1,19 @@
+/// Class passed to the printer to be formatted and printed.
+class FormattedLogMessage {
+  static const maxLength = 55;
+  final String message;
+  final String methodName;
+  final String className;
+
+  FormattedLogMessage(
+    this.message, {
+    required this.methodName,
+    required this.className,
+  });
+
+  String format() {
+    final formattedClassName = className.padLeft(25);
+    final formattedMethodName = methodName.padRight(25);
+    return '[$formattedClassName] - $formattedMethodName: $message';
+  }
+}

lib/features/logging/models/parsed_log_message.dart

@@ -0,0 +1,149 @@
+import 'dart:io';
+
+import 'package:logger/logger.dart';
+
+final _newLine = Platform.lineTerminator;
+
+sealed class ParsedLogMessage {
+  static List<ParsedLogMessage> parse(List<String> logs) {
+    List<ParsedLogMessage> messages = [];
+    int offset = 0;
+    while (offset < logs.length) {
+      final currentLine = logs[offset];
+      if (ParsedFormattedLogMessage.canConsumeFirstLine(currentLine)) {
+        final (consumedLines, result) =
+            ParsedFormattedLogMessage.consume(logs.sublist(offset));
+        messages.add(result);
+        offset += consumedLines;
+      } else {
+        messages.add(UnformattedLogMessage(currentLine));
+        offset++;
+      }
+    }
+    return messages;
+  }
+}
+
+class ParsedErrorLogMessage {
+  static final RegExp _errorBeginPattern = RegExp(r"---BEGIN ERROR---\s*");
+  static final RegExp _errorEndPattern = RegExp(r"---END ERROR---\s*");
+  static final RegExp _stackTraceBeginPattern =
+      RegExp(r"---BEGIN STACKTRACE---\s*");
+  static final RegExp _stackTraceEndPattern =
+      RegExp(r"---END STACKTRACE---\s*");
+  final String error;
+  final String? stackTrace;
+  ParsedErrorLogMessage({
+    required this.error,
+    this.stackTrace,
+  });
+  static bool canConsumeFirstLine(String line) =>
+      _errorBeginPattern.hasMatch(line);
+
+  static (int consumedLines, ParsedErrorLogMessage? result) consume(
+      List<String> log) {
+    assert(log.isNotEmpty && canConsumeFirstLine(log.first));
+    String errorText = "";
+    int currentLine =
+        1; // Skip first because we know that the first line is ---BEGIN ERROR---
+    
+    while (!_errorEndPattern.hasMatch(log[currentLine])) {
+      errorText += log[currentLine] + _newLine;
+      currentLine++;
+    }
+    currentLine++;
+    final hasStackTrace = _stackTraceBeginPattern.hasMatch(log[currentLine]);
+    String? stackTrace;
+    if (hasStackTrace) {
+      currentLine++;
+      String stackTraceText = '';
+
+      while (!_stackTraceEndPattern.hasMatch(log[currentLine])) {
+        stackTraceText += log[currentLine] + _newLine;
+        currentLine++;
+      }
+      stackTrace = stackTraceText;
+    }
+    return (
+      currentLine + 1,
+      ParsedErrorLogMessage(error: errorText, stackTrace: stackTrace)
+    );
+  }
+}
+
+class UnformattedLogMessage extends ParsedLogMessage {
+  final String message;
+
+  UnformattedLogMessage(this.message);
+}
+
+class ParsedFormattedLogMessage extends ParsedLogMessage {
+  static final RegExp pattern = RegExp(
+    r'(?<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\s*(?<level>[A-Z]*)'
+    r'\s*---\s*(?:\[\s*(?<className>.*)\]\s*-\s*(?<methodName>.*)\s*)?:\s*(?<message>.+)',
+  );
+
+  final Level level;
+  final String message;
+  final String? className;
+  final String? methodName;
+  final DateTime timestamp;
+
+  final ParsedErrorLogMessage? error;
+
+  ParsedFormattedLogMessage({
+    required this.level,
+    required this.message,
+    this.className,
+    this.methodName,
+    required this.timestamp,
+    this.error,
+  });
+
+  static bool canConsumeFirstLine(String line) => pattern.hasMatch(line);
+
+  static (int consumedLines, ParsedFormattedLogMessage result) consume(
+      List<String> log) {
+    assert(log.isNotEmpty && canConsumeFirstLine(log.first));
+
+    final match = pattern.firstMatch(log.first)!;
+    final result = ParsedFormattedLogMessage(
+      level: Level.values.byName(match.namedGroup('level')!.toLowerCase()),
+      message: match.namedGroup('message')!,
+      className: match.namedGroup('className'),
+      methodName: match.namedGroup('methodName'),
+      timestamp: DateTime.parse(match.namedGroup('timestamp')!),
+    );
+    final updatedLog = log.sublist(1);
+    if (updatedLog.isEmpty) {
+      return (1, result);
+    }
+    if (ParsedErrorLogMessage.canConsumeFirstLine(updatedLog.first)) {
+      final (consumedLines, parsedError) =
+          ParsedErrorLogMessage.consume(updatedLog);
+      return (
+        consumedLines + 1,
+        result.copyWith(error: parsedError),
+      );
+    }
+    return (1, result);
+  }
+
+  ParsedFormattedLogMessage copyWith({
+    Level? level,
+    String? message,
+    String? className,
+    String? methodName,
+    DateTime? timestamp,
+    ParsedErrorLogMessage? error,
+  }) {
+    return ParsedFormattedLogMessage(
+      level: level ?? this.level,
+      message: message ?? this.message,
+      className: className ?? this.className,
+      methodName: methodName ?? this.methodName,
+      timestamp: timestamp ?? this.timestamp,
+      error: error ?? this.error,
+    );
+  }
+}

lib/features/logging/utils/redaction_utils.dart

@@ -0,0 +1,22 @@
+(String username, String obscuredUrl) splitRedactUserId(String userId) {
+  final parts = userId.split('@');
+  if (parts.length != 2) {
+    return ('unknown', 'unknown');
+  }
+
+  final username = parts.first;
+  final serverUrl = parts.last;
+  final uri = Uri.parse(serverUrl);
+  final hostLen = uri.host.length;
+  final obscuredUrl = uri.scheme +
+      "://" +
+      uri.host.substring(0, 2) +
+      List.filled(hostLen - 4, '*').join() +
+      uri.host.substring(uri.host.length - 2, uri.host.length);
+  return (username, obscuredUrl);
+}
+
+String redactUserId(String userId) {
+  final (username, obscuredUrl) = splitRedactUserId(userId);
+  return '$username@$obscuredUrl';
+}

lib/features/logging/view/app_logs_page.dart

@@ -0,0 +1,282 @@
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:intl/intl.dart';
+import 'package:logger/logger.dart';
+import 'package:paperless_mobile/features/logging/cubit/app_logs_cubit.dart';
+import 'package:paperless_mobile/features/logging/models/parsed_log_message.dart';
+import 'package:paperless_mobile/core/extensions/dart_extensions.dart';
+import 'package:paperless_mobile/core/extensions/flutter_extensions.dart';
+import 'package:paperless_mobile/generated/l10n/app_localizations.dart';
+
+class AppLogsPage extends StatefulWidget {
+  const AppLogsPage({super.key});
+
+  @override
+  State<AppLogsPage> createState() => _AppLogsPageState();
+}
+
+class _AppLogsPageState extends State<AppLogsPage> {
+  final ScrollController _scrollController = ScrollController();
+
+  bool autoScroll = true;
+
+  @override
+  Widget build(BuildContext context) {
+    final locale = Localizations.localeOf(context).toString();
+    final theme = Theme.of(context);
+    return BlocBuilder<AppLogsCubit, AppLogsState>(
+      builder: (context, state) {
+        final formattedDate = DateFormat.yMMMd(locale).format(state.date);
+        return Scaffold(
+          bottomNavigationBar: BottomAppBar(
+            child: Row(
+              mainAxisAlignment: MainAxisAlignment.start,
+              children: switch (state) {
+                AppLogsStateInitial() => [],
+                AppLogsStateLoading() => [],
+                AppLogsStateLoaded() => [
+                    IconButton(
+                      tooltip: S.of(context)!.copyToClipboard,
+                      onPressed: () {
+                        context
+                            .read<AppLogsCubit>()
+                            .copyToClipboard(state.date);
+                      },
+                      icon: const Icon(Icons.copy),
+                    ).padded(),
+                    IconButton(
+                      tooltip: S.of(context)!.saveLogsToFile,
+                      onPressed: () {
+                        context
+                            .read<AppLogsCubit>()
+                            .saveLogs(state.date, locale);
+                      },
+                      icon: const Icon(Icons.download),
+                    ).padded(),
+                    IconButton(
+                      tooltip: S.of(context)!.clearLogs(formattedDate),
+                      onPressed: () {
+                        context.read<AppLogsCubit>().clearLogs(state.date);
+                      },
+                      icon: Icon(
+                        Icons.delete_sweep,
+                        color: Theme.of(context).colorScheme.error,
+                      ),
+                    ).padded(),
+                  ],
+                _ => [],
+              },
+            ),
+          ),
+          appBar: AppBar(
+            title: Text(S.of(context)!.appLogs(formattedDate)),
+            actions: [
+              if (state is AppLogsStateLoaded)
+                IconButton(
+                  tooltip: MaterialLocalizations.of(context).datePickerHelpText,
+                  onPressed: () async {
+                    final selectedDate = await showDatePicker(
+                      context: context,
+                      initialDate: state.date,
+                      firstDate: state.availableLogs.first,
+                      lastDate: state.availableLogs.last,
+                      selectableDayPredicate: (day) => state.availableLogs
+                          .any((date) => day.isOnSameDayAs(date)),
+                      initialEntryMode: DatePickerEntryMode.calendarOnly,
+                    );
+                    if (selectedDate != null) {
+                      context.read<AppLogsCubit>().loadLogs(selectedDate);
+                    }
+                  },
+                  icon: const Icon(Icons.calendar_today),
+                ).padded(),
+            ],
+          ),
+          body: switch (state) {
+            AppLogsStateLoaded(
+              logs: var logs,
+            ) =>
+              Builder(
+                builder: (context) {
+                  if (state.logs.isEmpty) {
+                    return Center(
+                      child: Text(S.of(context)!.noLogsFoundOn(formattedDate)),
+                    );
+                  }
+                  return ListView.builder(
+                    reverse: true,
+                    controller: _scrollController,
+                    itemBuilder: (context, index) {
+                      if (index == 0) {
+                        return Center(
+                          child: Text(S.of(context)!.logfileBottomReached,
+                              style: theme.textTheme.bodySmall?.copyWith(
+                                color: theme.disabledColor,
+                              )),
+                        ).padded(24);
+                      }
+                      final messages = state.logs;
+                      final logMessage = messages[index - 1];
+                      final altColor = CupertinoDynamicColor.withBrightness(
+                        color: Colors.grey.shade200,
+                        darkColor: Colors.grey.shade800,
+                      ).resolveFrom(context);
+                      return ParsedLogMessageTile(
+                        message: logMessage,
+                        backgroundColor: (index % 2 == 0)
+                            ? theme.colorScheme.background
+                            : altColor,
+                      );
+                    },
+                    itemCount: logs.length + 1,
+                  );
+                },
+              ),
+            AppLogsStateError() => Center(
+                child:
+                    Text(S.of(context)!.couldNotLoadLogfileFrom(formattedDate)),
+              ),
+            _ => _buildLoadingLogs(state.date)
+          },
+        );
+      },
+    );
+  }
+
+  Widget _buildLoadingLogs(DateTime date) {
+    final formattedDate =
+        DateFormat.yMd(Localizations.localeOf(context).toString()).format(date);
+    return Center(
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          const CircularProgressIndicator(),
+          Text(S.of(context)!.loadingLogsFrom(formattedDate)),
+        ],
+      ),
+    );
+  }
+}
+
+class ParsedLogMessageTile extends StatelessWidget {
+  final ParsedLogMessage message;
+  final Color backgroundColor;
+
+  const ParsedLogMessageTile({
+    super.key,
+    required this.message,
+    required this.backgroundColor,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return switch (message) {
+      ParsedFormattedLogMessage m => FormattedLogMessageWidget(
+          message: m,
+          backgroundColor: backgroundColor,
+        ),
+      UnformattedLogMessage(message: var m) => Text(m),
+    };
+  }
+}
+
+class FormattedLogMessageWidget extends StatelessWidget {
+  final ParsedFormattedLogMessage message;
+  final Color backgroundColor;
+  const FormattedLogMessageWidget(
+      {super.key, required this.message, required this.backgroundColor});
+  static final _timeFormat = DateFormat("HH:mm:ss.SSS");
+  @override
+  Widget build(BuildContext context) {
+    final c = Theme.of(context).colorScheme;
+
+    final icon = switch (message.level) {
+      Level.trace => Icons.troubleshoot,
+      Level.debug => Icons.bug_report,
+      Level.info => Icons.info_outline,
+      Level.warning => Icons.warning,
+      Level.error => Icons.error,
+      Level.fatal => Icons.error_outline,
+      _ => null,
+    };
+    final color = switch (message.level) {
+      Level.trace => c.onBackground.withOpacity(0.75),
+      Level.warning => Colors.yellow.shade600,
+      Level.error => Colors.red,
+      Level.fatal => Colors.red.shade900,
+      Level.info => Colors.blue,
+      _ => c.onBackground,
+    };
+
+    final logStyle = Theme.of(context).textTheme.bodyMedium?.copyWith(
+          fontFamily: 'monospace',
+          fontSize: 12,
+        );
+    final formattedMethodName =
+        message.methodName != null ? '${message.methodName!.trim()}()' : '';
+    final source = switch (message.className) {
+      '' || null => formattedMethodName,
+      String className => '$className.$formattedMethodName',
+    };
+    return Material(
+      color: backgroundColor,
+      child: ExpansionTile(
+        leading: Text(
+          _timeFormat.format(message.timestamp),
+          style: logStyle?.copyWith(color: color),
+        ),
+        title: Text(
+          message.message,
+          style: logStyle?.copyWith(color: color),
+        ),
+        trailing: Icon(
+          icon,
+          color: color,
+        ),
+        expandedCrossAxisAlignment: CrossAxisAlignment.start,
+        childrenPadding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
+        expandedAlignment: Alignment.topLeft,
+        children: source.isNotEmpty
+            ? [
+                Row(
+                  children: [
+                    const Icon(Icons.arrow_right),
+                    Flexible(
+                      child: Text(
+                        'In $source',
+                        style: logStyle?.copyWith(fontSize: 14),
+                      ),
+                    ),
+                  ],
+                ),
+                ..._buildErrorWidgets(context),
+              ]
+            : _buildErrorWidgets(context),
+      ),
+    );
+  }
+
+  List<Widget> _buildErrorWidgets(BuildContext context) {
+    if (message.error != null) {
+      return [
+        Divider(),
+        Text(
+          message.error!.error,
+          style: TextStyle(color: Colors.red),
+        ).padded(),
+        if (message.error?.stackTrace != null) ...[
+          Text(
+            message.error!.stackTrace!,
+            style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  fontFamily: 'monospace',
+                  fontSize: 10,
+                ),
+          ).paddedOnly(left: 8),
+        ],
+      ];
+    } else {
+      return [];
+    }
+  }
+}