Skip to content
CAI
Software that uses CAICheck a score

namastack/namastack-outbox

56.6

Adequate · 22 October 2026

25k

lines of production code

Kotlin

with TypeScript

9

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Namastack Outbox is a Spring Boot library that implements the transactional outbox pattern to ensure reliable, atomic persistence and processing of domain events. It provides a core engine for scheduling records with configurable retry and fallback policies, supporting persistence via JPA, JDBC, or MongoDB. The system integrates with external messaging brokers like Kafka, RabbitMQ, and AWS SNS, while offering comprehensive observability through Micrometer metrics and distributed tracing.

How it got here

2025 — Initial project scaffolding and core implementation

34 changes.

The project was initialized with comprehensive documentation, build configuration, and a new Kotlin-based core implementation of the transactional outbox pattern. This period established the foundational architecture, including JPA persistence, Jackson serialization, and administrative actuator endpoints, while replacing legacy components with modern Spring Boot 3 auto-configuration. Extensive test coverage and diverse example applications were added to demonstrate handler registration, retry policies, and multi-database support.

2026 — JDBC, Kafka, and MongoDB integrations

35 changes.

This period focused on expanding the Namastack Outbox library with new persistence backends and message broker integrations, specifically adding JDBC, MongoDB, Kafka, RabbitMQ, and AWS SNS support. It also introduced comprehensive observability via Micrometer and distributed tracing, alongside extensive example applications and performance testing tooling to validate these new capabilities.

Features

Add AWS SNS integration for outbox events

The \namastack-outbox-sns\ module now provides an auto-configured handler that publishes outbox records to AWS SNS topics. When Spring Cloud AWS SNS is on the classpath and the \namastack.outbox.sns.enabled\ property is true (default), the system automatically wires an \SnsOutboxHandler\ and a default \SnsOutboxRouting\ configuration. Users can customize routing via a Kotlin DSL or Java builder to define topic ARNs, message group IDs, headers, payload mappings, and filters per event type. The default topic ARN is \arn:aws:sns:us-east-1:000000000000:outbox-events\ but can be overridden via \namastack.outbox.sns.default-topic-arn\. Comprehensive tests verify auto-configuration conditions, bean creation, and handler behavior including filtering, mapping, and routing.

namastack-outbox-sns · high confidence

Add Flyway-JDBC outbox example with customer registration demo

This location introduces a complete example application demonstrating the Namastack outbox pattern using Flyway for schema management and JDBC for persistence. The example includes a customer registration service that persists customer data and schedules outbox records for both registration and removal events. It features two outbox handlers: one for sending registration emails and another for publishing events to an external broker, both utilizing simulated external services with configurable failure rates. The setup includes database migration scripts for outbox infrastructure tables and customer data, along with a smoke test to verify the end-to-end flow of event processing.

namastack-outbox-examples/namastack-outbox-example-flyway-jdbc · high confidence

Add Flyway-JPA outbox example with typed handlers and simulated external services

This location introduces a complete demonstration of the Namastack Outbox pattern using JPA and Flyway. It includes the database schema (outbox tables and customer entity), a service layer that schedules outbox records for customer registration and removal, and two specific handlers: a typed handler for sending registration emails and a generic handler for publishing events to an external broker. To facilitate testing and demonstration, the example integrates simulated external services (mail and broker) with configurable failure rates, and includes a smoke test to verify that the handlers correctly process the scheduled events.

namastack-outbox-examples/namastack-outbox-example-flyway-jpa · high confidence

Add JDBC example application configuration and database schema

The JDBC example module now includes its own application configuration and database schema. An application.yml file defines the Spring Boot application name, configures an in-memory H2 database for local development, and sets logging levels to warn for the root logger and debug for the demo package. Additionally, a schema.sql file is provided to automatically create the 'customer' table with id, firstname, lastname, and email columns, enabling the example to initialize its data structure on startup.

namastack-outbox-examples/namastack-outbox-example-jdbc/src/main/resources · high confidence

Add JDBC example domain models and events

The JDBC example module now includes the core domain data classes for the customer feature: a \Customer\ entity with a factory method for registration, and two event data classes (\CustomerRegisteredEvent\ and \CustomerRemovedEvent\) to represent customer lifecycle changes.

namastack-outbox-example-jdbc · high confidence

Add JDBC outbox example with custom table prefix and schema support

This location introduces a complete demo application illustrating how to configure the Namastack Outbox library with a custom database schema and table prefix. The example includes a \CustomerService\ that persists customer data and schedules outbox records, alongside specific handlers (\CustomerRegisteredOutboxHandler\ and \GenericOutboxHandler\) that process these events. The configuration in \application.yml\ explicitly sets \namastack.outbox.jdbc.schema-name\ to \myschema\ and \table-prefix\ to \prefix\_\, which is reflected in the provided \schema.sql\ and repository queries targeting tables like \myschema.prefix\_customer\ and \myschema.prefix\_outbox\_record\.

namastack-outbox-examples/namastack-outbox-example-table-prefix-jdbc/src/main · high confidence

Add JDBC-based outbox example with customer domain handlers

This location introduces a complete JDBC-backed outbox example, including the main application entry point, a customer service that persists data and schedules outbox events, and a repository using Spring JDBC. It adds specific outbox handlers for customer registration (sending emails) and generic event publishing (to an external broker), along with simulated external services and domain models to demonstrate the end-to-end flow.

namastack-outbox-examples/namastack-outbox-example-jdbc/src/main/kotlin · high confidence

Add MongoDB implementation for the outbox runtime

This release introduces a new MongoDB-based persistence layer for the outbox runtime, allowing users to store outbox records, instance heartbeats, and partition assignments in MongoDB instead of (or alongside) other databases. The module provides Spring Boot auto-configuration that registers repositories for outbox records, instances, and partition assignments, and enables multi-document transactions by default to ensure atomic partition reassignment and prevent split-brain scenarios during rebalancing. Users can customize collection names via the \namastack.outbox.mongodb.collectionPrefix\ property, and a provided \mongodb-setup.js\ script allows explicit index creation for production environments.

namastack-outbox-mongodb/src/main · high confidence

Add MongoDB outbox example with customer domain events

This change introduces the MongoDB implementation for the outbox pattern example, adding the core domain model and event definitions. It includes the Customer data class for managing customer details and defines two outbox events, CustomerRegisteredEvent and CustomerRemovedEvent, which are annotated to trigger outbox processing based on the customer ID.

namastack-outbox-example-mongodb · high confidence

Add MongoDB-based outbox example with transactional customer management

A new example application demonstrates the Namastack outbox pattern using MongoDB as the persistence store. The example includes a customer registration and removal workflow where database updates and outbox event publishing are handled within a single Spring transaction. It features a generic outbox handler that publishes events to a simulated external broker (with a configurable failure rate) and uses a custom MongoDB collection prefix for event storage. A smoke test verifies the end-to-end flow using Testcontainers.

namastack-outbox-examples/namastack-outbox-example-mongodb · high confidence

Add Namastack Outbox performance test harness

A new standalone Gradle composite build has been added to measure Namastack Outbox throughput against PostgreSQL. It provides a \run-performance-test.sh\ script that supports steady-state and backlog-drain modes, allowing users to verify consumer capacity and recovery behavior. The harness includes a Docker Compose environment with PostgreSQL, Prometheus, and Grafana, along with a pre-configured Grafana dashboard for monitoring metrics like processed records per second, consumer CPU, and PostgreSQL transaction rates.

namastack-outbox-performance-test · high confidence

Add RabbitMQ outbox example with customer domain models

This change introduces the foundational domain models for the RabbitMQ outbox example, providing both Java and Kotlin implementations. It adds a \Customer\ entity (with fields for ID, first name, last name, and email) and corresponding domain events (\CustomerRegisteredEvent\ and \CustomerRemovedEvent\) to demonstrate how customer registration and removal are modeled within the outbox pattern.

namastack-outbox-example-rabbit, namastack-outbox-example-rabbit-java · high confidence

Add RabbitMQ outbox integration examples for Java and Kotlin

New example projects for the Java and Kotlin outbox implementations demonstrate how to integrate with RabbitMQ. These examples show how to configure dedicated and default topic exchanges, route events like customer registration and removal using specific headers and keys, and schedule outbox messages within transactional service methods. A smoke test is included for each example to verify that messages are correctly published to RabbitMQ queues.

namastack-outbox-examples/namastack-outbox-example-rabbit, namastack-outbox-examples/namastack-outbox-example-rabbit-java · high confidence

Add RabbitMQ outbox integration with configurable routing and JSON serialization

This release introduces a new RabbitMQ integration for the outbox pattern, allowing outbox records to be published to RabbitMQ exchanges. The module auto-configures a handler and publisher when Spring AMQP is present, using correlated publisher confirms to ensure reliable delivery. Users can customize routing via a Kotlin DSL or Java builder to specify target exchanges, routing keys, payload mappings, and filters, with a default exchange of 'outbox-events'. JSON serialization is enabled by default using Jackson, and the publisher validates that Spring AMQP is correctly configured for synchronous publishing, failing fast if correlated confirms, publisher returns, or mandatory publishing are missing when required.

namastack-outbox-rabbit · high confidence

Add SNS outbox integration examples for Java and Kotlin

New demo applications have been added for both Java and Kotlin that demonstrate how to integrate the Namastack Outbox library with AWS SNS. These examples include the necessary domain models (Customer, events), service layers that schedule events to the outbox, and configuration classes that define routing rules to specific SNS topics. Each example also includes a smoke test using LocalStack to verify that outbox records are successfully published to SNS.

namastack-outbox-examples/namastack-outbox-example-sns, namastack-outbox-examples/namastack-outbox-example-sns-java · high confidence

Add Spring Modulith outbox example application

Introduces a new example application demonstrating Spring Modulith with an outbox pattern for event externalization. The example includes an Order module that persists orders and publishes internal events, and a Payment module that consumes these events, creates payments, and externalizes payment requests to Kafka via the outbox. It also provides configuration for outbox retry policies, Micrometer observation/tracing, and a smoke test verifying the end-to-end flow using Testcontainers.

namastack-outbox-example-modulith, namastack-outbox-examples/namastack-outbox-example-modulith · high confidence

Add annotation-based outbox example with explicit handler IDs

The annotation-based outbox example now includes a complete demo application that registers and removes customers, scheduling events via the outbox. The example introduces a \DemoOutboxHandler\ component that uses the \@OutboxHandler\ annotation with explicit \id\ attributes (e.g., \events.publish-to-external-broker\, \customers.send-registration-email\) to route events, reflecting a shift toward an opt-out or explicit-id mechanism rather than a global enable flag. It also adds simulated external services (\ExternalBroker\, \ExternalMailService\) with random failures to demonstrate handler behavior.

namastack-outbox-examples/namastack-outbox-example-annotation/src/main/kotlin · high confidence

Add customer domain model and domain events for Kafka example

The Kafka outbox example now includes the core customer domain model and associated events. A \Customer\ entity (with id, firstname, lastname, and email) is defined in both the Java and Kotlin implementations, along with \CustomerRegisteredEvent\ and \CustomerRemovedEvent\ data classes to represent state changes. This provides the foundational data structures required for the outbox pattern demonstration within this specific example module.

namastack-outbox-example-kafka, namastack-outbox-example-kafka-java · high confidence

Add customer domain model and event classes for JDBC outbox example

This change introduces the core domain data classes for the JDBC outbox example application. It adds the \Customer\ entity, which represents a customer record with identification and contact details, along with a factory method for registration. Additionally, it defines two event data classes, \CustomerRegisteredEvent\ and \CustomerRemovedEvent\, which capture the state changes associated with customer lifecycle events within this specific example module.

namastack-outbox-example-table-prefix-jdbc · high confidence

Add customer domain model and event definitions

The example application now includes the core domain entities and events for the customer feature. A new \Customer\ entity is defined with JPA annotations for SQL Server storage, including a UUID primary key and fields for first name, last name, and email. Additionally, \CustomerRegisteredEvent\ and \CustomerRemovedEvent\ data classes are introduced to represent the domain events associated with customer lifecycle changes.

namastack-outbox-example-mysql, namastack-outbox-example-sqlserver · high confidence

Add customer domain models and events

This change introduces the core domain entities for the customer feature within the Flyway JDBC outbox example. It adds the \Customer\ data class, which includes a factory method for registration, along with corresponding domain events (\CustomerRegisteredEvent\ and \CustomerRemovedEvent\) to capture state changes. These classes provide the data structures necessary for the application to model customer lifecycle events.

namastack-outbox-example-flyway-jdbc, namastack-outbox-example-table-prefix-jpa · high confidence

Add customer domain models and events to database-specific examples

The H2, MariaDB, and PostgreSQL example projects now include the core domain entities and events required for the outbox pattern demonstration. Specifically, each example now contains a \Customer\ entity (with fields for ID, first name, last name, and email) and two event data classes: \CustomerRegisteredEvent\ and \CustomerRemovedEvent\. These files provide the necessary data structures for handling customer registration and removal events within each respective database context.

namastack-outbox-example-h2, namastack-outbox-example-mariadb, namastack-outbox-example-postgresql · high confidence

Add customer domain models for annotation and Java examples

The annotation and Java example modules now include the core customer domain entities and associated events. Specifically, the \Customer\ entity (with JPA annotations) and the \CustomerRegisteredEvent\ and \CustomerRemovedEvent\ data classes have been added to the annotation example, while the Java example includes the corresponding \Customer\ entity class. These files provide the foundational data structures for the outbox pattern demonstrations in both language variants.

namastack-outbox-example-annotation, namastack-outbox-example-java · high confidence

Add customer management examples for multiple database backends

New demo examples have been added for H2, MariaDB, MySQL, PostgreSQL, and SQL Server, each providing a CustomerRepository and CustomerService. These examples demonstrate how to register and remove customers while scheduling events to the outbox, serving as reference implementations for integrating the outbox pattern with various database technologies.

(repo-wide) · high confidence

Add customer registration example with outbox event multicasting

This change introduces a new example project demonstrating the multicaster pattern for outbox events. It adds a Customer entity that extends AbstractAggregateRoot to manage domain events and a CustomerRegisteredEvent annotated with @OutboxEvent, enabling the system to publish customer registration events to multiple processors.

namastack-outbox-example-multicaster · high confidence

Add fallback handler example demonstrating outbox failure recovery

A new example application demonstrates how to handle outbox processing failures using both annotation-based (@OutboxFallbackHandler) and interface-based (OutboxHandlerWithFallback) fallback mechanisms. The example includes a demo application that registers and removes customers, triggering outbox events that intentionally fail to simulate external service errors, and verifies that the configured fallback handlers are invoked correctly.

namastack-outbox-examples/namastack-outbox-example-fallback · high confidence

Add multicaster outbox example application

Introduces a new example project demonstrating the Namastack outbox multicaster pattern. The application registers sample customers and processes outbox events using an asynchronous listener that intentionally throws exceptions to show they do not affect the outbox transaction, alongside a dedicated outbox handler that simulates external service calls with random delays and failures to demonstrate retry behavior.

namastack-outbox-examples/namastack-outbox-example-java/src/main/java, namastack-outbox-examples/namastack-outbox-example-multicaster/src/main/kotlin · high confidence

Add retry-focused outbox example with handler-specific policies

The namastack-outbox-example-retry module now demonstrates how to configure and apply custom retry policies to outbox handlers. It includes an aggressive retry policy (5 retries, 0 delay) and a custom policy with exponential backoff, allowing handlers to specify their own retry behavior via annotations or interface implementation. The example also shows how to access retry attempt metadata in handlers and verifies the setup with a smoke test that confirms event processing.

namastack-outbox-examples/namastack-outbox-example-retry · high confidence

Add tracing example demonstrating context propagation across outbox handlers

This location introduces a new example application that demonstrates how to observe and trace events processed by the outbox pattern. It includes a customer registration service that schedules outbox records, along with specific handlers for sending registration emails and publishing to an external broker. The example is configured with OpenTelemetry and Micrometer observations to ensure that trace context is correctly propagated from the initial request through the outbox processing pipeline to external services, verified by a smoke test that asserts consistent trace IDs across all components.

namastack-outbox-examples/namastack-outbox-example-tracing · high confidence

Added customer domain model and domain events

This change introduces the core domain entities and events for the customer module within the fallback example. It adds a JPA \Customer\ entity with fields for ID, first name, last name, and email, along with a factory method for registration. Additionally, it defines \CustomerRegisteredEvent\ and \CustomerRemovedEvent\ data classes to represent customer lifecycle state changes.

namastack-outbox-example-fallback · high confidence

Added customer domain model and event classes

Introduced the Customer entity and associated domain events (CustomerRegisteredEvent, CustomerRemovedEvent) to support the outbox pattern implementation. These classes define the data structure for customer registration and removal, enabling the tracking of state changes for eventual consistency.

namastack-outbox-example-flyway-jpa · high confidence

Added customer domain models and events for SNS example

The SNS integration example now includes the core domain entities and events required to model customer lifecycle operations. Specifically, it adds a \Customer\ entity (in both Java and Kotlin variants) representing the persistent customer record, along with \CustomerRegisteredEvent\ and \CustomerRemovedEvent\ data classes to capture state changes. These files provide the foundational data structures for the outbox pattern implementation within this specific example module.

namastack-outbox-example-retry, namastack-outbox-example-sns, namastack-outbox-example-sns-java, namastack-outbox-example-tracing · high confidence

Added outbox performance test tooling and consumer harness

This change introduces a new performance testing infrastructure for the outbox pattern. It adds a consumer application configured for high-throughput benchmarking (including metrics filtering and virtual thread support) and a comprehensive CLI tooling suite. The tooling enables users to seed deterministic records, trigger backlog-drain runs, produce continuous load at target rates, and collect detailed performance reports (including drain and steady-state metrics) via commands like \seed\, \produce\, \collect-drain\, and \collect-steady-state\.

(repo-wide) · high confidence

Automated release preparation scripts added

Added \scripts/prepare-release.mjs\ and \scripts/current-version.sh\ to streamline the OSS release process. The new \prepare-release\ script automates version updates across the root \build.gradle.kts\, example dependencies, performance test configurations, and documentation versioning (including \versions.json\, security policy tables, and Vercel redirects), ensuring consistent state before a release is cut.

scripts · high confidence

Enable Spring Boot auto-configuration for Outbox Jackson

The Outbox Jackson module now registers its auto-configuration class, OutboxJacksonAutoConfiguration, via standard Spring Boot metadata files. This allows the framework to automatically detect and apply the outbox Jackson serialization settings without requiring manual configuration by the user.

namastack-outbox-jackson/src/main/resources · high confidence

Initial JDBC outbox schema definitions for multiple databases

The JDBC module now includes database-specific SQL schema files for H2, MariaDB, MySQL, Oracle, PostgreSQL, and SQL Server. These scripts define the \outbox\_record\, \outbox\_instance\, and \outbox\_partition\ tables along with necessary indexes, enabling the outbox pattern to be deployed on these supported relational databases.

namastack-outbox-jdbc/src/main/resources/schema · high confidence

Initial project scaffolding and documentation

The repository has been initialized with the core project documentation and configuration files. This includes the README, contributing guidelines, governance model, security policy, and release procedures, alongside standard build configuration files like the Gradle wrapper and detekt rules. This establishes the foundational structure and operational guidelines for the Namastack Outbox project.

(repo-wide) · high confidence

Initial release of the Namastack Outbox API

This change introduces the core public API for the Namastack Outbox library, enabling developers to schedule domain events for reliable, atomic persistence and processing. The new \Outbox\ interface allows scheduling records with explicit keys and context metadata, which are merged from global providers and event-specific parameters. The API defines a comprehensive handler model including typed (\OutboxTypedHandler\) and generic (\OutboxHandler\) interfaces, with optional fallback logic via \OutboxHandlerWithFallback\ and \OutboxTypedHandlerWithFallback\ to manage permanently failed records. It also provides annotation-based handler registration (\@OutboxHandler\, \@OutboxFallbackHandler\, \@OutboxRetryable\) and supports stable handler identity migration. The release includes a robust retry system with configurable policies (\OutboxRetryPolicy\) and backoff strategies (fixed, linear, exponential), as well as routing capabilities via \OutboxRoute\ for externalizing records to destinations like Kafka or RabbitMQ.

namastack-outbox-api · high confidence

Introduce JDBC Outbox module with multi-database support and auto-initialization

The JDBC Outbox module is now available, providing a new \JdbcOutboxAutoConfiguration\ that registers repositories for outbox records, instances, and partitions using Spring's \JdbcClient\. The module supports automatic schema initialization by default (controlled by \namastack.outbox.jdbc.schema-initialization.enabled\), which detects the database type (PostgreSQL, MySQL, H2, MariaDB, SQL Server, or Oracle) and runs the corresponding SQL script. Users can customize table naming via \namastack.outbox.jdbc.table-prefix\, \namastack.outbox.jdbc.schema-name\, and \namastack.outbox.jdbc.table-names\, though these customizations require disabling auto-initialization and managing schema creation manually.

namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/config · high confidence

Introduce JDBC persistence module for the outbox pattern

This release adds a new JDBC-based storage backend for the outbox system, allowing outbox records, processor instance coordination, and partition assignments to be persisted in a relational database. The module includes repository implementations for managing outbox records (with support for filtering by status, key, and partition, as well as handling previous failures), tracking active processor instances via heartbeats, and managing partition assignments with optimistic locking to prevent concurrent conflicts. It also provides configurable table naming through schema and prefix settings, and uses Java Instant for timestamp storage.

namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox · high confidence

JDBC outbox module auto-configuration and metadata

The JDBC outbox module now registers its auto-configuration classes, enabling automatic setup of the outbox infrastructure. Users can configure the database schema name, table prefixes, and specific table names for records, instances, and partitions via properties like \namastack.outbox.jdbc.schema-name\ and \namastack.outbox.jdbc.table-names.\*\. Schema initialization is enabled by default at startup, controlled by \namastack.outbox.jdbc.schema-initialization.enabled\.

namastack-outbox-jdbc/src/main/resources/META-INF · high confidence

JPA-based outbox persistence and auto-configuration

The JPA module now provides a complete, auto-configured persistence layer for the outbox pattern. It registers \JpaOutboxAutoConfiguration\ to wire JPA repositories for outbox records, processor instances, and partition assignments, using a shared transaction-aware EntityManager and a dedicated TransactionTemplate. The implementation includes MySQL and MariaDB dialects to correctly handle LONGTEXT columns, indexes on key entity tables for query performance, and uses the context ClassLoader for payload class resolution to support various deployment environments.

namastack-outbox-jpa/src/main · high confidence

Jackson-based serialization for outbox payloads

The outbox module now includes a Jackson-based implementation for serializing and deserializing event payloads. This change introduces \JacksonOutboxPayloadSerializer\ to handle JSON conversion using Jackson 3.x and adds \OutboxJacksonAutoConfiguration\ to automatically register the serializer as a Spring bean. The auto-configuration supports custom \JsonMapper\ beans and automatically detects the presence of the Kotlin module for type-safe deserialization, enabling users to persist outbox events as JSON strings.

namastack-outbox-jackson/src/main/kotlin · high confidence

Namastack Outbox documentation site launched on Docusaurus

The project documentation has been migrated to a new Docusaurus-based static site. This update introduces a comprehensive reference guide covering core features, configuration options, handler types, and messaging integrations (Kafka, RabbitMQ, SNS). It also includes a quickstart guide, contributing guidelines, and legal notices with Google Analytics integration.

namastack-outbox-docs · high confidence

New JPA example with custom table prefix and schema support

This location introduces a new demo application that demonstrates how to configure the Namastack Outbox library with a custom database schema and table naming strategy. The example includes a \PrefixedPhysicalNamingStrategy\ that automatically prepends 'custom\prefix\' to all generated table names and configures Hibernate to use the 'myschema' schema. It also features a complete customer domain model with outbox handlers for sending registration emails and publishing events to an external broker, illustrating the end-to-end flow with simulated external service failures.

namastack-outbox-examples/namastack-outbox-example-table-prefix-jpa/src/main · high confidence

New Kafka outbox examples for Java and Kotlin

Added complete demo applications for both Java and Kotlin that showcase the Kafka outbox routing module. These examples demonstrate how to configure routing rules (such as directing specific events to dedicated topics with custom headers) and verify end-to-end functionality through smoke tests that confirm messages are published to Kafka topics.

namastack-outbox-examples/namastack-outbox-example-kafka, namastack-outbox-examples/namastack-outbox-example-kafka-java · high confidence

New Kafka outbox integration with configurable routing and JSON serialization

This release introduces the \namastack-outbox-kafka\ module, enabling automatic delivery of outbox records to Apache Kafka. The module auto-configures a \KafkaOutboxHandler\ and \KafkaOutboxRouting\ when Spring Kafka is present and the \namastack.outbox.kafka.enabled\ property is true (default). Users can customize delivery via a DSL-based routing configuration that supports topic selection, key extraction, header injection, payload mapping, and filtering per event type. JSON serialization is enabled by default using Jackson serializers/deserializers, configurable via \namastack.outbox.kafka.enable-json\. The default topic is \outbox-events\, overridable via \namastack.outbox.kafka.default-topic\.

namastack-outbox-kafka · high confidence

New Outbox Actuator Endpoint for Administrative Cleanup

This change introduces a new Spring Boot Actuator endpoint (id: 'outbox') that allows administrators to manage outbox records via HTTP DELETE operations. The endpoint enables deleting specific outbox records by record key and status, or deleting all records matching a specific status. It is automatically configured when the core OutboxService is present and the outbox is enabled (defaulting to true), requiring a persistence module like namastack-outbox-jpa to provide the OutboxRecordRepository.

namastack-outbox-actuator/src/main · high confidence

New example projects and documentation for handler registration, fallbacks, and Flyway schema management

The \namastack-outbox-examples\ directory now includes new standalone Spring Boot examples demonstrating annotation-based handler registration (\@OutboxHandler\), fallback handling for permanent failures (\@OutboxFallbackHandler\), and production-ready schema management using Flyway migrations for both JDBC and JPA modules. These examples, along with updated documentation, show how to assign stable, responsibility-based handler IDs and manage outbox tables via versioned SQL scripts instead of automatic schema initialization.

namastack-outbox-examples · high confidence

Outbox core auto-configuration registration

The outbox-core module now registers its specific auto-configuration classes (threading, processing, scheduling, infrastructure, and multicaster) via the Namastack child auto-configuration imports mechanism, enabling automatic setup of these components when the module is present on the classpath.

namastack-outbox-core/src/main/resources/META-INF/namastack · high confidence

Outbox core library initialization with Kotlin implementation

The \namastack-outbox-core\ module introduces the foundational Kotlin implementation of the transactional outbox pattern. This includes the core domain model (\OutboxRecord\, \OutboxRecordStatus\), repository interfaces for persistence, and the \OutboxService\ for intelligent handler discovery and record scheduling. The processing engine is built around a chain of processors (\PrimaryOutboxRecordProcessor\, \RetryOutboxRecordProcessor\, \FallbackOutboxRecordProcessor\) and a \SmartLifecycle\-based scheduler (\OutboxProcessingScheduler\) that handles partition-aware polling and parallel execution. Configuration is managed via \OutboxProperties\ with support for fixed and adaptive polling strategies, retry policies, and instance coordination. The module also provides auto-configuration classes (\OutboxCoreInfrastructureAutoConfiguration\, \OutboxCoreProcessingAutoConfiguration\) and a custom event multicaster (\OutboxEventMulticaster\) to intercept \@OutboxEvent\ annotations. New utility annotations like \@OpenForProxy\ ensure CGLIB proxy compatibility for Kotlin classes, and specific exceptions (\OutboxHandlerNotFoundException\, \OutboxPayloadTypeNotFoundException\) are introduced to handle runtime errors gracefully.

namastack-outbox-core/src/main/kotlin · high confidence

Outbox observability API definitions for record processing and scheduling

The \namastack-outbox-observability-api\ module now provides the foundational API for Micrometer-based observability of outbox operations. It introduces canonical metric names (e.g., \outbox.record.process\, \outbox.records\) and key names for both low-cardinality metrics (like handler kind and channel) and high-cardinality trace data (like record ID and delivery attempt). The module defines observation contexts and conventions for two key lifecycle events: processing a record (including primary vs. fallback handling) and scheduling records, enabling automatic distributed tracing and timer metrics when standard Micrometer handlers are registered.

namastack-outbox-observability-api · high confidence

Outbox observability module adds Micrometer metrics and distributed tracing

The new \namastack-outbox-observability\ module provides automatic Micrometer-based metrics and distributed tracing for the outbox pipeline. It instruments scheduling, record processing, and handler invocations with timer observations, and registers instance-level and cluster-level gauges (such as pending record counts, partition assignments, and active instance counts) via \OutboxInstanceMetricsMeterBinder\. Additionally, it captures and propagates trace context (W3C Trace Context headers) across asynchronous record processing boundaries using \OutboxObservabilityTracingContextProvider\, ensuring end-to-end visibility when Micrometer Tracing is available.

namastack-outbox-observability · high confidence

Removals

Removal of JPA-based outbox implementation

The JPA-specific outbox implementation has been removed from the \spring-outbox-jpa\ module. This change deletes the \JpaOutboxAutoConfiguration\ and all associated JPA entities, repositories, and mappers (\JpaOutboxLockRepository\, \JpaOutboxRecordRepository\, \OutboxLockEntity\, \OutboxRecordEntity\), along with the SQL schema definitions and Spring auto-configuration registration files. Consequently, the JPA outbox feature is no longer available in this module.

spring-outbox-jpa · high confidence

Removal of core outbox processing components

The \spring-outbox-core\ module has removed the entire outbox processing implementation, including the \OutboxScheduler\, \OutboxLockManager\, \OutboxRecord\ model, and associated repositories and configuration properties. This deletion eliminates the library's ability to persist, schedule, and process outbox events with locking and retry logic, effectively stripping the core functionality from this module.

spring-outbox-core · high confidence

Behavioural changes

Legacy outbox metrics module deprecated in favor of observability module

The \namastack-outbox-metrics\ module, which provides legacy gauge-based Micrometer metrics for outbox record counts and partition assignments, is now deprecated and marked for removal in a future major version. Users should migrate to the \namastack-outbox-observability\ module, which offers Observation-based timer metrics (such as \outbox.record.process\ and \outbox.record.schedule\) that provide more detailed insights into throughput, latency, and error rates per handler. The auto-configuration in this location registers the deprecated record and partition meter binders but explicitly directs users toward the new observability capabilities.

namastack-outbox-metrics/src/main · high confidence

Outbox example demos now use explicit handler identities

The outbox example applications (H2, MariaDB, MySQL, PostgreSQL, and SQL Server) have been updated to replace the previous \@EnableOutbox\ configuration with an opt-out mechanism. This change is reflected in the new \CustomerRegisteredOutboxHandler\ and \GenericOutboxHandler\ components, which now explicitly define their identities via \getTypedHandlerIdentity()\ and \getGenericHandlerIdentity()\ respectively, rather than relying on automatic discovery or global enablement annotations.

(repo-wide) · high confidence

Spring Boot 3 auto-configuration migration

The Outbox core module now uses the Spring Boot 3 standard \org.springframework.boot.autoconfigure.AutoConfiguration.imports\ file to register its auto-configuration classes. This replaces the legacy \spring.factories\ mechanism, ensuring the infrastructure, threading, processing, scheduling, and multicaster configurations are correctly discovered by modern Spring Boot applications.

namastack-outbox-core/src/main/resources/META-INF/spring · high confidence

Test coverage

Added comprehensive test coverage for JPA outbox components; Added integration and unit tests for MongoDB outbox implementation; Added smoke tests for all outbox examples; Added tests for JDBC outbox repository and schema initialization; Added tests for Outbox Actuator auto-configuration and endpoint behavior; Added tests for outbox metrics auto-configuration and meter binders; Added unit tests for Jackson outbox serialization and auto-configuration; Expanded integration tests for outbox handler registration, fallbacks, and lifecycle; Expanded test coverage for outbox core infrastructure.

Dependencies

Gradle wrapper upgraded to version 9.7.1 with new retry configuration

The Gradle wrapper has been updated from version 8.14.3 to 9.7.1, which may introduce changes in build behavior and performance. Additionally, the wrapper configuration now includes explicit retry settings (retries=0, retryBackOffMs=500) to control distribution download failures.

gradle · high confidence

Standardize build configuration with Gradle version catalogs

The project now uses Gradle version catalogs (gradle/libs.versions.toml) to centralize dependency and plugin management, replacing scattered version declarations. This introduces Spring Boot 4.1.1, Kotlin 2.4.20, and Testcontainers 2.0.5 as the base versions, while the documentation site has been updated to Docusaurus 3.10.2 and requires Node.js 22.x.

(dependencies) · high confidence

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

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 57 → 57 (-0.8)
  • Rubric changed (rubric-2026.10.1 → rubric-2026.10.5) — scores are not directly comparable.

Lenses

  • Code Health 47 → 57 (+10.1)
  • Architecture 98 → 98 (+0.0)
  • Maturity 79 → 56 (-22.9)
  • Readiness 58 → 51 (-7.1)
  • Security 77 → 75 (-2.0)
  • Accessibility 61 → 61 (+0.0)
  • Performance 100 → 100 (+0.0)

Resolved (169)

  • Low vulnerability: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
  • Outdated (compile): at.yawk.lz4:lz4-java
  • Outdated (compile): biz.aQute.bnd:biz.aQute.bnd.annotation
  • Outdated (compile): ch.qos.logback:logback-classic
  • Outdated (compile): ch.qos.logback:logback-core
  • Outdated (compile): com.fasterxml.jackson.core:jackson-annotations
  • Outdated (compile): com.fasterxml.jackson.core:jackson-core
  • Outdated (compile): com.fasterxml.jackson.core:jackson-databind
  • Outdated (compile): com.fasterxml.jackson.dataformat:jackson-dataformat-xml
  • Outdated (compile): com.fasterxml.jackson.module:jackson-module-kotlin
  • Outdated (compile): com.fasterxml.jackson:jackson-bom
  • Outdated (compile): com.fasterxml.woodstox:woodstox-core
  • Outdated (compile): com.github.ajalt.clikt:clikt
  • Outdated (compile): com.github.ajalt.clikt:clikt-jvm
  • Outdated (compile): com.github.luben:zstd-jni
  • Outdated (compile): com.google.errorprone:error_prone_annotations
  • Outdated (compile): com.h2database:h2
  • Outdated (compile): com.jayway.jsonpath:json-path
  • Outdated (compile): com.microsoft.sqlserver:mssql-jdbc
  • Outdated (compile): com.mysql:mysql-connector-j
  • …and 149 more

New (9)

  • Critical vulnerability: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (11 lines × 2) (namastack-outbox-mongodb/src/main/kotlin/io/namastack/outbox/MongoOutboxRecordRepository.kt)
  • Duplicated block (11 lines × 2) (namastack-outbox-mongodb/src/main/kotlin/io/namastack/outbox/MongoOutboxRecordRepository.kt)
  • High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
  • High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
  • Medium: security finding (details withheld)
  • Orphaned file (namastack-outbox-mongodb/src/main/kotlin/io/namastack/outbox/MongoOutboxInstanceRepository.kt)
  • Orphaned file (namastack-outbox-mongodb/src/main/kotlin/io/namastack/outbox/MongoOutboxPartitionAssignmentRepository.kt)

Changes since last survey

  • 10 commits — 10 feature/other, 0 fixes

By area

  • namastack-outbox-core/src — 2 commits
  • (root) — 1 commit
  • gradle/libs.versions.toml — 1 commit
  • gradle/wrapper — 1 commit
  • namastack-outbox-docs/docs — 1 commit
  • namastack-outbox-docs/versioned_docs — 1 commit
  • namastack-outbox-examples/namastack-outbox-example-annotation — 1 commit
  • namastack-outbox-examples/namastack-outbox-example-postgresql — 1 commit
  • namastack-outbox-integration-tests/src — 1 commit

Notable commits

  • change: Bump gradle-wrapper (#508)
  • change: Bump gradle-wrapper from 9.8.0 to 9.8.1 (#507)
  • change: Bump kotlin from 2.4.20 to 2.4.21 (#506)
  • change: Bump org.postgresql:postgresql (#509)
  • change: GH-486 add bounded retention methods to OutboxRecordRepository (#505)
  • change: GH-500 Allow fallback to keep record failed after successful invocation (#504)
  • change: GH-501 count pending records across assigned partitions in one query (#502)
  • change: GH-512 require an active transaction when scheduling outbox records (#514)
  • change: Prepare release 1.10.1 (#503)
  • change: Prepare release 1.11.0 (#511)

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 21 added · 23 removed

Added dependency edges (21)

  • namastack-outbox-example-fallback → namastack-outbox-example-annotation
  • namastack-outbox-example-flyway-jdbc → namastack-outbox-example-annotation
  • namastack-outbox-example-flyway-jpa → namastack-outbox-example-annotation
  • namastack-outbox-example-h2 → namastack-outbox-example-annotation
  • namastack-outbox-example-jdbc → namastack-outbox-example-annotation
  • namastack-outbox-example-kafka → namastack-outbox-example-annotation
  • namastack-outbox-example-mariadb → namastack-outbox-example-annotation
  • namastack-outbox-example-mongodb → namastack-outbox-example-annotation
  • namastack-outbox-example-multicaster → namastack-outbox-example-annotation
  • namastack-outbox-example-multicaster → namastack-outbox-example-tracing (coupling)
  • namastack-outbox-example-mysql → namastack-outbox-example-annotation
  • namastack-outbox-example-postgresql → namastack-outbox-example-annotation
  • namastack-outbox-example-rabbit → namastack-outbox-example-annotation
  • namastack-outbox-example-retry → namastack-outbox-example-annotation
  • namastack-outbox-example-sns → namastack-outbox-example-annotation
  • namastack-outbox-example-sqlserver → namastack-outbox-example-annotation
  • namastack-outbox-example-table-prefix-jdbc → namastack-outbox-example-annotation
  • namastack-outbox-example-table-prefix-jpa → namastack-outbox-example-annotation
  • namastack-outbox-example-tracing → namastack-outbox-example-annotation
  • namastack-outbox-jpa → namastack-outbox-core (coupling)
  • …and 1 more

Removed dependency edges (was a dependency, now gone) (23)

  • namastack-outbox-example-fallback → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-flyway-jdbc → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-flyway-jpa → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-h2 → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-java → namastack-outbox-example-sns-java
  • namastack-outbox-example-jdbc → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-kafka → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-kafka-java → namastack-outbox-example-sns-java
  • namastack-outbox-example-mariadb → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-mongodb → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-multicaster → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-mysql → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-postgresql → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-rabbit → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-rabbit-java → namastack-outbox-example-sns-java
  • namastack-outbox-example-retry → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-sns → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-sqlserver → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-table-prefix-jdbc → namastack-outbox-example-annotation (coupling)
  • namastack-outbox-example-table-prefix-jpa → namastack-outbox-example-annotation (coupling)
  • …and 3 more

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

Survey your own repository

namastack/namastack-outbox 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 22 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 13773814f60b5771a36fd60b4b6f9405dbbaa09b — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.3+preprod-fddbc92cb8df.