Buscar pacotes, repositórios e categorias de apps

Detalhes do pacotev2.1.0

en_logger

O EnLogger permite que você escreva mensagens de log conforme suas necessidades, sem restringir a escrita de mensagens no console de depuração ou em outros sistemas.

AndroidiOSWebmacOSWindowsLinux
Downloads em 30 dias
141
Curtidas
4
Pontos Pub
160

Instalar pacote

flutter pub add en_logger

Visão geral do pacote

Orientação gerada a partir de informações públicas. Apenas para referência.

EnLogger é um pacote de registro flexível para aplicativos Flutter que permite aos desenvolvedores escrever mensagens de log personalizadas sem ficar restritos ao console de depuração ou a sistemas de saída específicos. Ele suporta múltiplas plataformas, incluindo Android, iOS, Web, macOS, Windows e Linux, oferecendo integração perfeita em qualquer projeto. Com seu design extensível, o EnLogger permite que os usuários definam seus próprios manipuladores de log e formatos, tornando-o ideal para depuração, monitoramento e análise. O pacote enfatiza simplicidade e controle, permitindo que os desenvolvedores ajustem o comportamento do registro conforme suas necessidades exatas.

Casos de uso

  • Depuração do fluxo do aplicativo
  • Monitoramento do comportamento em tempo de execução
  • Encaminhamento de saída de log personalizado
  • Integração com análise externa
  • Testando cenários de erro
  • Entrando em ambientes de produção

Principais recursos

  • Sistema de manipulação de logs extensível
  • Suporte para múltiplas plataformas
  • Formatação de log configurável
  • Sem dependência do console de depuração
  • Integração fácil com código existente
  • Destinos de saída flexíveis

Indicado para

  • Desenvolvedores que precisam de registro personalizado
  • Equipes que desenvolvem aplicativos multiplataforma
  • Projetos que exigem logs estruturados
  • Aplicações com necessidades complexas de depuração
  • Aplicativos com registro voltados para produção
  • Usuários evitando saídas de console codificadas

Considerações

  • Requer configuração manual de manipuladores de log
  • Sem armazenamento ou persistência de log embutidos
  • Pode ser necessário configuração adicional para casos de uso avançados
  • Não otimizado para registro de log de alta frequência
  • Recursos limitados fora da caixa em comparação com frameworks completos de registro
  • Depende da lógica definida pelo usuário para o processamento de mensagens

README original

Snapshot do README original do repositório-fonte vinculado. Consulte o repositório para o conteúdo mais recente.

En Logger

package badge pub points pub likes codecov ci badge license pub publisher

Welcome to EnLogger—a highly flexible and extensible logging system designed to adapt to your application's unique needs.

Instead of restricting you to the standard debug console, EnLogger acts as a central hub. It broadcasts your log messages to a customizable list of EnLoggerHandlers. You simply log your message once, and let your attached handlers decide where and how that data is processed.

Key Features:

  • Plug-and-Play Architecture: Log once, write anywhere. You can easily implement custom handlers based on your specific requirements:
    • Need local persistence? Implement a handler that writes logs to a local file.
    • Need remote crash reporting? Create a handler that pipes messages directly to Sentry, Crashlytics, or Datadog.
  • Lazy Evaluation: Boost your app's performance with "lazy" logging. Wrap expensive string interpolations or data serializations in closures; if the log level is disabled, the computation is completely skipped (see the Lazy messages section for details).
  • Zone: Automatically extract contextual data (tags) from Zone.current and attach them to every log event.
  • Caller info Indicates the exact location in your source code where the log was emitted
  • Syslog Standards: All log operations strictly adhere to the standard syslog severity levels (Emergency, Alert, Critical, Error, Warning, Notice, Info, Debug).
  • Ready-to-use Console Logger: Get started immediately with the included DevLogHandler, which outputs beautifully colored and formatted messages straight to your developer console.

To see these features in action, check out the example project.

Installation

dependencies:
  en_logger:

Configuration

Fast setup
  • Create en EnLogger instance: final logger = EnLogger()
  • Add handlers to your logger: logger.addHandler(DevLogHandler())
  • Write log: logger.debug('Arrived here');, logger.error('Error deserializing data')
Prefix

Logs can have a prefix. A style can be applied to this prefix.

final logger = EnLogger(defaultPrefixFormat: PrefixFormat(
    startFormat: '[',
    endFormat: ']',
    style: PrefixStyle.uppercaseSnakeCase,
  ))
  ..addHandler(DevLogHandler())
  ..debug('get data',prefix: "API repository")

  // output --> '[API_REPOSITORY] get data'
Data

Messages can include attachments such as serialized data, file contents, and more.

// error with data
logger.error(
  "error",
  data: [
    EnLoggerData(
      name: "response",
      content: jsonEncode("BE data"),
      description: "serialized BE response",
    ),
  ],
);
Instances

To avoid having to rewrite the prefix each time, you can create instances based on EnLogger. For instance, if you have a specific scope (like the API repository), you can instantiate a EnLogger with the prefix "API repository," and this prefix will be included in every log unless you explicitly override it.

final instLogger = logger.getConfiguredInstance(prefix: 'API Repository');
instLogger.debug('a debug message'); // [API Repository] a debug message
instLogger.error(
  'error',
  prefix: 'Custom prefix',
); // [Custom prefix] a debug message
Lazy messages

Lazy messages are not evaluated until at least one handler is going to write them. Use them to avoid expensive computations when a log level is disabled (e.g. in production, where debug is often turned off).

The message closure is only called when at least one handler returns true from can(severity) for that log.

logger.lazyDebug(() => 'a lazy debug message');
// The closure is not run if debug is disabled (every handler's `can` returns `false`)

By default, can returns true for every handler, so all log levels are written unless you override it.

The message callbacks (e.g. the closure passed to lazyDebug) may be asynchronous. Handle exceptions inside the callback, otherwise they are ignored.

Tags & Zones

EnLogger can automatically extract contextual data (tags) from Dart's [Zone.current] and attach them to every log event. By providing zoneContextKeys to the constructor, the logger will capture only the specified keys from the current execution zone.

Additionally, every logging method accepts its own tags parameter. The handlers will receive a single, merged, and sanitized map containing both the requested zone tags and the method-specific tags.

final logger = EnLogger(
   zoneContextKeys: {#userId},
   ...
);

runZoned(
   () {
     // In addition to the method tags, the zoneContextKeys 
     // values will be extracted from the zones
     logger
       .debug('a debug message',
          prefix: 'API Repository',
          tags: {'custom_key':'custom_value'},
          );
   },
  zoneValues: {
    #userId: 123,
    #tenantId: 'abc'
  },
 );
Caller info

callerInfo captures the exact location in your source code where a log was emitted. It provides the function name, file path, and line number (e.g., AuthRepository.login (/lib/auth_repository.dart:142:5)).

While an error stackTrace shows you where an exception crashed, callerInfo pinpoints exactly where you wrote the log statement.

Because extracting stack traces is a CPU-intensive operation, this feature is disabled by default. You can explicitly enable it when initializing EnLogger:

final logger = EnLogger(includeCallerInfo: true);
Closing the logger

When you are done using an EnLogger instance, you should clean up its resources. EnLogger provides a graceful shutdown mechanism that safely stops accepting new logs and waits for any pending asynchronous writes or lazy evaluations to finish before clearing its handlers, ensuring no data is lost.

You can trigger this shutdown using two methods depending on your architectural needs:

  • close(): The preferred, asynchronous method. You can await it to guarantee all pending logs have been fully processed and written before proceeding.
  • dispose(): A synchronous wrapper around close(). It immediately marks the logger as closed and handles the graceful shutdown in the background (fire-and-forget).

Note: Both methods are safe to call multiple times (idempotent) and automatically cascade the shutdown to any child instances created via getConfiguredInstance().

// Asynchronous (Graceful Shutdown)
await logger.close();

// Synchronous (e.g., inside Flutter lifecycle)
@override
void dispose() {
  logger.dispose();
  super.dispose();
}
DevLogHandler

A default Develop console log handler colored. There is a basic color setup that can be updated.

  final devLogHandler = DevLogHandler()
    ..configure({Severity.notice: DevLogColor.green()});

You can also create custom colors.

DevLogColor.custom(schema: '\x1B[31m')
CustomHandler
  1. Create a custom handler that extends EnLoggerHandler;

  2. Override write method with your custom write operation.

class FileHandler extends EnLoggerHandler {
  @override
  void write(String message) {
    _logToFile(message);
  }
}
  1. Override can method to filter logs to complete skip the log evaluation.
@override
bool can({required Severity severity, String? prefix}) {
  if (isProduction) {
    return severity.atLeastError; // only error and above are evaluated and written
  }
  return true; // every log is evaluated and written (default behavior)
}

Some examples are shown in the example project.

Categorias

Repositório-fonte

Projetos que usam este pacote