Adopted more common log-levels.

* Added `all`, `off`, `trace` and `fatal`.
* Deprecated `nothing`, `verbose` and `wtf`.

Author: Bungeefan

README.md

@@ -41,7 +41,7 @@ Instead of a string message, you can also pass other objects like `List`, `Map`
 You can log with different levels:
 
 ```dart
-logger.v("Verbose log");
+logger.t("Trace log");
 
 logger.d("Debug log");
 
@@ -51,7 +51,7 @@ logger.w("Warning log");
 
 logger.e("Error log");
 
-logger.wtf("What a terrible failure log");
+logger.f("What a fatal log");
 ```
 
 To show only specific log levels, you can set:
@@ -60,7 +60,7 @@ To show only specific log levels, you can set:
 Logger.level = Level.warning;
 ```
 
-This hides all `verbose`, `debug` and `info` log events.
+This hides all `trace`, `debug` and `info` log events.
 
 ## Options
 

example/main.dart

@@ -23,7 +23,7 @@ void demo() {
 
   logger.e('Error! Something bad happened', 'Test Error');
 
-  loggerNoStack.v({'key': 5, 'value': 'something'});
+  loggerNoStack.t({'key': 5, 'value': 'something'});
 
-  Logger(printer: SimplePrinter(colors: true)).v('boom');
+  Logger(printer: SimplePrinter(colors: true)).t('boom');
 }

lib/src/logger.dart

@@ -8,13 +8,25 @@ import 'package:logger/src/printers/pretty_printer.dart';
 /// [Level]s to control logging output. Logging can be enabled to include all
 /// levels above certain [Level].
 enum Level {
-  verbose,
-  debug,
-  info,
-  warning,
-  error,
-  wtf,
-  nothing,
+  all(0),
+  @Deprecated('[verbose] is being deprecated in favor of [trace].')
+  verbose(999),
+  trace(1000),
+  debug(2000),
+  info(3000),
+  warning(4000),
+  error(5000),
+  @Deprecated('[wtf] is being deprecated in favor of [fatal].')
+  wtf(5999),
+  fatal(6000),
+  @Deprecated('[nothing] is being deprecated in favor of [off].')
+  nothing(9999),
+  off(10000),
+  ;
+
+  final int levelInt;
+
+  const Level(this.levelInt);
 }
 
 class LogEvent {
@@ -48,7 +60,7 @@ class Logger {
   /// The current logging level of the app.
   ///
   /// All logs with levels below this level will be omitted.
-  static Level level = Level.verbose;
+  static Level level = Level.trace;
 
   /// The current default implementation of log filter.
   static LogFilter Function() defaultFilter = () => DevelopmentFilter();
@@ -88,8 +100,15 @@ class Logger {
   }
 
   /// Log a message at level [Level.verbose].
+  @Deprecated(
+      "[Level.verbose] is being deprecated in favor of [Level.trace], use [t] instead.")
   void v(dynamic message, [dynamic error, StackTrace? stackTrace]) {
-    log(Level.verbose, message, error, stackTrace);
+    t(message, error, stackTrace);
+  }
+
+  /// Log a message at level [Level.trace].
+  void t(dynamic message, [dynamic error, StackTrace? stackTrace]) {
+    log(Level.trace, message, error, stackTrace);
   }
 
   /// Log a message at level [Level.debug].
@@ -113,8 +132,15 @@ class Logger {
   }
 
   /// Log a message at level [Level.wtf].
+  @Deprecated(
+      "[Level.wtf] is being deprecated in favor of [Level.fatal], use [f] instead.")
   void wtf(dynamic message, [dynamic error, StackTrace? stackTrace]) {
-    log(Level.wtf, message, error, stackTrace);
+    f(message, error, stackTrace);
+  }
+
+  /// Log a message at level [Level.fatal].
+  void f(dynamic message, [dynamic error, StackTrace? stackTrace]) {
+    log(Level.fatal, message, error, stackTrace);
   }
 
   /// Log a message with [level].
@@ -124,8 +150,11 @@ class Logger {
       throw ArgumentError('Logger has already been closed.');
     } else if (error != null && error is StackTrace) {
       throw ArgumentError('Error parameter cannot take a StackTrace!');
-    } else if (level == Level.nothing) {
-      throw ArgumentError('Log events cannot have Level.nothing');
+    } else if (level == Level.all) {
+      throw ArgumentError('Log events cannot have Level.all');
+      // ignore: deprecated_member_use_from_same_package
+    } else if (level == Level.off || level == Level.nothing) {
+      throw ArgumentError('Log events cannot have Level.off');
     }
 
     var logEvent = LogEvent(level, message, error, stackTrace);

lib/src/printers/hybrid_printer.dart

@@ -18,15 +18,19 @@ class HybridPrinter extends LogPrinter {
   HybridPrinter(
     LogPrinter realPrinter, {
     LogPrinter? debug,
+    LogPrinter? trace,
+    @Deprecated('[verbose] is being deprecated in favor of [trace].')
     LogPrinter? verbose,
+    LogPrinter? fatal,
+    @Deprecated('[wtf] is being deprecated in favor of [fatal].')
     LogPrinter? wtf,
     LogPrinter? info,
     LogPrinter? warning,
     LogPrinter? error,
   }) : _printerMap = {
           Level.debug: debug ?? realPrinter,
-          Level.verbose: verbose ?? realPrinter,
-          Level.wtf: wtf ?? realPrinter,
+          Level.trace: trace ?? verbose ?? realPrinter,
+          Level.fatal: fatal ?? wtf ?? realPrinter,
           Level.info: info ?? realPrinter,
           Level.warning: warning ?? realPrinter,
           Level.error: error ?? realPrinter,

lib/src/printers/logfmt_printer.dart

@@ -7,12 +7,12 @@ import 'package:logger/src/logger.dart';
 /// ```
 class LogfmtPrinter extends LogPrinter {
   static final levelPrefixes = {
-    Level.verbose: 'verbose',
+    Level.trace: 'trace',
     Level.debug: 'debug',
     Level.info: 'info',
     Level.warning: 'warning',
     Level.error: 'error',
-    Level.wtf: 'wtf',
+    Level.fatal: 'fatal',
   };
 
   @override

lib/src/printers/prefix_printer.dart

@@ -15,12 +15,21 @@ class PrefixPrinter extends LogPrinter {
   final LogPrinter _realPrinter;
   late Map<Level, String> _prefixMap;
 
-  PrefixPrinter(this._realPrinter,
-      {debug, verbose, wtf, info, warning, error}) {
+  PrefixPrinter(
+    this._realPrinter, {
+    String? debug,
+    String? trace,
+    @Deprecated('[verbose] is being deprecated in favor of [trace].') verbose,
+    String? fatal,
+    @Deprecated('[wtf] is being deprecated in favor of [fatal].') wtf,
+    String? info,
+    String? warning,
+    String? error,
+  }) {
     _prefixMap = {
       Level.debug: debug ?? 'DEBUG',
-      Level.verbose: verbose ?? 'VERBOSE',
-      Level.wtf: wtf ?? 'WTF',
+      Level.trace: trace ?? verbose ?? 'TRACE',
+      Level.fatal: fatal ?? wtf ?? 'FATAL',
       Level.info: info ?? 'INFO',
       Level.warning: warning ?? 'WARNING',
       Level.error: error ?? 'ERROR',

lib/src/printers/pretty_printer.dart

@@ -26,21 +26,21 @@ class PrettyPrinter extends LogPrinter {
   static const singleDivider = '┄';
 
   static final levelColors = {
-    Level.verbose: AnsiColor.fg(AnsiColor.grey(0.5)),
+    Level.trace: AnsiColor.fg(AnsiColor.grey(0.5)),
     Level.debug: const AnsiColor.none(),
     Level.info: const AnsiColor.fg(12),
     Level.warning: const AnsiColor.fg(208),
     Level.error: const AnsiColor.fg(196),
-    Level.wtf: const AnsiColor.fg(199),
+    Level.fatal: const AnsiColor.fg(199),
   };
 
   static final levelEmojis = {
-    Level.verbose: '',
+    Level.trace: '',
     Level.debug: '🐛 ',
     Level.info: '💡 ',
     Level.warning: '⚠️ ',
     Level.error: '⛔ ',
-    Level.wtf: '👾 ',
+    Level.fatal: '👾 ',
   };
 
   /// Matches a stacktrace line as generated on Android/iOS devices.
@@ -120,10 +120,10 @@ class PrettyPrinter extends LogPrinter {
   /// to prevent 'boxing' of a specific level,
   /// include it with `true` in the map.
   ///
-  /// Example to prevent boxing of [Level.verbose] and [Level.info]:
+  /// Example to prevent boxing of [Level.trace] and [Level.info]:
   /// ```dart
   /// excludeBox: {
-  ///   Level.verbose: true,
+  ///   Level.trace: true,
   ///   Level.info: true,
   /// },
   /// ```

lib/src/printers/simple_printer.dart

@@ -10,21 +10,21 @@ import 'package:logger/src/logger.dart';
 /// ```
 class SimplePrinter extends LogPrinter {
   static final levelPrefixes = {
-    Level.verbose: '[V]',
+    Level.trace: '[T]',
     Level.debug: '[D]',
     Level.info: '[I]',
     Level.warning: '[W]',
     Level.error: '[E]',
-    Level.wtf: '[WTF]',
+    Level.fatal: '[FATAL]',
   };
 
   static final levelColors = {
-    Level.verbose: AnsiColor.fg(AnsiColor.grey(0.5)),
+    Level.trace: AnsiColor.fg(AnsiColor.grey(0.5)),
     Level.debug: const AnsiColor.none(),
     Level.info: const AnsiColor.fg(12),
     Level.warning: const AnsiColor.fg(208),
     Level.error: const AnsiColor.fg(196),
-    Level.wtf: const AnsiColor.fg(199),
+    Level.fatal: const AnsiColor.fg(199),
   };
 
   final bool printTime;

pubspec.yaml

@@ -4,7 +4,7 @@ version: 1.4.0
 repository: https://github.com/Bungeefan/logger
 
 environment:
-  sdk: ">=2.12.0 <4.0.0"
+  sdk: ">=2.17.0 <4.0.0"
 
 dev_dependencies:
   test: ^1.16.8

test/logger_test.dart

@@ -64,7 +64,14 @@ void main() {
 
     logger = Logger(filter: _AlwaysFilter(), printer: callbackPrinter);
 
-    var levels = Level.values.take(6);
+    var levels = [
+      Level.trace,
+      Level.debug,
+      Level.info,
+      Level.warning,
+      Level.error,
+      Level.fatal,
+    ];
     for (var level in levels) {
       var message = Random().nextInt(999999999).toString();
       logger.log(level, message);
@@ -89,9 +96,10 @@ void main() {
       expect(printedStackTrace, stackTrace);
     }
 
-    expect(() => logger.log(Level.verbose, 'Test', StackTrace.current),
+    expect(() => logger.log(Level.trace, 'Test', StackTrace.current),
         throwsArgumentError);
-    expect(() => logger.log(Level.nothing, 'Test'), throwsArgumentError);
+    expect(() => logger.log(Level.off, 'Test'), throwsArgumentError);
+    expect(() => logger.log(Level.all, 'Test'), throwsArgumentError);
   });
 
   test('Multiple Loggers', () {
@@ -111,11 +119,11 @@ void main() {
     expect(printedStackTrace, null);
   });
 
-  test('Logger.v', () {
+  test('Logger.t', () {
     var logger = Logger(filter: _AlwaysFilter(), printer: callbackPrinter);
     var stackTrace = StackTrace.current;
-    logger.v('Test', 'Error', stackTrace);
-    expect(printedLevel, Level.verbose);
+    logger.t('Test', 'Error', stackTrace);
+    expect(printedLevel, Level.trace);
     expect(printedMessage, 'Test');
     expect(printedError, 'Error');
     expect(printedStackTrace, stackTrace);
@@ -161,11 +169,11 @@ void main() {
     expect(printedStackTrace, stackTrace);
   });
 
-  test('Logger.wtf', () {
+  test('Logger.f', () {
     var logger = Logger(filter: _AlwaysFilter(), printer: callbackPrinter);
     var stackTrace = StackTrace.current;
-    logger.wtf('Test', 'Error', stackTrace);
-    expect(printedLevel, Level.wtf);
+    logger.f('Test', 'Error', stackTrace);
+    expect(printedLevel, Level.fatal);
     expect(printedMessage, 'Test');
     expect(printedError, 'Error');
     expect(printedStackTrace, stackTrace);