flex_logger #

A flexible, extensible logging framework for Flutter and Dart. No external logging dependency—console output, observers, and integrations are built in or provided by optional packages.

Contents #

• Features
• Packages
• Installation
• Quick Start
• Filtering
• Log Levels
• Custom Log Types
• Exception Handling
• Creating Custom Providers
• License

Features #

• Multiple Log Levels: debug, info, success, warning, error, critical
• Provider System: Extensible provider pattern for custom observers
• Flexible Filtering: Multiple filter types including level, type, and custom filters
• Composite Observers: Combine multiple logging destinations
• Custom Formatters: Customize log output format
• Exception Handling: Built-in error and stack trace support
• Packages: Optional packages for console, file, isolate, and Sentry integration

Packages #

FlexLogger is designed for any level of customization.

Package	Version	Description
flex_logger		Core logging framework with provider pattern and filtering.
flex_logger_console		Colored console output with ANSI colors.
flex_logger_file		File logging with automatic rotation.
flex_logger_isolate		Log from Dart isolates to the main logger.
flex_logger_sentry		Sentry integration for error tracking.

Installation #

Add flex_logger to your pubspec.yaml:

dependencies:
  flex_logger: ^1.0.0

Then run:

flutter pub get

Quick Start #

Basic Usage #

FlexLogger is a singleton: call configure(providers: ...), then initialize(). Call dispose() before app exit when needed.

import 'package:flex_logger/flex_logger.dart';

void main() async {
  FlexLogger.instance.configure(providers: []);
  await FlexLogger.instance.initialize();

  final logger = FlexLogger.instance;
  logger.info('Application started');
  logger.debug('Debug information');
  logger.success('Operation completed');
  logger.warning('Something might be wrong');
  logger.error('An error occurred');
  logger.critical('Critical failure');
  // await FlexLogger.instance.dispose();  // when shutting down
}

With Console Provider #

For console output, add the flex_logger_console package:

dependencies:
  flex_logger: ^1.0.0
  flex_logger_console: ^1.0.0

import 'package:flex_logger/flex_logger.dart';
import 'package:flex_logger_console/flex_logger_console.dart';

void main() async {
  FlexLogger.instance.configure(
    providers: [ConsoleLoggerProvider()],
  );
  await FlexLogger.instance.initialize();

  FlexLogger.instance.info('Application started with console logging');
}

With File Logging #

For file logging, add the flex_logger_file package:

dependencies:
  flex_logger: ^1.0.0
  flex_logger_file: ^1.0.0

import 'package:flex_logger/flex_logger.dart';
import 'package:flex_logger_file/flex_logger_file.dart';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as path;

Future<void> main() async {
  final appDocDir = await getApplicationDocumentsDirectory();
  final logPath = path.join(appDocDir.path, 'logs', 'app.log');

  FlexLogger.instance.configure(
    providers: [
      FileLoggerProvider.rotating(
        filePath: logPath,
        maxFileSize: 5 * 1024 * 1024, // 5 MB
        filter: MinLevelFilter(FlexLogLevel.info),
      ),
    ],
  );
  await FlexLogger.instance.initialize();
  FlexLogger.instance.info('Logging to file');
}

Filtering #

Set a filter when configuring a provider to control which logs it receives:

import 'package:flex_logger/flex_logger.dart';
import 'package:flex_logger_console/flex_logger_console.dart';

FlexLogger.instance.configure(
  providers: [
    ConsoleLoggerProvider(
      filter: MinLevelFilter(FlexLogLevel.warning), // Only warnings and above
    ),
  ],
);
await FlexLogger.instance.initialize();

Available filters: MinLevelFilter, TypeFilter, DevelopmentOnlyFilter, CompositeLogFilter, AcceptAllFilter, RejectAllFilter.

Log Levels #

Custom Log Types #

Create custom log types by extending FlexLog. Build the message from your fields in the constructor so it appears correctly in console, file, and observers:

class NetworkLog extends FlexLog {
  NetworkLog({
    required String url,
    required int statusCode,
    String? description,
  }) : super(
    message: '${description ?? 'HTTP'} $url [$statusCode]',
    level: statusCode >= 400 ? FlexLogLevel.error : FlexLogLevel.info,
    tag: 'HTTP',
  );
}

// Usage
FlexLogger.instance.logCustom(NetworkLog(
  url: 'https://api.example.com/data',
  statusCode: 200,
  description: 'API request successful',
));

Exception Handling #

Log exceptions with stack traces:

try {
  await riskyOperation();
} catch (e, stackTrace) {
  FlexLogger.instance.error('Operation failed: ${e.toString()}', e, stackTrace);
}

Creating Custom Providers #

Implement LoggerProvider for custom logging destinations:

class MyCustomProvider implements LoggerProvider {
  @override
  String get providerId => 'MyCustomProvider';

  @override
  Future<void> initialize() async {
    // Setup your observer
  }

  @override
  FlexObserver? createObserver() => MyCustomObserver();

  @override
  Future<void> dispose() async {
    // Cleanup resources
  }
}

class MyCustomObserver extends FlexObserver {
  @override
  Future<void> onLog(FlexLog log) async {
    // Handle the log entry
    print('Custom: ${log.message}');
  }
}

License #

MIT License - see LICENSE for details.