Skip to content
CAI
Software that uses CAICheck a score

outr/scribe

58.6

Adequate · 6 November 2026

6.6k

lines of production code

Scala

with Java

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Scribe is a high-performance, multi-platform logging library for the Scala ecosystem, supporting JVM, Scala.js, and Scala Native. It provides a flexible architecture with asynchronous and caching handlers, rich formatting options, and extensible output writers for consoles, files, and Slack. The system integrates seamlessly with major logging bridges like SLF4J, Log4j, and Java Util Logging, while offering deep integration with functional programming libraries such as Cats Effect.

How it got here

2016–2018 — Core architecture refactoring and multi-platform support

23 changes.

This period focused on a major refactoring of the core logging architecture, introducing a flexible data model, priority-based modifiers, and a new fluent handler builder. It significantly expanded platform coverage by adding native support for Scala.js and Scala Native, alongside enhanced terminal formatting and rich browser console integration. The work also established robust integration points for SLF4J and Cats Effect, while implementing asynchronous logging and comprehensive performance benchmarks.

2019–2022 — Extensibility and ecosystem integration

18 changes.

This period focused on expanding Scribe's capabilities through a modular architecture, introducing extensible output formatting, composable filter DSLs, and pluggable MDC backends. Significant effort was dedicated to ecosystem integration by implementing bridges for SLF4J 2.0, Log4j, Java Util Logging, and cats-effect, alongside tools for automatic Log4j migration. The work also included robust platform support for JVM and Scala Native shutdown hooks, comprehensive benchmarking, and internal refactoring of message handling to improve performance and flexibility.

2023–2026 — Extensible JSON and TUI integration

8 changes.

The project expanded its logging capabilities by introducing extensible JSON support through multiple serialization libraries (Fabric, Circe) and integrating with the Java Platform Logging API. Concurrently, a new TUI overlay framework was added to enable rich terminal user interfaces with features like progress bars and fixed banners.

Features

Add Circe-based JSON serialization for log records

Users can now serialize structured log data to JSON using the Circe library. This change introduces the \ScribeCirceJsonSupport\ trait, which implements the \ScribeJsonSupport\ interface to convert \LogRecord\ instances (including level, message, file/line details, MDC data, and stack traces) into Circe \Json\ objects. A corresponding test suite (\JsonWriterSpec\) validates that log messages, exceptions, and pre-existing Circe JSON objects are correctly serialized.

jsonCirce/shared · high confidence

Add SLF4J bridge for Scribe logging

Introduces a new SLF4J bridge module that allows applications using the SLF4J API to route their logging calls to the Scribe logging framework. This includes an SLF4J LoggerFactory implementation, an MDC adapter for mapping SLF4J MDC context to Scribe's MDC, and helper classes to translate SLF4J log records into Scribe's internal LogRecord format, enabling seamless integration for users migrating from or interoperating with SLF4J-based libraries.

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

Add log4j bridge to redirect log4j calls to Scribe

Users can now integrate Scribe with applications using log4j by adding this module; log4j logging calls are automatically redirected to Scribe's logging infrastructure via a new Provider service registration and context factory implementation.

log4j · high confidence

Added JULHandler to bridge Java Util Logging to Scribe

A new JULHandler has been added to the scribe.jul package, enabling Java Util Logging (JUL) records to be routed directly into Scribe. This handler maps JUL log levels to Scribe levels, resolves the target logger based on the record's name (defaulting to the root logger if absent), and formats the log message by substituting placeholders with parameters from the JUL record. It also ensures that any associated exceptions are logged alongside the message.

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

Added JavaScript console integration and platform abstraction for Scala.js

This change introduces a new \Platform\ object for the Scala.js target that abstracts environment detection (distinguishing between Node.js and browsers) and configures the default logging output. It adds a \JavaScriptConsole\ facade to map scribe's logging levels to the native browser/Node.js console methods (\log\, \info\, \warn\, \error\, etc.) and sets \BrowserConsoleWriter\ as the default writer. Additionally, it defines a \RichBrowserOutputFormat\ for browser environments to support colored output, ensuring that logs are written directly to the JavaScript console with appropriate formatting and severity mapping.

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

Added ScribeFabricJsonSupport for JSON serialization via Fabric

A new ScribeFabricJsonSupport trait has been introduced to enable JSON serialization of log records using the Fabric library. This implementation converts Scribe LogRecord objects into Fabric Json structures, handling levels, messages, MDC data, traces, and timestamps, and allows for JSON output customization through the jsonExtras method.

jsonFabric/shared · high confidence

Added benchmark testers for multiple logging frameworks

The benchmark suite now includes dedicated tester implementations for Log4Cats, Log4j, Log4s, Logback, ScalaLogging, TinyLog, and three Scribe variants (standard, async, and effect-based). These new files define the \LoggingTester\ trait and concrete classes that initialize, run, and dispose of each logging library, enabling performance comparisons against Scribe.

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

Added configuration files for benchmarking logging frameworks

New configuration files have been added to the benchmarks resource directory 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

Added logging performance benchmarks and stress tests

New benchmarking tools have been added to the \scribe/benchmark\ module to measure logging performance. This includes JMH-based benchmarks (\LoggingSpeedBenchmark\, \PerformanceBenchmark\) that compare Scribe against other libraries like Log4j, Log4cats, Log4s, Logback, and Tinylog, as well as a stress test utility (\LoggingStressTest\) and a visualization tool (\LoggingVisualizations\) for analyzing throughput and file I/O metrics.

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

Added platform-specific shutdown hook support for Scala Native

The Scala Native implementation now includes a dedicated Platform module that registers an exit handler via \stdlib.atexit\ to execute registered shutdown hooks. This ensures that cleanup tasks added via \addShutdownHook\ are reliably triggered when the application terminates, addressing previous gaps in platform-specific lifecycle management.

fileModule/native · high confidence

Adds cats-effect integration for asynchronous logging

Introduces a new \Scribe\ trait and implementation classes (\LoggerWrapper\, \ScribeImpl\) in the \cats/shared\ module to integrate the Scribe logging library with \cats-effect\. This change enables asynchronous, effect-safe logging by wrapping synchronous \Logger\ calls within \Sync\[F\]\ contexts using \sync.delay\ and \sync.defer\, allowing applications to perform logging operations within \F\[\_\]\ effect types without blocking.

cats/shared/src/main · high confidence

Automatic migration from Log4j 1.x properties to Scribe

The migration module now automatically detects and converts existing \log4j.properties\ files to Scribe configuration. It supports loading the properties file from the local filesystem or the classpath, parses standard Log4j appender and logger definitions, and applies the corresponding log levels and handlers to the Scribe logger hierarchy. This allows applications to transition their logging configuration without manual rewriting.

migration/src/main · high confidence

Extensible JSON support via ScribeJsonSupport trait

The json/shared module now provides a ScribeJsonSupport trait that allows users to define custom JSON implementations for logging. This trait exposes methods to convert log records to JSON, serialize JSON to strings, and crucially, override the resulting JSON via a new jsonExtras method, enabling users to inject additional fields or modify the output structure before serialization.

json/shared · high confidence

Initial Scribe configuration integration via Moduload

The application now includes a preliminary configuration mechanism for Scribe logging, implemented as a new \ScribeConfig\ module that integrates with the Moduload framework. A \moduload.list\ file registers this module, and the \ScribeConfig\ object initializes the Profig configuration system upon loading, marking the config as loaded even though full configuration mapping is currently marked as a TODO.

config/src/main · high confidence

Initial project setup with CI, publishing, and documentation

This change introduces the foundational infrastructure for the Scribe logging library, including CI configuration via GitHub Actions and Mergify, build and publishing scripts for JVM, Scala.js, and Scala Native, and a comprehensive README with usage examples and dependency instructions. It also adds a JVM options file for benchmarking, a Scalastyle configuration for code quality, and updates the .gitignore to reflect the new project structure.

(repo-wide) · high confidence

Integrate Scribe as the Java Platform Logging (JPL) implementation

Scribe now serves as the backend for the Java Platform Logging API (JPL). By registering the \ScribeSystemLoggerFinder\ via the \java.lang.System$LoggerFinder\ service provider interface, standard Java applications using \System.getLogger\ will automatically route their log records to Scribe, allowing users to leverage Scribe's formatting and handler capabilities for platform-level logging.

jpl · high confidence

Introduce TUI overlay framework for terminal UIs

Added a new TUI overlay framework in the shared overlay module that enables rich terminal user interfaces. The framework provides an Overlay API to manage persistent UI elements such as progress bars and floating banners, utilizing ANSI escape codes and terminal control sequences for rendering. It supports two rendering modes: a relative mode compatible with all terminals (including IDE consoles) and a scroll region mode for standard terminals that allows banners to remain fixed while logs scroll. The implementation includes a demo application demonstrating concurrent progress bar updates and banner display, along with underlying components for terminal interaction, stream redirection, and log output integration.

overlay/shared · high confidence

Introduces native platform support for console output and configuration

Adds a new \Platform.scala\ implementation for Scala Native, enabling the logging library to function on native targets. This implementation configures the default console writer to use \SystemWriter\, sets the terminal column width to 120 (plus any adjustment), and defines platform-specific properties such as \isNative=true\. It also integrates with the \OutputFormat\ system, allowing native users to control ANSI or ASCII output via the \SCRIBE\_OUTPUT\_FORMAT\ environment property, consistent with JVM behavior.

core/native · high confidence

JVM file logging: shutdown hooks, rolling file tests, and stress test

The JVM-specific file logging module now registers a shutdown hook to ensure logs are flushed when the application terminates, and includes comprehensive tests for date-based and rolling file logging strategies along with a stress test for high-volume file logging.

fileModule/jvm · high confidence

New DSL for styled and composite log outputs

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, combine multiple outputs into a single composite, and apply text decorations such as bold, italic, underline, and strikethrough. URLs can also be embedded directly into log outputs. This change introduces new implicit conversions and helper methods to simplify the creation of rich, styled log entries.

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

New FilterBuilder DSL for composing log filters

Introduces a new \FilterBuilder\ API in the \scribe.filter\ package that allows users to compose log modifications using \select\, \include\, and \exclude\ filters combined with logical \&&\ and \\|\|\ operators. This change adds new filter matchers for class names (\ClassNameFilter\) and package names (\PackageNameFilter\), along with a \boosted\ method to adjust log priority levels based on specific criteria, and exposes these via the \scribe.filter\ package object for convenient access.

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

New Scribe integration for Cats Effect and enhanced terminal formatting

This change introduces a new \scribe/cats\ module that provides seamless integration with the Cats Effect ecosystem, including a \Scribe\[IO\]\ instance, automatic \Sync\[F\]\ derivation, and utilities for timing IO operations via \Timer.chain\ and \timed\. It also adds a comprehensive ANSI support layer (\ANSI.scala\) with extensive control codes for cursor movement, screen clearing, and scrolling, alongside new \LogOutput\ types (\ColoredOutput\, \BackgroundColoredOutput\, \BoldOutput\, etc.) and format blocks that enable rich, colored, and styled terminal logging.

repository · high confidence

New SlackWriter for logging to Slack

A new SlackWriter has been added to the scribe library, enabling users to send log messages directly to Slack. This component integrates with the existing logging infrastructure by implementing the Writer interface, accepting LogRecord, LogOutput, and OutputFormat parameters to format and dispatch messages via the Slack API.

slack · high confidence

New asynchronous logging and caching handlers with configurable overflow policies

The logging library now includes AsynchronousLogHandle, which processes log records in a background thread to prevent blocking, and CachingLogHandler, which buffers log records for later retrieval. Both components support a configurable maximum buffer size (defaulting to 1000 records). AsynchronousLogHandle introduces four overflow policies—DropOld, DropNew, Block, and Error—to control behavior when the buffer is full, allowing users to balance performance and data loss according to their needs.

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

New extensible output formatting system with ANSI, HTML, and ASCII support

The logging library now provides a modular \OutputFormat\ trait that allows users to choose how log messages are rendered. This change introduces three built-in formatters: \ANSIOutputFormat\ for terminal output with thread-safe color and style handling (bold, italic, underline, strikethrough), \HTMLOutputFormat\ for generating styled HTML logs (including a SolarizedDark theme with Inconsolata font), and \ASCIIOutputFormat\ for plain text. The \OutputFormat\ trait also supports an \init\ hook, enabling formats like HTML to inject headers or prefixes before the log stream begins.

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

New utility classes for log abbreviation and time management

Added two new utility classes to the core shared module: \Abbreviator\, which provides logic for abbreviating string values (such as package names) based on length constraints and separators, and \Time\, which abstracts time retrieval to allow for contextual overrides (useful for testing or deterministic logging). These changes introduce new capabilities for formatting log output and managing time sources within the library.

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

Rich browser console logging with colors and formatting

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 routes messages to console.log, console.warn, or console.error based on severity, and a RichBrowserOutputFormat that translates Scribe's LogOutput structure into CSS arguments for the JavaScript console.

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

SLF4J 2.0 bridge implementation for Scribe

Adds a new SLF4J 2.0 provider implementation that allows applications using the SLF4J API to route their logging calls to the Scribe logging framework. This includes the \ScribeServiceProvider\ (targeting API version 2.0.17), a logger factory (\ScribeLoggerFactory\), an MDC adapter (\ScribeMDCAdapter\) for context mapping, and helper utilities (\SLF4JHelper\) to translate SLF4J messages into Scribe's internal \LogRecord\ format. The bridge is registered via the standard \META-INF/services\ mechanism.

slf4j2/src/main · high confidence

Behavioural changes

JVM platform abstraction for console metrics and execution context

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

LogModifier now supports priority-based sorting and unique identification

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

MDC support refactored to allow custom implementations

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

Major refactoring of core logging architecture and data model

The core logging engine has been significantly restructured to improve flexibility and performance. The \LogRecord\ data model has been redesigned to support multiple messages via a \List\[LoggableMessage\]\ and a new \LogFeature\ system, allowing users to apply transformations and enrich log records. A new \LogRecordCreator\ trait enables custom implementations of record creation. The \LoggerSupport\ trait now provides a unified API for all log levels (including \fatal\) and introduces an \elapsed\ block for timing code execution. Additionally, a new \PlatformImplementation\ trait standardizes platform-specific behaviors like console output and execution context, while a new \Priority\ system allows for fine-grained control over handler application order.

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

New Writer API and Console Routing

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

New formatting blocks and updated default multi-line formatter

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

Refactored file logging to use File instead of Path and added time-based filename parts

The file logging implementation has been refactored to use java.io.File instead of java.nio.file.Path to avoid issues with too many open files. New time-based filename parts (hour, minute, second) have been added to allow more granular log file rotation. The rolling configuration now supports a truncate option, which is set as the new default behavior.

fileModule/shared · high confidence

Refactored logging handlers with a builder pattern and new functional handler

The handler subsystem has been restructured to simplify configuration and improve extensibility. A new \LogHandlerBuilder\ provides a fluent API for configuring formatters, writers, output formats, and modifiers, replacing previous direct instantiation methods. A \FunctionalLogHandler\ allows users to define custom logging logic via a simple function, while \SynchronousLogHandle\ and the \LogHandle\ trait abstract the execution model, enabling future asynchronous implementations. This change centralizes handler construction and makes it easier to customize logging behavior without implementing the full \LogHandler\ interface.

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

Refactored message representation with new internal message types

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

SLF4J binding implementation migrated to Scala

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

Fixes

Fix MDC binding in slf4j module

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

Test coverage

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 ScribeConfig loading; Added tests for asynchronous logging, JUL handler, and MDC thread safety; Added unit tests for core logging features.

Dependencies

Update build dependencies and Scala versions

The build configuration updates the default Scala version to 3.3.7 and adds support for Scala 3.8.2. Key dependency versions have been bumped, including cats-effect to 3.7.0, circe to 0.14.15, log4j to 2.25.4, and scalatest to 3.2.20.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 60 → 59 (-1.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 56 → 56 (+0.0)
  • Architecture 92 → 90 (-1.4)
  • Maturity 54 → 54 (+0.0)
  • Readiness 62 → 62 (+0.0)
  • Security 75 → 62 (-13.8)
  • Performance 87 → 87 (+0.0)

Findings

  • No change — the same findings as the prior survey.

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 6 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit c83d83b6945260035132341eb056b803d03a3d8d — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-60d1b390edf0.