Line data    Source code

       1              : import 'dart:async';
       2              : import 'dart:developer' as developer;
       3              : 
       4              : import 'package:logging/logging.dart';
       5              : import 'package:the_logger/src/abstract_logger.dart';
       6              : import 'package:the_logger/src/models/models.dart';
       7              : 
       8              : /// Console logger
       9              : class ConsoleLogger extends AbstractLogger {
      10              :   /// Create console logger
      11            4 :   ConsoleLogger({
      12              :     this.loggerCallback,
      13              :     this.colors = const ConsoleColors(),
      14              :     this.formatJson = true,
      15              :   });
      16              : 
      17              :   /// Console logger callback
      18              :   final ConsoleLoggerCallback? loggerCallback;
      19              : 
      20              :   /// Console colors
      21              :   final ConsoleColors colors;
      22              : 
      23              :   /// Format JSON embedded in message and error
      24              :   final bool formatJson;
      25              : 
      26            4 :   @override
      27              :   void write(MaskedLogRecord record) {
      28            4 :     final formatted = _formatRecord(record);
      29              : 
      30            4 :     developer.log(
      31              :       formatted,
      32            4 :       time: record.time,
      33            4 :       sequenceNumber: record.sequenceNumber,
      34            8 :       level: record.level.value,
      35            4 :       name: record.loggerName,
      36            4 :       zone: record.zone,
      37              :     );
      38              : 
      39            5 :     loggerCallback?.call(
      40              :       formattedRecord: formatted,
      41            1 :       message: record.message,
      42            1 :       time: record.time,
      43            1 :       sequenceNumber: record.sequenceNumber,
      44            2 :       level: record.level.value,
      45            1 :       name: record.loggerName,
      46            1 :       zone: record.zone,
      47            1 :       error: record.error,
      48            1 :       stackTrace: record.stackTrace,
      49              :     );
      50              :   }
      51              : 
      52            4 :   String _formatRecord(MaskedLogRecord record) {
      53            4 :     final message = record.message;
      54            8 :     final error = (record.error != null ? '\n${record.error}' : '');
      55            8 :     final formattedMessage = formatJson ? message.prettyJson : message;
      56            8 :     final formattedError = formatJson ? error.prettyJson : error;
      57            8 :     final trace = record.stackTrace != null ? '\n${record.stackTrace}' : '';
      58            4 :     return _colorMessage(
      59           20 :       '''${record.level.name}: ${record.time.toIso8601String()} $formattedMessage$formattedError$trace''',
      60            4 :       record.level,
      61              :     );
      62              :   }
      63              : 
      64            4 :   String _colorMessage(String message, Level level) {
      65            4 :     final colorString = _getLevelColor(level);
      66            4 :     final resetColor = _getResetColor();
      67              : 
      68            4 :     return '$colorString$message$resetColor';
      69              :   }
      70              : 
      71            4 :   String _getLevelColor(Level level) {
      72              :     return switch (level) {
      73           12 :       Level.FINEST => colors.finest,
      74           10 :       Level.FINER => colors.finer,
      75           10 :       Level.FINE => colors.fine,
      76           10 :       Level.CONFIG => colors.config,
      77           12 :       Level.INFO => colors.info,
      78            9 :       Level.WARNING => colors.warning,
      79            9 :       Level.SEVERE => colors.severe,
      80            9 :       Level.SHOUT => colors.shout,
      81              :       _ => '',
      82              :     };
      83              :   }
      84              : 
      85           12 :   String _getResetColor() => colors.reset;
      86              : }
      87              : 
      88              : /// Console logger callback. Mostly for debugging and testing purpose.
      89              : typedef ConsoleLoggerCallback = void Function({
      90              :   required String formattedRecord,
      91              :   required String message,
      92              :   DateTime? time,
      93              :   int? sequenceNumber,
      94              :   int level,
      95              :   String name,
      96              :   Zone? zone,
      97              :   Object? error,
      98              :   StackTrace? stackTrace,
      99              : });