namastack/namastack-outbox

Namastack Outbox is a Spring Boot library that implements the outbox pattern to ensure reliable, atomic persistence and asynchronous processing of domain events. It provides a pluggable architecture supporting multiple persistence backends (JPA, JDBC, MongoDB) and message brokers (Kafka, RabbitMQ, AWS SNS), with built-in features for distributed partitioning, configurable retry policies, and comprehensive observability. The system is designed for horizontal scaling, offering instance coordination, adaptive polling, and administrative endpoints for managing record lifecycles.

37 changes.

The Namastack Outbox project was initialized with a comprehensive structure, establishing the core API, JPA persistence, and distributed instance registry. Significant work focused on implementing adaptive polling, configurable retry policies, and stable handler identities to support horizontal scaling and reliable event processing. The period also included the creation of extensive documentation, example applications, and test coverage to validate the new architecture.

25 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 modules. The work included implementing core storage and routing logic, establishing auto-configuration for these components, and providing comprehensive example applications and smoke tests to demonstrate end-to-end functionality across various database and messaging scenarios.

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

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

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

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

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

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

The Java example project now includes a complete demo application that demonstrates the outbox pattern. It features a customer management service that persists entities and schedules events (registration and removal) into the outbox, alongside specific handlers for sending registration emails and publishing events to an external broker, supported by simulated external services to illustrate failure scenarios.

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

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

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

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

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

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

The SQL Server example now includes the core customer domain logic, introducing a JPA entity, repository, and service layer. The CustomerService implements the outbox pattern by persisting customer registration and removal actions to the database and simultaneously scheduling corresponding domain events (CustomerRegisteredEvent, CustomerRemovedEvent) to the outbox for reliable delivery.

namastack-outbox-examples/namastack-outbox-example-sqlserver/src/main/kotlin/io/namastack/demo/customer · high confidence

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

The multicaster example project now includes the customer domain layer, introducing a JPA entity for customer data and a repository for persistence. It also defines a \CustomerRegisteredEvent\ annotated with \@OutboxEvent\, enabling the system to publish customer registration events via the outbox pattern for downstream processing.

namastack-outbox-examples/namastack-outbox-example-multicaster/src/main/kotlin/io/namastack/demo/customer · high confidence

The MySQL example now includes the core customer domain components: a JPA entity, repository, and service layer. The CustomerService implements the outbox pattern by persisting customer registration and removal data to the database and simultaneously scheduling corresponding domain events (CustomerRegisteredEvent, CustomerRemovedEvent) to the outbox for reliable asynchronous processing.

namastack-outbox-examples/namastack-outbox-example-mysql/src/main/kotlin/io/namastack/demo/customer · high confidence

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

This change introduces a new demo application that illustrates the multicaster outbox pattern. It registers three sample customers on startup and processes the resulting events using an asynchronous listener that intentionally throws an exception to demonstrate that such errors do not roll back the outbox transaction. Additionally, it includes an outbox handler configured with a specific ID that simulates external service calls with random delays and a 30% failure rate to showcase automatic retry behavior.

namastack-outbox-examples/namastack-outbox-example-multicaster/src/main/kotlin/io/namastack/demo · high confidence

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

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

This change introduces a new performance testing suite for the outbox mechanism. It adds a consumer application that processes payment events with an intentionally empty handler to isolate outbox processing overhead, and configures it to disable specific database-intensive metrics. It also provides a comprehensive command-line tooling suite for orchestrating performance tests, including commands to seed deterministic records, trigger outbox processing, produce records at target rates, and collect detailed drain and steady-state performance metrics with Markdown reporting.

namastack-outbox-performance-test/consumer, namastack-outbox-performance-test/tooling · high confidence

The outbox system now automatically collects and merges metadata from multiple registered context providers whenever a record is scheduled. This allows components to contribute additional information—such as tracing IDs, tenant identifiers, or user details—to outbox entries without manual intervention. The collector handles conflicts by letting the last provider win and ensures resilience by logging warnings and skipping any providers that fail, preventing a single error from blocking the entire scheduling operation.

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

The H2, MariaDB, and PostgreSQL example projects now include the core customer domain components: the \Customer\ entity, \CustomerRepository\, \CustomerService\, and associated domain events (\CustomerRegisteredEvent\, \CustomerRemovedEvent\). The service layer implements customer registration and removal, persisting the customer record and scheduling the corresponding event to the outbox within a single transaction.

namastack-outbox-examples/namastack-outbox-example-h2/src/main/kotlin/io/namastack/demo/customer, namastack-outbox-examples/namastack-outbox-example-mariadb/src/main/kotlin/io/namastack/demo/customer, namastack-outbox-examples/namastack-outbox-example-postgresql/src/main/kotlin/io/namastack/demo/customer · high confidence

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

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

The repository has been initialized with the Namastack Outbox project structure, including the core source modules (API, core, JPA, JDBC, Kafka, RabbitMQ, etc.) and a new documentation site. This change adds essential project governance and contribution guidelines (CONTRIBUTING.md, GOVERNANCE.md), a SECURITY.md policy with private vulnerability reporting, and an Apache 2.0 LICENSE. It also updates the Gradle wrapper scripts (gradlew, gradlew.bat) to a newer version and configures code quality tools like Detekt and Codecov.

(repo-wide) · high confidence

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

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

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

The outbox core module now supports adaptive polling, which dynamically adjusts the polling interval based on workload to reduce database load during idle periods and increase responsiveness under high load. This is configured via the new \namastack.outbox.polling.trigger\ property (values: \fixed\ or \adaptive\) and associated \namastack.outbox.polling.fixed\ and \namastack.outbox.polling.adaptive\ settings, deprecating the older \namastack.outbox.poll-interval\ and \namastack.outbox.batch-size\ properties. Additionally, a new \@OpenForProxy\ marker annotation has been added to ensure Kotlin classes can be proxied by CGLIB for AOP instrumentation (e.g., OpenTelemetry), preventing startup failures for beans like \OutboxProcessingScheduler\ and \OutboxService\ that lack standard Spring stereotype annotations.

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

The outbox module now includes a new instance management layer that tracks active processor nodes in a distributed environment. This change adds the OutboxInstance data model, an OutboxInstanceRepository interface, and an OutboxInstanceRegistry service that implements Spring's SmartLifecycle. The registry automatically registers the current instance on startup, maintains a persistent record with hostname and port, and performs periodic heartbeats to detect stale nodes. It also handles graceful shutdown by marking the instance as SHUTTING\_DOWN before removal, allowing other instances to redistribute work. This enables horizontal scaling and load balancing across multiple application instances.

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

The outbox module now supports configurable retry behavior for message processing. A new factory creates retry policies based on application properties, supporting fixed, linear, and exponential backoff strategies with optional jitter and exception filtering. A registry resolves these policies per handler, allowing explicit policies via annotations or interfaces, with a fallback to a default policy. This enables users to fine-tune retry behavior for different handlers without code changes.

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

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

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

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

This release adds a new MongoDB backend for the Namastack Outbox module, providing the core persistence layer for outbox records, instance heartbeats, and partition assignments. The implementation includes Spring Data MongoDB repositories and entity mappings for the \outbox\_records\, \outbox\_instances\, and \outbox\_partition\_assignments\ collections, along with an auto-configuration that registers these beans. A key behavioral addition is the use of MongoDB multi-document transactions for partition assignment updates (\saveAll\), ensuring atomic reassignment and preventing split-brain scenarios during rebalancing. The module also supports configurable collection name prefixes and includes a setup script for manual index creation in production environments.

namastack-outbox-mongodb · high confidence

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

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

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

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

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

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

The outbox core module now provides dedicated Spring Boot auto-configuration classes that wire the complete outbox processing pipeline, including the record processor chain, partition coordination, and scheduling. The system automatically enables scheduling and configures the necessary beans for polling and processing. Additionally, the threading configuration now supports both platform and virtual threads, allowing the outbox processing executor and schedulers to adapt to the application's threading model via the \spring.threads\ properties.

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

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

The new \namastack-outbox-observability\ module provides automatic, Observation-based metrics and distributed tracing for the outbox processing pipeline. When Micrometer is on the classpath, the module instruments handler dispatches and record scheduling with timer metrics (e.g., \outbox.record.process\, \outbox.record.schedule\) and propagates trace context (W3C Trace Context) across async boundaries so that outbox processing appears as child spans in existing traces. It also registers instance-level and cluster-level gauge metrics (record counts by status, partition assignments, pending records, active instances, and unassigned partitions) via a Micrometer MeterBinder. The feature is opt-in, activated when \namastack.outbox.enabled\ is true and the required Micrometer beans are present, and it registers its auto-configurations via Spring Boot's standard import files.

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

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

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

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

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

The partition handling in the outbox core has been overhauled to support horizontal scaling and more efficient load distribution. The system now uses 256 partitions hashed via MurmurHash3 for record key distribution, ensuring deterministic assignment. A new \PartitionCoordinator\ manages the lifecycle of partitions, including bootstrapping initial assignments, claiming stale partitions from inactive instances, and releasing surplus partitions to maintain balance. The \DistributionCalculator\ implements a fair distribution algorithm that assigns partitions evenly across active instances. Additionally, a \PartitionAssignmentCache\ improves performance by caching partition assignments, and new statistics classes (\PartitionStats\, \PartitionProcessingStats\) provide monitoring capabilities for partition distribution and processing load.

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

The handler registration process in the outbox core has been refactored to introduce stable handler identities, support for fallback handlers, and handler-specific retry policies. A new BeanPostProcessor now discovers handlers (via annotations or interfaces), validates their declarations, and assembles complete registrations that include optional fallback methods and explicit retry configurations. This enables handlers to define fallback logic for permanent failures and allows fine-grained retry policy assignment per handler, improving reliability and backward compatibility through stable ID routing.

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

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

Added comprehensive test coverage for JPA outbox components; 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.

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

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.

• CAI 46 → 63 (+17.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 62 → 63 (+0.3)
• Architecture 100 → 98 (-1.6)
• Maturity 75 → 82 (+7.4)
• Readiness 25 → 60 (+34.5)
• Security 66 → 77 (+11.5)
• Accessibility 59 → 59 (+0.0)

• Change coupling: OutboxRecord.kt ↔ OutboxRecordEntity.kt (namastack-outbox-core/src/main/kotlin/io/namastack/outbox/OutboxRecord.kt)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (12 lines × 3) (namastack-outbox-examples/namastack-outbox-example-kafka/src/main/kotlin/io/namastack/demo/KafkaOutboxRoutingConfiguration.kt)
• Duplicated block (12 lines × 3) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxRecordEntityMapper.kt)
• Duplicated block (12 lines × 3) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxRecordEntityMapper.kt)
• Duplicated block (6 lines × 2) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxInstanceRepository.kt)
• Duplicated block (7 lines × 2) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxRecordRepository.kt)
• High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High CVE: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High vulnerability: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High vulnerability: [GHSA redacted] (namastack-outbox-docs/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 15 more

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (namastack-outbox-examples/namastack-outbox-example-h2/README.md)
• Documentation: no installation or build instructions (namastack-outbox-examples/namastack-outbox-example-java/README.md)
• Documentation: no installation or build instructions (namastack-outbox-examples/namastack-outbox-example-jdbc/README.md)
• Documentation: no installation or build instructions (namastack-outbox-examples/namastack-outbox-example-rabbit-java/README.md)
• Documentation: no installation or build instructions (namastack-outbox-examples/namastack-outbox-example-retry/README.md)
• Duplicated block (10 lines × 13) (namastack-outbox-examples/namastack-outbox-example-annotation/src/main/kotlin/io/namastack/demo/ExternalMailService.kt)
• Duplicated block (10 lines × 14) (namastack-outbox-examples/namastack-outbox-example-annotation/src/main/kotlin/io/namastack/demo/ExternalBroker.kt)
• Duplicated block (10 lines × 3) (namastack-outbox-examples/namastack-outbox-example-flyway-jdbc/src/main/kotlin/io/namastack/demo/customer/CustomerRepository.kt)
• Duplicated block (10 lines × 3) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxInstanceEntityMapper.kt)
• Duplicated block (12 lines × 2) (namastack-outbox-examples/namastack-outbox-example-flyway-jdbc/src/main/kotlin/io/namastack/demo/customer/CustomerRepository.kt)
• Duplicated block (12 lines × 3) (namastack-outbox-examples/namastack-outbox-example-kafka/src/main/kotlin/io/namastack/demo/KafkaOutboxRoutingConfiguration.kt)
• Duplicated block (15 lines × 3) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxRecordEntityMapper.kt)
• Duplicated block (17 lines × 17) (namastack-outbox-examples/namastack-outbox-example-annotation/src/main/kotlin/io/namastack/demo/DemoApplication.kt)
• Duplicated block (21 lines × 17) (namastack-outbox-examples/namastack-outbox-example-annotation/src/main/kotlin/io/namastack/demo/customer/CustomerService.kt)
• Duplicated block (25 lines × 3) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxRecordEntityMapper.kt)
• Duplicated block (5 lines × 2) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxInstanceRepository.kt)
• Duplicated block (5 lines × 3) (namastack-outbox-jdbc/src/main/kotlin/io/namastack/outbox/JdbcOutboxRecordEntityMapper.kt)
• Duplicated block (7 lines × 17) (namastack-outbox-examples/namastack-outbox-example-annotation/src/main/kotlin/io/namastack/demo/customer/CustomerService.kt)
• …and 51 more

• 30 commits — 25 feature/other, 5 fixes

• namastack-outbox-docs/package-lock.json — 7 commits
• (root) — 4 commits
• namastack-outbox-core/src — 3 commits
• (repo) — 2 commits
• gradle/libs.versions.toml — 2 commits
• gradle/wrapper — 2 commits
• namastack-outbox-docs/docs — 2 commits
• namastack-outbox-docs/versioned_docs — 2 commits
• namastack-outbox-examples/namastack-outbox-example-annotation — 2 commits
• namastack-outbox-api/src — 1 commit
• namastack-outbox-docs/src — 1 commit
• namastack-outbox-examples/namastack-outbox-example-fallback — 1 commit
• namastack-outbox-examples/namastack-outbox-example-sns — 1 commit

• fix: GH-420 fix docs [skip ci]
• fix: GH-433 Fix OutboxFailureContext.lastException in documentation (#439)
• fix: GH-469 fix interface-based fallback handler documentation
• fix: fix assertions in OutboxCoreAutoConfigurationTest
• fix: support spring boot snapshot tests and fix
• change: Bump brace-expansion (#419)
• change: Bump browserslist (#458)
• change: Bump fast-uri (#457)
• change: Bump gradle-wrapper (#425)
• change: Bump gradle-wrapper (#441)
• change: Bump gradle-wrapper from 9.6.1 to 9.7.0 (#424)
• change: Bump gradle-wrapper from 9.7.0 to 9.7.1 (#440)
• change: Bump io.awspring.cloud:spring-cloud-aws-dependencies from 4.1.0 to 4.1.1 (#451)
• change: Bump io.awspring.cloud:spring-cloud-aws-starter-sns (#452)
• change: Bump kotlin from 2.4.10 to 2.4.20 (#465)
• change: Bump mermaid (#423)
• change: Bump the npm_and_yarn group across 1 directory with 2 updates (#426)
• change: Bump the npm_and_yarn group across 1 directory with 2 updates (#463)
• change: Bump the npm_and_yarn group across 1 directory with 3 updates (#422)
• change: Bump the npm_and_yarn group across 1 directory with 3 updates (#462)
• …and 10 more

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

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.