[mixin_logger] support custom file content leading

Author: boyan01

packages/mixin_logger/lib/mixin_logger.dart

@@ -64,14 +64,24 @@ extension _LogLevelExtension on _LogLevel {
   }
 }
 
+///
+/// Init logger to write log to file.
+///
+/// [logDir] the directory to store log files.
+/// [fileLeading] the leading of log file content, it will be written
+///               to the first line of each log file.
 Future<void> initLogger(
   String logDir, {
   int maxFileCount = 10,
   int maxFileLength = 1024 * 1024 * 10, // 10 MB
+  String? fileLeading,
 }) async {
   assert(maxFileCount > 1, 'maxFileCount must be greater than 1');
   assert(maxFileLength > 10 * 1024, 'maxFileLength must be greater than 10 KB');
-  await platform.initLogger(logDir, maxFileCount, maxFileLength);
+  if (fileLeading != null) {
+    assert(fileLeading.length < maxFileLength, 'fileLeading is too long');
+  }
+  await platform.initLogger(logDir, maxFileCount, maxFileLength, fileLeading);
 }
 
 void v(String message) {

packages/mixin_logger/lib/src/log_file_manager.dart

@@ -8,9 +8,7 @@ import 'dart:ui';
 import 'package:flutter/foundation.dart';
 import 'package:path/path.dart' as p;
 
-class LogFileManager {
-  LogFileManager._(this._sendPort);
-
+abstract class LogFileManager {
   static LogFileManager? _instance;
 
   static LogFileManager? get instance => _instance ??= _fromOtherIsolate();
@@ -20,36 +18,63 @@ class LogFileManager {
   static LogFileManager? _fromOtherIsolate() {
     final sendPort = IsolateNameServer.lookupPortByName(_logPortName);
     if (sendPort == null) {
+      debugPrint('[mixin_logger] no logger isolate found');
       return null;
     }
-    return LogFileManager._(sendPort);
+    return _LogFileMangerForOtherIsolate(sendPort);
   }
 
   static Future<void> init(
     String logDir,
     int maxFileCount,
-    int maxFileLength,
-  ) async {
+    int maxFileLength, {
+    String? fileLeading,
+  }) async {
     final receiver = ReceivePort();
     await Isolate.spawn(
       _logIsolate,
-      [receiver.sendPort, logDir, maxFileCount, maxFileLength],
+      [
+        receiver.sendPort,
+        logDir,
+        maxFileCount,
+        maxFileLength,
+        fileLeading,
+      ],
     );
-    final sendPort = await receiver.first as SendPort;
-    final removed = IsolateNameServer.removePortNameMapping(_logPortName);
-    if (removed) {
-      debugPrint('Removed old logger isolate. this is ok if hot restarted app');
-    }
-    IsolateNameServer.registerPortWithName(sendPort, _logPortName);
-  }
+    final completer = Completer<void>();
+    receiver.listen((message) {
+      if (message is SendPort) {
+        final sendPort = message;
+        final removed = IsolateNameServer.removePortNameMapping(_logPortName);
+        if (removed) {
+          debugPrint(
+              'Removed old logger isolate. this is ok if hot restarted app');
+        }
+        IsolateNameServer.registerPortWithName(sendPort, _logPortName);
+        completer.complete();
+      } else {
+        assert(false, 'unknown message: $message');
+      }
+    });
 
-  final SendPort _sendPort;
+    return completer.future;
+  }
 
   static Future<void> _logIsolate(List<dynamic> args) async {
     final responsePort = args[0] as SendPort;
     final messageReceiver = ReceivePort();
     final dir = args[1] as String;
-    final logFileHandler = LogFileHandler(dir);
+    final maxFileCount = args[2] as int;
+    final maxFileLength = args[3] as int;
+    final fileLeading = args[4] as String?;
+
+    final logFileHandler = LogFileHandler(
+      dir,
+      maxFileCount: maxFileCount,
+      maxFileLength: maxFileLength,
+      fileLeading: fileLeading,
+    );
+    LogFileManager._instance = _LogFileManagerForLogIsolate(logFileHandler);
     messageReceiver.listen((message) {
       if (message is String) {
         logFileHandler.write(message);
@@ -58,11 +83,32 @@ class LogFileManager {
     responsePort.send(messageReceiver.sendPort);
   }
 
+  Future<void> write(String message);
+}
+
+class _LogFileMangerForOtherIsolate implements LogFileManager {
+  _LogFileMangerForOtherIsolate(this._sendPort);
+
+  final SendPort _sendPort;
+
+  @override
   Future<void> write(String message) async {
     _sendPort.send(message);
   }
 }
 
+class _LogFileManagerForLogIsolate implements LogFileManager {
+  _LogFileManagerForLogIsolate(this.handler);
+
+  final LogFileHandler handler;
+
+  @override
+  Future<void> write(String message) {
+    handler.write(message);
+    return Future.value();
+  }
+}
+
 final _fileNameRegex = RegExp(r'^log_\d+.log$');
 final _fileNumberExtractRegex = RegExp(r'(?<=_)\d+(?=.log)');
 
@@ -73,6 +119,7 @@ class LogFileHandler {
     this.directory, {
     this.maxFileCount = 10,
     this.maxFileLength = 1024 * 1024 * 10, // 10 MB
+    this.fileLeading,
   })  : assert(maxFileCount >= 1),
         assert(maxFileLength >= 0) {
     final dir = Directory(directory);
@@ -108,10 +155,12 @@ class LogFileHandler {
 
   void _prepareOutputFile() {
     final File outputFile;
+    var newFileCreated = false;
     if (files.isEmpty) {
       final file = File(p.join(directory, _generateFileName(0)));
       files[0] = file;
       outputFile = file;
+      newFileCreated = true;
     } else {
       final max = files.keys.reduce(math.max);
       final file = files[max];
@@ -123,6 +172,7 @@ class LogFileHandler {
         final file = File(p.join(directory, _generateFileName(nextIndex)));
         files[nextIndex] = file;
         outputFile = file;
+        newFileCreated = true;
       }
       if (files.length > maxFileCount) {
         final min = files.keys.reduce(math.min);
@@ -142,6 +192,10 @@ class LogFileHandler {
     }
     _logFile = outputFile;
     _currentFileLength = outputFile.lengthSync();
+    if (newFileCreated && fileLeading != null) {
+      write(fileLeading!);
+      write('\n');
+    }
   }
 
   final String directory;
@@ -155,6 +209,8 @@ class LogFileHandler {
 
   final int maxFileLength;
 
+  final String? fileLeading;
+
   void write(String message) {
     assert(_logFile != null, 'Log file is null');
     final bytes = utf8.encode('$message\n');

packages/mixin_logger/lib/src/write_log_to_file_io.dart

@@ -12,6 +12,12 @@ Future<void> initLogger(
   String logDir,
   int maxFileCount,
   int maxFileLength,
+  String? fileLeading,
 ) async {
-  await LogFileManager.init(logDir, maxFileCount, maxFileLength);
+  await LogFileManager.init(
+    logDir,
+    maxFileCount,
+    maxFileLength,
+    fileLeading: fileLeading,
+  );
 }

packages/mixin_logger/lib/src/write_log_to_file_web.dart

@@ -8,4 +8,5 @@ Future<void> initLogger(
   String logDir,
   int maxFileCount,
   int maxFileLength,
+  String? fileLeading,
 ) async {}

packages/mixin_logger/test/mixin_logger_test.dart

@@ -117,7 +117,7 @@ void main() {
     expect(fileContent, equals('test\n'));
   });
 
-  test('test write on other isolate', () async {
+  test('test write in other isolate', () async {
     await LogFileManager.init(dir, 10, 1024 * 1024 * 10);
     final manger = LogFileManager.instance!;
     await manger.write('main');
@@ -136,6 +136,21 @@ void main() {
     final fileContent = File(p.join(dir, 'log_0.log')).readAsStringSync();
     expect(fileContent, contains('after initLogger\n'));
   });
+
+  test('write file leading', () async {
+    await LogFileManager.init(dir, 10, 200, fileLeading: 'file_leading_test');
+
+    for (var i = 0; i < 100; i++) {
+      LogFileManager.instance!.write('test $i');
+    }
+    await Future.delayed(const Duration(milliseconds: 1000));
+    final fileContent = File(p.join(dir, 'log_0.log')).readAsStringSync();
+    expect(fileContent, startsWith('file_leading_test'));
+    final fileContent1 = File(p.join(dir, 'log_1.log')).readAsStringSync();
+    expect(fileContent1, startsWith('file_leading_test'));
+    final fileContent2 = File(p.join(dir, 'log_2.log')).readAsStringSync();
+    expect(fileContent2, startsWith('file_leading_test'));
+  });
 }
 
 void _writeLog(String message) {