Logging screen implementation #163
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,8 +1,17 @@ | ||
| import 'dart:developer'; | ||
| import 'package:patta/app/log_manager.dart'; | ||
|
|
||
| /// Logs a message to both the console and the LogManager | ||
| /// | ||
| /// This function maintains backward compatibility with existing code | ||
| /// while integrating with the new logging system | ||
| void log2(String msg) { | ||
| // lazy local debugging: | ||
| print(msg); | ||
|
|
||
| // add to log manager | ||
| logManager.addLog(msg, "INFO"); | ||
|
|
||
| // the actual log message: | ||
| log(msg, level: 1, name: "app"); | ||
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,24 @@ | ||
| import 'dart:convert'; | ||
|
|
||
| /// Represents a single log entry with timestamp, message, and level information | ||
| class LogEntry { | ||
| final DateTime timestamp; | ||
| final String message; | ||
| final String level; | ||
|
|
||
| LogEntry(this.message, this.level) : timestamp = DateTime.now(); | ||
|
|
||
| @override | ||
| String toString() { | ||
| return "${timestamp.toIso8601String()}: $level: $message"; | ||
| } | ||
|
|
||
| /// Estimates the memory size of this log entry in bytes | ||
| int get estimatedSize { | ||
| // Rough estimate: | ||
| // - DateTime ~= 8 bytes | ||
| // - Each character in strings ~= 2 bytes (UTF-16) | ||
| // - Object overhead ~= 16 bytes | ||
| return 8 + (message.length * 2) + (level.length * 2) + 16; | ||
| } | ||
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,70 @@ | ||
| import 'dart:collection'; | ||
| import 'dart:developer' as developer; | ||
| import 'package:patta/app/log_entry.dart'; | ||
|
|
||
| /// A manager for application logs that maintains a queue of log entries | ||
| /// with constraints on both count and memory usage | ||
| class LogManager { | ||
| // Singleton pattern | ||
| static final LogManager _instance = LogManager._internal(); | ||
|
|
||
| factory LogManager() { | ||
| return _instance; | ||
| } | ||
|
|
||
| LogManager._internal(); | ||
|
|
||
| // Queue with size and memory constraints | ||
| final Queue<LogEntry> _logs = Queue<LogEntry>(); | ||
|
|
||
| // Constraints | ||
| static const int _maxLogCount = 1000; | ||
| static const int _maxMemoryBytes = 10 * 1024 * 1024; // 10 MB | ||
|
|
||
| // Track current memory usage | ||
| int _currentMemoryUsage = 0; | ||
|
|
||
| /// Adds a new log entry to the queue, respecting size and memory constraints | ||
| void addLog(String message, String level) { | ||
| final entry = LogEntry(message, level); | ||
| final entrySize = entry.estimatedSize; | ||
|
Member
There was a problem hiding this comment. Let's not do this. The following Feel free to push back if you think this is essential for low-power devices. |
||
|
|
||
| // Remove oldest entries if constraints would be exceeded | ||
| while ((_logs.length >= _maxLogCount) || | ||
| (_currentMemoryUsage + entrySize > _maxMemoryBytes && _logs.isNotEmpty)) { | ||
| if (_logs.isNotEmpty) { | ||
| final oldestEntry = _logs.removeFirst(); | ||
| _currentMemoryUsage -= oldestEntry.estimatedSize; | ||
| } else { | ||
| break; | ||
| } | ||
| } | ||
|
|
||
| // Add new log entry | ||
| _logs.add(entry); | ||
| _currentMemoryUsage += entrySize; | ||
|
|
||
| // Also log to developer console | ||
| developer.log(message, name: "app"); | ||
| } | ||
|
|
||
| /// Returns all logs in reverse chronological order (newest first) | ||
| List<LogEntry> getLogs() { | ||
| return _logs.toList().reversed.toList(); | ||
| } | ||
|
|
||
| /// Clears all logs | ||
| void clearLogs() { | ||
| _logs.clear(); | ||
| _currentMemoryUsage = 0; | ||
| } | ||
|
|
||
| /// Returns the current memory usage of the log queue in bytes | ||
| int get memoryUsage => _currentMemoryUsage; | ||
|
|
||
| /// Returns the current number of log entries | ||
| int get logCount => _logs.length; | ||
| } | ||
|
|
||
| // Global instance | ||
| final logManager = LogManager(); | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,119 @@ | ||
| import 'dart:async'; | ||
| import 'dart:developer' as developer; | ||
| import 'package:logging/logging.dart'; | ||
| import 'package:path_provider/path_provider.dart'; | ||
| import 'dart:io'; | ||
|
|
||
| /// A comprehensive logging system for the Pariyatti app that provides: | ||
| /// - In-memory circular buffer for recent logs | ||
| /// - File-based persistent logging with rotation | ||
| /// - Console logging for debugging | ||
| /// - Multiple severity levels (debug, info, warning, error) | ||
| class AppLogger { | ||
|
Member
There was a problem hiding this comment. Let's please name the file and class the same: |
||
| // Core logging components | ||
| static final Logger _logger = Logger('PariyattiApp'); | ||
| static bool _initialized = false; | ||
| static File? _logFile; | ||
|
|
||
| // In-memory circular buffer | ||
| static final List<String> _memoryLogs = []; | ||
| static const int _maxMemoryLogs = 1000; | ||
|
Member
There was a problem hiding this comment. If it's important that this 1000 log entry limit is the same as the other 1000 from |
||
|
|
||
| /// Initializes the logging system. Must be called before any logging operations. | ||
| static Future<void> init() async { | ||
| if (_initialized) return; | ||
|
|
||
| Logger.root.level = Level.ALL; | ||
| Logger.root.onRecord.listen((record) { | ||
| String logMessage = '${record.time}: ${record.level.name}: ${record.message}'; | ||
| if (record.error != null) { | ||
| logMessage += '\nError: ${record.error}'; | ||
| } | ||
| if (record.stackTrace != null) { | ||
| logMessage += '\nStack Trace:\n${record.stackTrace}'; | ||
| } | ||
|
|
||
| // Store in circular buffer | ||
| _memoryLogs.add(logMessage); | ||
| if (_memoryLogs.length > _maxMemoryLogs) { | ||
| _memoryLogs.removeAt(0); | ||
| } | ||
|
|
||
| // Write to persistent storage | ||
| _writeToFile(logMessage); | ||
|
Member
There was a problem hiding this comment. Since the in-memory log is the only one used in the UI (as far as I can tell), why do we bother writing the logs to disk at all? Preferably, we would only use the disk-based log for all our purposes, since I don't understand the value of the in-memory logs, and the on-disk logs could be shared in the event of a crash. At the moment, if the app crashes and then the user tries to share the logs, they are sharing the empty in-memory log, not the on-disk log which would contain the events before the crash. Let me know if this question makes sense? |
||
|
|
||
| // Output to debug console | ||
| developer.log( | ||
| record.message, | ||
| time: record.time, | ||
| level: record.level.value, | ||
| name: record.loggerName, | ||
| error: record.error, | ||
| stackTrace: record.stackTrace, | ||
| ); | ||
| }); | ||
|
|
||
| await _initLogFile(); | ||
| _initialized = true; | ||
| } | ||
|
|
||
| /// Sets up the log file with rotation support | ||
| static Future<void> _initLogFile() async { | ||
| final directory = await getApplicationDocumentsDirectory(); | ||
| _logFile = File('${directory.path}/pariyatti.log'); | ||
|
|
||
| if (!await _logFile!.exists()) { | ||
| await _logFile!.create(); | ||
| } | ||
|
|
||
| // Implement log rotation | ||
| final fileSize = await _logFile!.length(); | ||
| if (fileSize > 5 * 1024 * 1024) { | ||
| final backupFile = File('${directory.path}/pariyatti.log.bak'); | ||
| if (await backupFile.exists()) { | ||
| await backupFile.delete(); | ||
| } | ||
| await _logFile!.rename('${directory.path}/pariyatti.log.bak'); | ||
| _logFile = File('${directory.path}/pariyatti.log'); | ||
| await _logFile!.create(); | ||
| } | ||
| } | ||
|
|
||
| /// Writes a log message to the persistent log file | ||
| static Future<void> _writeToFile(String message) async { | ||
| if (_logFile != null) { | ||
| await _logFile!.writeAsString('$message\n', mode: FileMode.append); | ||
| } | ||
| } | ||
|
|
||
| // Public logging methods | ||
| static void info(String message) { | ||
| _logger.info(message); | ||
| } | ||
|
|
||
| static void warning(String message) { | ||
| _logger.warning(message); | ||
| } | ||
|
|
||
| static void error(String message, [Object? error, StackTrace? stackTrace]) { | ||
| _logger.severe(message, error, stackTrace); | ||
| } | ||
|
|
||
| static void debug(String message) { | ||
| _logger.fine(message); | ||
| } | ||
|
|
||
| /// Returns all logs in reverse chronological order | ||
| static List<String> getLogs() { | ||
| return List.from(_memoryLogs.reversed); | ||
| } | ||
|
|
||
| /// Clears both in-memory and file-based logs | ||
| static Future<void> clearLogs() async { | ||
| _memoryLogs.clear(); | ||
| if (_logFile != null && await _logFile!.exists()) { | ||
| await _logFile!.delete(); | ||
| await _initLogFile(); | ||
| } | ||
| } | ||
| } | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Why has this line changed? This PR shouldn't be changing translations for Pali Word, since that is unrelated.