init static method

Future<void> init(LogConfig config)

Implementation

static Future<void> init(LogConfig config) async {
  config.validate();
  final previousLogger = _logger;
  final previousConsoleLogger = _consoleLogger;
  final previousConfig = _config;
  final previousFileOutput = _fileOutput;
  final previousInitialized = _initialized;

  IsolateFileOutput? nextFileOutput;
  Object? fileInitError;

  try {
    final consoleLevel = LevelAdapter.toLevel(config.logLevel);
    final fileLevel = LevelAdapter.toLevel(config.recordLevel);
    final outputsPretty = <LogOutput>[
      _applyOutputFilter(
        DeveloperOutput(name: 'LOG'),
        consoleLevel,
      ),
    ];
    final outputsRaw = <LogOutput>[
      _applyOutputFilter(
        DeveloperOutput(name: 'CONSOLE'),
        consoleLevel,
      ),
    ];

    if (config.canWriteToFile) {
      nextFileOutput = IsolateFileOutput(config);
      try {
        await nextFileOutput.init();
        outputsPretty.add(_applyOutputFilter(nextFileOutput, fileLevel));
        outputsRaw.add(_applyOutputFilter(nextFileOutput, fileLevel));
      } catch (e) {
        fileInitError = e;
        debugPrint(
          'File logging unavailable, falling back to console only: $e',
        );
        await _safeDestroyFileOutput(nextFileOutput);
        nextFileOutput = null;
      }
    }

    if (config.output != null) {
      outputsPretty.addAll(
        config.output!.map((output) => _applyOutputFilter(
              output,
              consoleLevel,
            )),
      );
      outputsRaw.addAll(
        config.output!.map((output) => _applyOutputFilter(
              output,
              consoleLevel,
            )),
      );
    }

    var prettyOutputs = outputsPretty;
    var rawOutputs = outputsRaw;
    if (config.composeOutputs != null) {
      prettyOutputs = config.composeOutputs!(prettyOutputs);
      rawOutputs = config.composeOutputs!(rawOutputs);
    }

    final minimumRequiredLevel = nextFileOutput != null
        ? _minimumLevel(consoleLevel, fileLevel)
        : consoleLevel;

    final nextLogger = Logger(
      filter: config.filter ?? ComLogFilter(minimumRequiredLevel),
      printer: config.printer ?? PrettyPrinter(colors: false),
      output: MultiOutput(prettyOutputs),
    );
    final nextConsoleLogger = Logger(
      filter: config.filter ?? ComLogFilter(minimumRequiredLevel),
      printer: RawPrinter(),
      output: MultiOutput(rawOutputs),
    );

    _config = config;
    _logger = nextLogger;
    _consoleLogger = nextConsoleLogger;
    _fileOutput = nextFileOutput;
    _initialized = true;
    _lastInitError = fileInitError;
    _reportedBufferedLogs = false;

    _flushPendingLogs();
    if (fileInitError != null) {
      _emitInternalWarning(
        'File logging unavailable; continuing with console output only: $fileInitError',
      );
    }

    if (previousInitialized &&
        previousFileOutput != null &&
        !identical(previousFileOutput, nextFileOutput)) {
      await _safeDestroyFileOutput(previousFileOutput);
    }
  } catch (e) {
    _logger = previousLogger;
    _consoleLogger = previousConsoleLogger;
    _config = previousConfig;
    _fileOutput = previousFileOutput;
    _initialized = previousInitialized;
    _lastInitError = e;
    if (nextFileOutput != null &&
        !identical(nextFileOutput, previousFileOutput)) {
      await _safeDestroyFileOutput(nextFileOutput);
    }
    rethrow;
  }
}