outr/scribe

Scribe is a high-performance, multi-platform logging framework for Scala that supports JVM, JavaScript, and Native environments. It provides a flexible architecture with asynchronous logging, rich formatting options, and extensive integration capabilities for SLF4J, Log4j, and Cats Effect. The system features advanced filtering, MDC context management, and specialized writers for file, console, and Slack output.

23 changes.

This period focused on a major architectural overhaul of the Scribe logging core, introducing a redesigned LogRecord system, flexible handler builders, and a new formatting DSL. It simultaneously expanded platform coverage by adding native support for Scala.js and Scala Native, while integrating with functional libraries like Cats Effect and external services such as Slack.

18 changes.

This period focused on expanding Scribe's capabilities across JVM, Scala Native, and functional programming ecosystems by adding cats-effect support and platform-specific shutdown hooks. It also introduced comprehensive bridges for SLF4J 2.0, Log4j, and Java Util Logging, alongside a new DSL for log filtering and enhanced file logging APIs.

8 changes.

This period focused on expanding the Scribe logging framework with extensible JSON support through multiple serialization libraries (Fabric, Circe) and a base trait for custom implementations. It also introduced a new TUI overlay system for rendering persistent terminal elements like progress bars and banners alongside log output. Comprehensive test coverage was added to ensure reliability across JS/JVM platforms, particularly for asynchronous logging and MDC thread safety.

Users can now log structured data using the Circe JSON library. This change introduces the \ScribeCirceJsonSupport\ trait, which implements the \ScribeJsonSupport\ interface to serialize log records (including level, message, MDC, and stack traces) into Circe \Json\ objects. A corresponding test suite (\JsonWriterSpec\) verifies that simple messages, exceptions, and pre-formed Circe JSON objects are correctly logged and formatted.

jsonCirce/shared · high confidence

The JPL module now bridges Java's standard \java.util.logging\ API to the Scribe logging framework. By registering \scribe.jpl.ScribeSystemLoggerFinder\ via the \META-INF/services\ mechanism, applications using \System.getLogger\ will automatically route their logs through Scribe, allowing standard Java logging calls to be handled by Scribe's handlers and formatters.

jpl · high confidence

Users can now integrate Scribe with applications using log4j by adding this module as a dependency. The change introduces a log4j Provider implementation that intercepts log4j API calls and redirects them to Scribe's logging infrastructure, allowing existing log4j-based code to output logs through Scribe without modification.

log4j · high confidence

New benchmarking utilities have been added to the \scribe/benchmark\ package to measure and compare logging performance. \LoggingSpeedBenchmark\ uses JMH to benchmark throughput and latency for Scribe variants (including async and effect-based modes) against external libraries like Log4j, Log4cats, Log4s, Logback, TinyLog, and ScalaLogging. \PerformanceBenchmark\ isolates Scribe's internal overhead for trace, debug, info, and error levels. Additionally, \LoggingStressTest\ and \LoggingVisualizations\ provide tools for stress-testing hierarchical logger structures and visualizing initialization, runtime, and disposal metrics for file logging scenarios.

benchmarks/src/main/scala/scribe/benchmark · high confidence

A new JULHandler component has been introduced in the scribe.jul package, enabling Scribe to act as a backend for Java Util Logging. This handler bridges Java's java.util.logging framework to Scribe by mapping Java log levels (such as FINE, INFO, and SEVERE) to corresponding Scribe levels (Trace, Info, Error) and forwarding log records, allowing applications using Java's standard logging to be captured by Scribe's logging infrastructure.

core/shared/src/main/scala/scribe/jul · high confidence

This change introduces a new \JavaScriptConsole\ facade to access browser and Node.js console methods (log, error, warn, info, etc.) and updates the \Platform\ object for Scala.js to use this facade. It configures the default console writer to \BrowserConsoleWriter\ and selects an appropriate output format (\RichBrowserOutputFormat\ for browsers, standard for Node.js), enabling better integration with JavaScript environments and supporting ANSI/ASCII output where applicable.

core/js/src/main/scala/scribe · high confidence

This change introduces a new SLF4J binding module that allows applications using the SLF4J API to route their log calls directly to the Scribe logging engine. It provides an SLF4J LoggerFactory implementation that delegates to Scribe loggers, a helper object to translate SLF4J formatting tuples into Scribe LogRecords, and an MDC adapter that synchronizes SLF4J MDC context with Scribe's MDC system, enabling seamless integration for users migrating to or using Scribe as their underlying logging provider.

slf4j/src/main/scala/scribe · high confidence

Users can now serialize Scribe log records to JSON using the Fabric library. This new \ScribeFabricJsonSupport\ trait implements the necessary serialization logic, converting log details such as level, message, MDC data, and trace information into a structured JSON format.

jsonFabric/shared · high confidence

Introduced \AtomicLongExtras\ and an implicit conversion in the \scribe.handler\ package to provide lock-free, thread-safe operations on \AtomicLong\ instances. This enables handlers to perform atomic modifications, increments, decrements, and conditional updates (such as incrementing only if below a maximum) without explicit locking, supporting the performance optimizations and file size rolling logic required by the asynchronous logging infrastructure.

core/jvm/src/main/scala/scribe/handler · high confidence

The benchmark suite now includes dedicated tester implementations for Log4Cats, Log4j, Log4s, Logback, ScalaLogging, TinyLog, and various Scribe configurations (sync, async, and effect-based). These new files define how each library is initialized, how messages are processed during the benchmark run, and how resources are cleaned up, allowing for direct performance comparison between Scribe and other popular Scala logging solutions.

benchmarks/src/main/scala/scribe/benchmark/tester · high confidence

New configuration files have been added to the benchmarks resources to support performance testing of various logging libraries. This includes an Akka configuration to disable dead-letter logging, a Log4j2 configuration defining console and asynchronous file appenders with trace-level logging, and a Logback configuration setting up a file appender with info-level logging.

benchmarks/src/main/resources · high confidence

The Scala Native implementation now registers a native exit hook via \stdlib.atexit\ to ensure that registered shutdown hooks are executed when the application terminates. This change introduces a new \Platform.scala\ file in the native module that manages a list of callbacks, allowing users to register cleanup actions that will reliably run during process shutdown, addressing previous gaps in shutdown behavior for this platform.

fileModule/native · high confidence

Introduces a new \Scribe\ trait and \LoggerWrapper\/\ScribeImpl\ classes in the \cats/shared\ module to provide a \cats-effect\ compatible logging API. This allows users to perform logging operations within \F\[\_\]\ effect types using \cats.effect.Sync\, enabling asynchronous and non-blocking log writes via \sync.delay\ and \sync.defer\.

cats/shared/src/main · high confidence

The migration module now automatically detects and loads a single \log4j.properties\ file (from the filesystem or classpath) to configure Scribe logging. It maps Log4j appenders to Scribe handlers, applies level filters to specific loggers and the root logger, and supports the FATAL level, allowing users to transition their existing Log4j configuration to Scribe without manual code changes.

migration/src/main · high confidence

This change introduces the foundational build infrastructure for the Scribe logging framework. It adds shell scripts for running benchmarks, local publishing, and testing, alongside a comprehensive Scalastyle configuration for code quality checks. CI/CD is established through a GitHub Actions workflow, a Mergify configuration to automate merging dependency updates from scala-steward, and a JitPack build script. The project's README is also significantly expanded to include availability details, quick-start instructions, and feature overviews.

(repo-wide) · high confidence

The configuration module now integrates with the Moduload system to automatically load ScribeConfig. A new \moduload.list\ resource file registers \scribe.ScribeConfig\, and a corresponding test verifies that the configuration is successfully loaded upon initialization.

config · high confidence

The \overlay/shared\ module now provides a new TUI overlay system that allows applications to render persistent UI elements like progress bars and banners directly in the terminal alongside log output. This framework intercepts standard output and scribe log handlers to route text into a scrollable region, keeping overlay entries fixed at the bottom of the screen. It supports two rendering modes: a relative mode compatible with all terminals (including IDE consoles) and a scroll-region mode for standard terminals that enables floating banners. The module includes a demo application demonstrating concurrent progress bars and dynamic banners, along with the underlying terminal interaction and ANSI styling utilities.

overlay/shared · high confidence

The json/shared module now provides the ScribeJsonSupport trait, which allows users to define custom JSON implementations for logging. This trait exposes a jsonExtras method that can be overridden to modify the resulting JSON structure, enabling users to inject additional fields or alter the output format before it is written to the log.

json/shared · high confidence

The library now supports running on Scala Native, providing a dedicated Platform implementation that configures the default console writer to use SystemWriter and sets the terminal column width to 120 (plus any adjustment). This enables native applications to utilize the existing ANSI and ASCII output format support for colored or plain-text logging, ensuring consistent behavior with JVM and JS platforms.

core/native · high confidence

The JVM-specific file logging implementation now ensures that log resources are properly cleaned up when the application terminates by registering a shutdown hook via the new \Platform\ object. Additionally, the module introduces extensive test coverage for file logging behaviors, including a new \FileLoggingSpec\ that validates simple, date-formatted, and rolling log file creation, as well as a \StressTestFileLogging\ utility to verify performance under high-volume logging conditions.

fileModule/jvm · high confidence

Users can now compose log filters using && (AND) and \|\| (OR) operators, allowing multiple conditions to be combined into a single filter. The update introduces a new DSL via the scribe.filter package object, exposing level, packageName, and className filters. These filters support matching strategies such as exact match, contains, startsWith, endsWith, and regex, enabling more granular control over which log records are processed.

core/shared/src/main/scala/scribe/filter · high confidence

The \scribe.output\ package now provides a fluent DSL for constructing formatted log messages. Users can apply foreground and background colors (including bright variants) to text, and combine multiple outputs using the \out\ helper. Additionally, the DSL supports adding bold, italic, underline, and strikethrough styles, as well as wrapping text in hyperlinks via the \url\ function, allowing for richer console output formatting.

core/shared/src/main/scala/scribe/output · high confidence

A new SlackWriter component has been added to the scribe-slack module, enabling users to send log messages directly to Slack. This writer integrates with the existing logging infrastructure by accepting LogRecord, LogOutput, and OutputFormat parameters, allowing for flexible formatting and emoji customization when posting messages via the Slack API.

slack · high confidence

The file logging module now exposes a new fluent API for constructing log file paths and configuring rolling behavior. Users can build file names using time-based parts (second, minute, hour, day, month, year) and apply rolling strategies via the \rolling\ and \rollingGZIP\ functions. The \rolling\ function now defaults to truncating files rather than moving them, and allows configuration of validation frequency to optimize performance. Implicit conversions simplify path construction by allowing strings, Files, and Paths to be used directly in path builders.

fileModule/shared/src/main/scala/scribe/file · high confidence

The file logging module now includes two new writer implementations: IOLogFileWriter, which uses standard Java IO (FileWriter/PrintWriter), and NIOLogFileWriter, which uses NIO FileChannels for potentially better performance. A new LogFileWriter trait and factory are introduced to allow selecting between these implementations. This change supports the goal of avoiding too many open files by providing alternative writing strategies.

fileModule/shared/src/main/scala/scribe/file/writer · high confidence

Added a new \scribe-cats\ module (\cats/shared/src/main/scala/scribe/cats.scala\) that provides integration with the Cats Effect library. This includes an \Scribe\[IO\]\ instance for logging within \IO\ effects, a generic \effect\[F\[\_\]\]\ instance for any \Sync\ type, and convenience extensions for timing operations. Users can now use \IO.timed\ to measure execution duration and log it, or use the \Timer\ class to log elapsed time and time since the previous log call, facilitating performance monitoring within functional effects.

repository · high confidence

Added \Abbreviator\ to support complex string abbreviation in log formatting, including options for controlling separator characters, removing entries, and abbreviating names, and introduced \Time\ to provide a replaceable abstraction for retrieving the current time, which facilitates testing and supports file logging features.

core/shared/src/main/scala/scribe/util · high confidence

Logs in the browser now support rich formatting, including colors, background colors, bold, italic, underline, and strikethrough styles, as well as clickable URLs. This is achieved by introducing a new BrowserConsoleWriter that targets the JavaScript console and a RichBrowserOutputFormat that translates Scribe's LogOutput structure into CSS arguments for the console API, replacing the previous plain-text-only approach.

core/js/src/main/scala/scribe/writer · high confidence

Added a new bridge module that allows applications using SLF4J 2.0 to route their logging calls to the Scribe logging library. This includes a service provider configuration, a logger factory, an MDC adapter for context mapping, and helper utilities to translate SLF4J API calls into Scribe log records.

slf4j2/src/main · high confidence

The logging library now includes dedicated \ANSIOutputFormat\ and \ASCIIOutputFormat\ implementations to handle colored and plain-text logging respectively. The ANSI format uses thread-local state to manage formatting attributes (colors, bold, italic, etc.) safely across concurrent threads, ensuring that ANSI escape codes do not leak between log lines or into plain-text outputs. The \OutputFormat\ trait has been updated to support initialization hooks, allowing formats to inject prefix information (such as HTML headers) at the start of output streams.

core/shared/src/main/scala/scribe/output/format · high confidence

The JVM-specific platform implementation now provides a centralized abstraction for console dimensions (columns and rows) and execution context. It detects terminal size by executing a shell script (using \tput\) with caching to avoid frequent overhead, and exposes the global Scala \ExecutionContext\. This replaces previous platform-specific wiring with a unified \Platform\ object that defines common behaviors like \isJVM\ and \consoleWriter\ for the JVM target.

core/jvm/src/main/scala/scribe · high confidence

The LogModifier trait has been updated to include a \priority\ field and an \id\ identifier. This allows multiple modifiers attached to the same Logger to be automatically sorted by priority and enables replacement of existing modifiers by their unique ID. The \alwaysApply\ method is now available to create modifiers that apply regardless of ID conflicts, and an implicit ordering ensures correct execution order based on priority.

core/shared/src/main/scala/scribe/modify · high confidence

The MDC (Mapped Diagnostic Context) subsystem has been restructured to support pluggable backends. A new \MDCManager\ trait and \MDC\ trait define the interface, allowing users to replace the default \MDCThreadLocal\ implementation with alternative strategies via the \MDC.manager\ and \MDC.creator\ variables. This change introduces a breaking change to the \contextualize\ method signature, which now requires an explicit \MDC\ instance argument rather than accepting key-value pairs directly.

core/shared/src/main/scala/scribe/mdc · high confidence

The core logging API has been significantly restructured to improve flexibility and performance. The \LogRecord\ data structure has been simplified into a case class and now supports a \LogFeature\ system, allowing users to apply functional transformations (such as adding data, boosting priority, or overriding thread/time) to log records before they are processed. A new \Loggable\ typeclass enables custom formatting for any type via \LogOutput\, replacing previous message handling mechanisms. Additionally, the library now uses \sourcecode\ for compile-time tracing of file names, line numbers, and class names, and introduces a \Priority\ system for handler ordering. New components like \LogRecordCreator\ allow for custom record instantiation, while \LoggerSupport\ provides the unified interface for all logging methods (trace, debug, info, etc.) with integrated MDC support.

core/shared/src/main/scala/scribe · high confidence

The logging system introduces a new \Writer\ trait that accepts \LogRecord\, \LogOutput\, and \OutputFormat\ parameters, replacing the previous interface. This change includes new concrete writers: \ConsoleWriter\ delegates to platform-specific implementations, \SystemWriter\ automatically routes logs to \System.out\ for levels at or below Info and to \System.err\ for higher levels, and dedicated \SystemOutWriter\ and \SystemErrWriter\ allow explicit stream selection. Additionally, \CacheWriter\ and \NullWriter\ are added to support buffering and discarding logs respectively.

core/shared/src/main/scala/scribe/writer · high confidence

The logging format system now includes new \AbbreviateBlock\ and \CachingFormatBlock\ components to support abbreviated text output and time-based caching for performance. The \Formatter\ trait has been expanded with several predefined styles: \simple\, \colored\, \classic\, \compact\, \enhanced\, \advanced\, \advancedTabbed\, and \strict\. The default formatter has been changed to \advanced\, which provides a multi-line output with auto-wrapping for messages and MDC data, addressing previous issues with indentation when copying console output. Additionally, a \RightPaddingBlock\ is now available for aligning formatted output.

core/shared/src/main/scala/scribe/format · high confidence

The logging handler system has been restructured to improve extensibility and performance. A new \LogHandlerBuilder\ is introduced to simplify the creation of standard handlers, while \LogHandler\ now explicitly accepts \Formatter\, \Writer\, \OutputFormat\, and \LogModifier\ components. The synchronous logging path is now mediated by \SynchronousLogHandle\, which applies modifiers and formatting before writing. Additionally, a \FunctionalLogHandler\ allows for custom logging logic via a function, and \LevelFilter\ is now set to high priority to prevent ordering issues during handler insertion.

core/shared/src/main/scala/scribe/handler · high confidence

The internal message handling in the core logging module has been restructured to introduce dedicated message types: EmptyMessage for empty logs, LazyMessage for deferred evaluation, and LoggableMessage as the base trait with implicit conversions for strings, string lists, and throwables. This change replaces the previous LoggableMessage argument structure with a more flexible LogFeature-based approach, allowing for better separation of concerns and improved handling of multiple messages and throwables within log records.

core/shared/src/main/scala/scribe/message · high confidence

The SLF4J binding implementation in the slf4j module has been rewritten from Java to Scala. The new StaticLoggerBinder.scala file now provides the LoggerFactoryBinder interface, allowing applications using the SLF4J API to route their logging calls to the Scribe logger implementation.

slf4j/src/main/scala/org · high confidence

The slf4j module now correctly binds to the Scribe MDC adapter via a new StaticMDCBinder, ensuring that MDC (Mapped Diagnostic Context) values are properly accessible for logging. This resolves a bug where MDC data was not being handled correctly, allowing users to include MDC entries in their log outputs when using the slf4j bridge.

slf4j/src/main/java · high confidence

Added SLF4J integration tests; Added comprehensive logging tests for JS/JVM platforms; Added tests for JSON logging output; Added tests for Log4J to Logback migration configuration; Added tests for SLF4J integration and MDC handling; Added tests for Scribe integration with cats-effect; Added tests for asynchronous logging and MDC thread safety; Added unit tests for core logging features.

This release updates the build configuration to Scala 3.3.7 (with 3.8.2 for specific modules) and bumps key dependencies including cats-effect to 3.7.0, scalatest to 3.2.20, log4j to 2.25.4, and circe to 0.14.15, ensuring compatibility with the latest library versions and platform support.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 66.

• Code Health 95
• Architecture 100
• Maturity 59
• Readiness 70
• Security 62

• 300 commits — 284 feature/other, 16 fixes

• (repo) — 136 commits
• (root) — 97 commits
• project/plugins.sbt — 33 commits
• project/build.properties — 10 commits
• core/shared — 6 commits
• jpl/src — 4 commits
• .github/workflows — 3 commits
• rapid/shared — 2 commits
• slack/src — 2 commits
• core/js-jvm — 1 commit
• core/jvm — 1 commit
• fileModule/shared — 1 commit
• json/shared — 1 commit
• jsonCirce/shared — 1 commit
• logstash/src — 1 commit
• overlay/shared — 1 commit

• fix: Cleanup and fixes for dependency updates
• fix: Couple fixes
• fix: Fix HTML output test to dynamically handle timezone-sensitive timestamps
• fix: Fix dependencies to be platformed and fix newly enabled tests
• fix: Fix for ScalaNative test running
• fix: Fix scala-collection-compat for Scala Native
• fix: Fix to rollPaths to use move instead of copy+truncate (Resolves #756)
• fix: Fixed ISO8601 to supply the current timezone code instead of always Z (Resolves #573)
• fix: Fixes SlackWriter to actually evaluate the IO.
• fix: Fixes and cleanup for ANSI support
• fix: Fixes for version changes
• fix: Merge pull request #592 from lolgab/fix-collection-compat
• fix: Merge pull request #593 from lolgab/fix-tests-js-native
• fix: Merge pull request #798 from 2m/fix/enable-cats-native-2m
• fix: Merge remote-tracking branch 'origin/master' into fix-tests-js-native
• fix: Update perfolation to 1.3.0, improve timestamp formatting logic, and fix HTML output in tests
• change: .
• change: Add Java Platform Logging module
• change: Add Slack and Logstash module support to builds, tests, and publishing
• change: Add loggerName FormatBlock, extend LogRecord, and update related tests and version to 3.19.0-SNAPSHOT
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

outr/scribe was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.