AxonIQ/AxonFramework

This system is the Axon Framework, a Java-based toolkit for building event-driven and event-sourced applications using CQRS patterns. It provides core infrastructure for managing entity lifecycles through event sourcing, including robust snapshotting, consistency markers, and transactional event storage with JPA and in-memory backends. The framework supports flexible serialization via a modular conversion system (Jackson, Avro, etc.), distributed tracing, and metrics collection, while offering extensive Spring Boot auto-configuration and multi-tenancy capabilities for enterprise deployment.

91 changes.

This period covers the comprehensive development of Axon Framework 5.0, introducing a new entity modelling system with annotation-based support and a restructured event sourcing engine featuring atomic batch visibility and aggregate-based storage. The work also established a robust Spring Boot integration with declarative configuration, dedicated auto-configuration classes, and enhanced metrics monitoring via Micrometer and Dropwizard. Additionally, it included the creation of automated migration tools for upgrading from version 4.x and extensive test coverage to validate the new architectural foundations.

68 changes.

This period focused on enhancing developer experience and operational visibility by introducing comprehensive Spring Boot auto-configuration for metrics, testing, and legacy saga support. It also established robust distributed tracing across the event sourcing layer and expanded the framework's ecosystem with new Kotlin extensions and multi-tenancy examples.

The university multi-tenancy demo now includes a dedicated write slice for opening courses. This change introduces the OpenCourse command, an event-sourced State entity to track whether a course is open, and an OpenCourseCommandHandler that ensures idempotency by ignoring duplicate open requests. The slice is wired via OpenCourseConfiguration, registering the entity and command handling modules for both declarative and Spring Boot wiring styles, allowing tenants to open courses with a specified capacity while keeping event streams isolated per tenant.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/university/write/opencourse · high confidence

This change introduces tracing instrumentation for the Axon Framework event sourcing module. It adds a \TracingEntityLifecycleHandler\ that wraps entity lifecycle operations, opening an internal span around the \source\ method to capture entity ID and type attributes, while leaving initialization and subscription paths uninstrumented to avoid trace noise. Additionally, it provides a \TracingEventTagsHandlerEnhancerDefinition\ that automatically enriches active spans with event tags when \@EventHandler\ methods are invoked, resolving tags via the configured \TagResolver\ and \EventConverter\ to complement the publish-side tracing.

eventsourcing/src/main/java/org/axonframework/eventsourcing/handler/tracing · high confidence

New tracing decorators have been introduced for the Axon Framework event sourcing layer. The \TracingEventStorageEngine\ now wraps the event storage engine to trace the complete logical append transaction (from invocation through commit, rollback, or failure), ensuring spans are properly closed even if a \ProcessingContext\ is abandoned. The \TracingEventStore\ decorator ensures that event publishing is traced via \TracingEventSink\, while other \EventStore\ operations are passed through. Additionally, an \EventTagsSpanAttributesProvider\ is available to automatically attach event tags as span attributes, with configurable prefixes and allowlists.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore/tracing · high confidence

A new Jackson deserializer (JacksonPageDeserializer) has been added to the Spring Data extension, enabling the conversion of JSON representations of paginated data into Spring Data PageImpl instances. This allows users to seamlessly deserialize paginated responses from JSON sources into standard Spring Data Page objects, with sensible defaults applied for missing fields like page number, size, and total elements.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/data · high confidence

The eventsourcing module now supports creating event-sourced entities via reflection using the new @EntityCreator annotation on constructors or static factory methods. This allows entities to be initialized with event payloads, identifiers (via @InjectEntityId), or configuration, with the factory automatically resolving parameters and matching event types. A new @ForcedEntityCreator annotation ensures entities are instantiated even when no initial event is present, simplifying create-if-missing scenarios without requiring static command handlers. The AnnotationBasedEventSourcedEntityFactory handles polymorphic subtypes and validates that at least one creator is defined.

eventsourcing/src/main/java/org/axonframework/eventsourcing/annotation/reflection · high confidence

The \eventsourcing\ module now supports defining entities via the \@EventSourcedEntity\ annotation, enabling automatic loading, instantiation, and command handling without manual repository configuration. Users can customize event loading via \@EventCriteriaBuilder\ methods or the \tagKey\ attribute, define entity creation using \@EntityCreator\, and enable declarative snapshotting with \@Snapshotting\. This change introduces the \AnnotationBasedEventCriteriaResolver\, \AnnotationBasedEventSourcedEntityFactory\, and related definition interfaces to manage these behaviors.

eventsourcing/src/main/java/org/axonframework/eventsourcing/annotation · high confidence

This module introduces OpenRewrite recipes that automate the mechanical migration of Axon Framework applications from version 4.x to 5.x. The recipes handle build file updates (swapping BOMs, bumping Java versions), package and class renames (e.g., EventBus to EventSink), and annotation rewrites (such as @Aggregate to @EventSourced, @Revision to @Event, and @CreationPolicy removal). It also automates test fixture migrations (AggregateTestFixture to AxonTestFixture with generated @AfterEach teardowns), command routing key lifting (@RoutingKey to @Command), and snapshotting configuration updates. Users run these recipes via Maven or Gradle to significantly reduce manual refactoring effort, with remaining non-automatable changes marked by TODO comments.

migration · high confidence

Axon Framework now automatically wires distributed tracing into the event-sourcing module when a tracing backend is present on the classpath. Configuration enhancers registered via ServiceLoader decorate the EventStorageEngine, SnapshotStore, and EventStore with tracing wrappers, while a new EventSourcingTracingSettings record allows users to toggle tracing for each component (event store, snapshot store) and control whether event tags are recorded as span attributes. This enables out-of-the-box observability for event sourcing operations without manual wiring.

eventsourcing/src/main/java/org/axonframework/eventsourcing/tracing · high confidence

Axon Framework 5.0 adds a new Update Checker module that periodically sends anonymous usage data to Axoniq to detect available library upgrades and security vulnerabilities. The system automatically starts during the external connections phase, sending details about the JVM, operating system, and installed Axon libraries to a telemetry endpoint. Users receive formatted log reports highlighting any detected vulnerabilities (with severity and fix versions) or available upgrades. The feature respects user privacy by allowing opt-out via the \AXONIQ\_UPDATE\_CHECKER\_DISABLED\ environment variable, the \-Daxoniq.update-checker.disabled=true\ JVM property, or a local configuration file, and it automatically disables itself when a test environment is detected.

update · high confidence

A new declarative multi-tenancy demo has been added to the examples, allowing users to run the university scenario using the declarative Configuration API instead of Spring Boot. The demo supports two modes: an in-memory default mode using a bundled tenant provider, and an Axon Server mode enabled via the \demo.axon-server.enabled\ property, which sources tenants from Axon Server contexts. When using Axon Server, the demo also supports persistent streams for the course-statistics projection via the \demo.axon-server.persistent-streams.enabled\ toggle. The configuration wires per-tenant component providers for statistics and audit logs, and includes a local query handler switch to ensure direct queries are routed through the per-tenant connector.

examples/university-multi-tenancy-examples/university-multi-tenancy-declarative/src/main · high confidence

Adds a new university-demo application that demonstrates an event-sourced faculty module, including write-side commands (enrolling students, creating and renaming courses, changing capacity), read-side projections for course statistics, and automations such as notifying when all courses are fully booked or when a student subscribes to a course.

examples/university-demo/src/main/java · high confidence

The test module now includes a JUnit 5 extension (AxonFrameworkExtension) and supporting annotations (@ProvidedAxonTestFixture) that automatically manage the lifecycle of the AxonTestFixture. This allows test classes to inject the fixture directly as a method parameter, with the extension handling setup and teardown, while also introducing dedicated exception types (AxonAssertionError, FixtureExecutionException) to provide clearer error reporting during test execution.

test · high confidence

The AvroConverter and its supporting classes have been introduced in the conversion module to handle serialization and deserialization of Avro messages using single-object encoding. This includes configuration via AvroConverterConfiguration, strategy-based conversion for SpecificRecordBase types, and utilities for schema compatibility checking and fingerprinting, enabling users to convert between Avro binary formats and Java objects within the Axon Framework.

conversion/src/main/java/org/axonframework/conversion/avro · high confidence

Added a standalone example module demonstrating Axon Framework 4.12.x with Spring Boot 4 and Java 21. The example includes a Spring Boot application that connects to Axon Server, configures Jackson serialization, and uses an in-memory event store and projection to handle course creation commands and queries. It also provides an IntelliJ run configuration and documentation for running the example independently.

examples/framework4-springboot4 · high confidence

The \axon-spring-boot-starter-test\ module now provides a dedicated \@AxonSpringBootTest\ meta-annotation and \AxonTestConfiguration\ that automatically register an \AxonTestFixture\ bean within the Spring Boot test context. This allows test classes to inject the fixture directly, with command and event recording enabled out-of-the-box. The fixture's integration mode is automatically derived from the \axon.axonserver.enabled\ property, and the bean is configured with a \destroyMethod\ to ensure proper cleanup after tests.

extensions/spring/spring-boot-starter-test/src/main · high confidence

Added a new Java-based example application that models a university faculty domain using event sourcing and CQRS. The example includes a main application entry point, configuration for Axon Server integration, and a faculty initializer that seeds data. It demonstrates key patterns such as command handling for course creation and capacity changes, event sourcing for tracking course state, and a read-side projection that maintains course statistics in an in-memory repository. The example also features an automation component that sends notifications when a course becomes fully booked, showcasing event-driven business logic.

examples/university-java/src/main · high confidence

The Kotlin extension now provides idiomatic APIs for Axon users, including reified gateway methods (sendWithResult, sendAndWait, query, queryMany, subscriptionQuery, streamingQuery) that eliminate the need for explicit Java class arguments, and convenience aliases like whenever() to bypass Kotlin's reserved when keyword in test fixtures. It also introduces a Kotlin-reflect-based NullabilityResolver that correctly honors Kotlin's T? nullability declarations at runtime, a Kotlin-reflect PropertyAccessStrategy that supports value classes, and helper utilities such as evolveIf() for event sourcing and metadata accessors.

extensions/kotlin/kotlin · high confidence

A new Kotlin-based university demo has been added to the examples directory, demonstrating event sourcing with the Axon Framework. The example models a faculty domain where students can be enrolled and subscribed to courses, using Kotlin-specific features like value classes for IDs and nullable types for create-or-update command handling. It includes both a standard state-machine implementation and a polymorphic state implementation for course subscriptions, along with a docker-compose file for running the Axon Server infrastructure.

examples/university-demo-kotlin · high confidence

The Micrometer metrics extension now includes a set of new monitor implementations that automatically instrument Axon components with detailed performance metrics. The MetricsConfigurationEnhancer registers these monitors on CommandBuses, EventSinks, EventProcessors, and QueryBuses. Specifically, MessageCountingMonitor tracks ingested, successful, failed, and ignored message counts; MessageTimerMonitor records processing durations with configurable percentile distributions; CapacityMonitor estimates processing capacity based on message throughput and duration within a sliding time window; and EventProcessorLatencyMonitor measures the lag between event publication and processing. These monitors leverage Micrometer's MeterRegistry and support optional dimensionality via tags for message types and processor names, with a custom SlidingTimeWindowReservoir handling time-windowed capacity calculations.

extensions/metrics/metrics-micrometer/src/main/java/org/axonframework/extension/metrics/micrometer · high confidence

The university example now includes a Spring Boot 4 variant that demonstrates event-driven automation and real-time read-model updates. It introduces a notification automation system that automatically detects when a course is fully booked and sends a notification command, alongside a course statistics projection that keeps a read model in sync with domain events. Users can view course statistics via REST endpoints, including real-time streaming updates using Server-Sent Events (SSE) through subscription queries.

examples/university-java-springboot-3, examples/university-java-springboot-4 · high confidence

The Spring Boot autoconfigure extension now includes new utility classes to support more precise bean registration and database integration. Developers can use the new \@ConditionalOnQualifiedBean\ and \@ConditionalOnMissingQualifiedBean\ annotations to conditionally register beans based on the presence of specific qualifiers, with support for negation and multiple qualifiers. Additionally, the \DefaultEntityRegistrar\ and \@RegisterDefaultEntities\ annotation simplify the registration of entities from specified packages. For database interactions, the \SpringDataSourceConnectionProvider\ ensures JDBC connections are properly managed within active Spring transactions, while the \ContainerManagedEntityManagerProvider\ facilitates the injection of container-managed JPA \EntityManager\ instances.

extensions/spring/spring-boot-autoconfigure/src/main/java/org/axonframework/extension/springboot/util, extensions/spring/spring/src/main/java/org/axonframework/extension/spring/jdbc · high confidence

The Spring Boot auto-configuration module now exposes dedicated \@ConfigurationProperties\ classes for key Axon subsystems, allowing users to configure them via \application.properties\ or \application.yml\. This includes \ConverterProperties\ for managing serialization strategies (general, message, and event converters), \EventProcessorProperties\ for tuning event processor modes and token claims, \JpaEventStorageEngineConfigurationProperties\ for JPA storage engine defaults (batch size, gap cleaning), \TimeoutProperties\ for setting limits on unit-of-work and message handlers, \TokenStoreProperties\ for claim timeouts, \TracingProperties\ for distributed tracing toggles and component-level settings, and \UpdateCheckerProperties\ to disable the update checker. These properties provide a structured, type-safe way to tune Axon Framework behavior within a Spring Boot application.

extensions/spring/spring-boot-autoconfigure/src/main/java/org/axonframework/extension/springboot · high confidence

A new SpringTransactionManager implementation has been added to the Spring extension's unit of work package. This component integrates Spring's PlatformTransactionManager with Axon's processing lifecycle, allowing transactions to be started, committed, or rolled back in sync with message processing. It also provides JPA EntityManagerExecutor and JDBC ConnectionExecutor resources when the respective providers are available, ensuring database operations participate in the same transactional context as the messaging unit of work.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/messaging/unitofwork · high confidence

The Spring extension now provides dedicated stereotype annotations (such as @EventSourced) that allow developers to mark Spring components as event-sourced entities directly. These annotations act as meta-annotations for Axon's core @EventSourcedEntity, enabling Spring's auto-configuration to automatically detect and manage entity instances with configurable properties for ID resolution, event criteria, and entity factories. The package is also marked with JSpecify nullability annotations to improve static analysis support.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/stereotype · high confidence

The Spring extension now includes new utility classes, BeanDefinitionUtils and SpringUtils, to assist with Spring bean definition resolution and qualifier matching, alongside the introduction of AxonStartedEvent to signal when Axon is fully initialized. Additionally, the package-level nullability annotations have been adopted using JSpecify's @NullMarked.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring · high confidence

The common module now includes a new Assert utility class for parameter and state validation, a dedicated exception hierarchy (AxonException, AxonConfigurationException, etc.), and various utility classes for builders, collections, dates, identifiers, executors, and futures. These additions provide a self-contained set of infrastructure tools without requiring external dependencies like Spring for basic assertion logic.

common/src/main · high confidence

The conversion module now includes five new {@code ContentTypeConverter} implementations: {@code BlobToInputStreamConverter}, {@code ByteArrayToInputStreamConverter}, {@code ByteArrayToStringConverter}, {@code InputStreamToByteArrayConverter}, and {@code StringToByteArrayConverter}, enabling direct conversion between SQL Blobs, byte arrays, strings, and input streams. Additionally, the {@code converter} package has been annotated with JSpecify nullability markers (e.g., {@code @NullMarked}, {@code @Nullable}) to improve static analysis and null-safety guarantees.

conversion/src/main/java/org/axonframework/conversion/converter · high confidence

A new \org.axonframework.conversion\ package has been introduced to centralize object conversion logic. This includes a new \GeneralConverter\ interface for unrestricted type conversion, a \ChainingContentTypeConverter\ that automatically discovers and chains \ContentTypeConverter\ implementations via Java ServiceLoader, and utility classes like \CachingSupplier\ and \PassThroughConverter\. This modularizes conversion capabilities previously scattered in messaging components, providing a dedicated contract for general-purpose conversion tasks.

conversion/src/main/java/org/axonframework/conversion · high confidence

The university-message-transformation example now includes a complete course-catalog demo application that demonstrates event transformation capabilities. The demo features an interactive REPL shell (accessible via --keep-alive) for running sample commands like publishing courses, updating capacity, and enrolling students. It includes a transformation chain that lifts legacy events (CourseOffered, CourseListedWithSeats, StudentRegistered) to their current shapes (CoursePublished v3, CourseCapacityChanged, StudentEnrolledInCourse with region backfilling). The application supports AxonIQ Platform integration through configuration properties loaded from application.properties, .env files, and environment variables, with Axon Server connection toggled via axon.server.enabled. An overbooking notifier automation alerts when course capacity ranges exceed 20 seats, and the demo seeds historic events idempotently to demonstrate the transformation chain in action.

examples/university-message-transformation/src/main · high confidence

The eventsourcing module now provides a new configuration API centered on the \EventSourcingConfigurer\ and \EventSourcedEntityModule\. Users can register event-sourced entities using a fluent, declarative builder or automatically via the \@EventSourcedEntity\ annotation, which simplifies setup by handling metamodels, factories, and criteria resolvers. The \EventSourcingConfigurationDefaults\ enhancer automatically registers default components like \TagResolver\, \EventStorageEngine\, and \EventStore\, while disabling the standard \EventBus\ defaults to prevent conflicts. Additionally, snapshot sourcing is now handled via a dedicated \SnapshotSourcingConfigurationEnhancer\ that decorates the storage engine, and entity ID resolution includes automatic payload conversion to support polymorphic types.

eventsourcing/src/main/java/org/axonframework/eventsourcing/configuration · high confidence

The multi-tenancy demo now includes a dedicated write slice for enrolling students in courses. This adds a new command (EnrollStudent), an event-sourced course state that is snapshotted per tenant, and a command handler that validates enrollment against the tenant's own event store (rejecting if the course is not open or full). The handler appends enrollment events and, when running on a shared event store backing, directly updates the tenant-scoped statistics and audit log; on Axon Server, a separate projection handles the read model. Configuration classes wire the entity and command handler, exposing modules for Spring Boot and a snapshot name resolver for other wiring styles.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/university/write/enrollstudent · high confidence

The modelling module introduces the foundational interfaces and components for the new entity modelling system in version 5.0.0. This includes the \StateManager\ interface and its \SimpleStateManager\ and \HierarchicalStateManager\ implementations, which handle entity loading and persistence via registered \Repository\ instances. The \EntityEvolver\ and \EntityEvolvingComponent\ interfaces (with \SimpleEntityEvolvingComponent\ and \AnnotationBasedEntityEvolvingComponent\ implementations) define how entities evolve their state based on incoming events. Additionally, \EntityIdResolver\ and \PropertyBasedEntityIdResolver\ provide mechanisms for resolving entity identifiers from message payloads, supported by a set of new exceptions such as \EntityIdResolutionException\, \MissingRepositoryException\, and \ConcurrencyException\ to handle specific error scenarios.

modelling · high confidence

The eventsourcing module introduces a new handler API in the \org.axonframework.eventsourcing.handler\ package to manage the lifecycle of event-sourced entities. This includes the \EntityLifecycleHandler\ interface and its implementations (\SimpleEntityLifecycleHandler\ and \SnapshottingEntityLifecycleHandler\), which handle entity initialization, sourcing from the event store (with optional snapshot support), and live event subscription. The \InitializingEntityEvolver\ class coordinates entity creation and state evolution, while \SourcingHandler\ defines the contract for reconstructing entities from historical events. This refactoring decouples the sourcing and lifecycle logic, allowing for more flexible entity management strategies.

eventsourcing/src/main/java/org/axonframework/eventsourcing/handler · high confidence

The Spring extension now provides a new fluent configuration API (EventProcessorDefinition) for explicitly defining event processors and assigning event handlers to them. Users can create pooled streaming or subscribing processors, specify handler selection criteria using the new EventHandlerSelector (which supports matching by @Namespace annotation), and apply custom configuration. The underlying DefaultProcessorModuleFactory uses these definitions to group handlers and build the corresponding EventProcessorModules, replacing the previous implicit assignment logic.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/config · high confidence

Axon Framework introduces an in-memory implementation of the SnapshotStore interface, designed for testing, prototyping, and single-node scenarios. The store supports two modes: a default constructor that retains snapshot payloads by reference, and a constructor accepting a Converter that serializes and deserializes payloads on both store and load operations. This conversion-based copying ensures that later mutations to mutable entity instances do not alter previously stored snapshots, providing isolation behavior that mirrors production-grade durable stores. The implementation is thread-safe, uses ConcurrentHashMap for storage, and returns immediate CompletableFutures to align with the asynchronous API.

eventsourcing/src/main/java/org/axonframework/eventsourcing/snapshot/inmemory · high confidence

The multi-tenancy demo now includes a structured lifecycle runner and outcome reporting system. The new \DemoApplication\ record and \DemoLifecycle\ class orchestrate the end-to-end demo scenario, handling tenant provisioning, enrollment, and statistics tracking. The \DemoOutcome\ record and its sub-records (\EventStorageOutcome\, \SnapshottingOutcome\, \StreamingOutcome\, \SubscriptionQueryOutcome\, \QueryRejectionOutcome\) capture and report the results of the demo run, including tenant isolation, snapshotting, event processing, and subscription query behavior. A \ProviderAmbiguityGuardrail\ class demonstrates framework guardrails against ambiguous tenant component providers. This change provides a more structured and observable way to run and verify the multi-tenancy demo.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared/run · high confidence

The multi-tenancy demo now uses a shared core module to support multiple demonstration styles (declarative and Spring Boot) with consistent behavior. This location introduces configuration enums to select the infrastructure backing (in-memory vs. Axon Server) and the event processing style (pooled streaming vs. persistent streams), alongside a new tenant-scoped audit log component that records entries per tenant. These shared components allow the demo to toggle between different multi-tenancy architectures and observe how tenant isolation and event processing behave in each setup.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared · high confidence

The multi-tenancy demo now includes a shared tenant package that standardizes how tenants are provisioned and managed across both in-memory and Axon Server backends. This adds an in-memory tenant provider for local runs, an Axon Server context manager to provision and delete server contexts at runtime, and a tenant provisioning abstraction that handles the lifecycle of adding and removing tenants. It also introduces per-tenant component providers for course statistics and audit logs, a utility for building multi-tenant persistent stream event sources, and a snapshot lookup helper to inspect per-tenant snapshot stores.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared/tenant · high confidence

The Reactor extension now provides Reactor-specific command, event, and query gateways that run dispatch interceptors inside the Reactor subscription. This allows interceptors to access Reactor context (such as ReactiveSecurityContextHolder) during message dispatch, which was previously unavailable. The extension introduces ReactorMessageDispatchInterceptor and ReactorDispatchInterceptorRegistry components, along with configuration defaults that wire these interceptors into the new gateway implementations.

extensions/reactor/axon-reactor · high confidence

A new META-INF/services file has been added to register the default content-type converters for the Axon Framework conversion module. This enables automatic discovery and usage of converters for common data types, including conversions between byte arrays and input streams, as well as byte arrays and strings.

conversion/src/main/resources · high confidence

The repository has been initialized with the Axon Framework codebase, including the Apache 2.0 license, a comprehensive README with project overview and migration notes, and contribution guidelines. The project is configured for Java 21 and uses the Maven Wrapper (version 3.3.4) for builds. Standard development tooling is established via .editorconfig, .gitattributes, and .gitignore files, alongside IDE-specific style definitions (axon\_code\_style.xml) and copyright templates to ensure consistent code formatting and legal compliance across the project.

(repo-wide) · high confidence

The saga-recipes example now includes a generic payment context that models payments using two distinct identifiers: a system-generated PaymentId and a caller-supplied PaymentReference. This design makes the PreparePayment command idempotent by construction, as the decision model is keyed by the reference rather than the identifier. The context supports preparing, confirming, rejecting, and cancelling payments, with cancellation serving as a deadline replacement for Axon Framework 5's missing DeadlineManager via a scheduled sweep.

examples/saga-recipes/src/main · high confidence

The legacy module now includes Spring Boot auto-configuration for Axon Framework 4 Sagas, enabling seamless migration of existing Saga implementations. This adds automatic discovery of @Saga-annotated beans via SpringSagaLookup, assembly of dedicated event processors through SagaProcessorConfigurer, and fallback to an InMemorySagaStore if no other store is configured. It also provides auto-configured JPA and JDBC SagaStore implementations (LegacyJpaSagaStoreAutoConfiguration and LegacyJdbcSagaStoreAutoConfiguration) that respect the same precedence rules as Axon Framework 4, ensuring Saga persistence works out-of-the-box with existing DataSource or EntityManagerFactory infrastructure.

legacy · high confidence

The Micrometer metrics extension now includes Spring Boot auto-configuration, allowing metrics to be automatically set up when the required classes are present. A new \MetricsProperties\ class exposes the \axon.metrics\ configuration prefix, enabling users to toggle metrics on or off via \axon.metrics.enabled\ (defaulting to true) and to enable Micrometer dimensional tags via \axon.metrics.micrometer.dimensional\. The \MicrometerMetricsAutoConfiguration\ registers a \SimpleMeterRegistry\ if none is already defined and ensures the metrics configuration enhancer is properly integrated with the Axon application context.

extensions/metrics/metrics-micrometer/src/main/java/org/axonframework/extension/metrics/micrometer/springboot · high confidence

The university multi-tenancy example now includes a Spring Boot implementation that demonstrates tenant-aware event processing and query handling via autoconfiguration. The demo features a configurable projection processor that can run as either a pooled streaming processor (default) or a subscribing processor fed by persistent streams, selectable via the \axon.axonserver.auto-persistent-streams-enabled\ property. It also configures the distributed query bus to route direct queries through the per-tenant connector rather than preferring local handlers, ensuring the multi-tenant routing behavior is visible during the demo run.

examples/university-multi-tenancy-examples/university-multi-tenancy-springboot/src/main · high confidence

The Spring extension now includes authorization support within the \org.axonframework.extension.spring.authorization\ package. \MessageAuthorizationDispatchInterceptor\ automatically injects the current Spring Security username and authorities into message metadata during dispatch, making them available downstream. \MessageAuthorizationHandlerInterceptor\ and \SecuredMessageHandlerDefinition\ enforce access control by checking these metadata authorities against \@Secured\ annotations on message payloads and handler methods, throwing \UnauthorizedMessageException\ if access is denied.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/authorization · high confidence

The Spring extension now automatically resolves method and constructor parameters in Axon handlers as Spring beans. By marking a parameter with Spring's @Autowired or @Qualifier, the framework will inject the corresponding bean from the ApplicationContext, supporting both single-bean resolution and explicit qualification. This capability is provided by new configuration classes in the Spring extension that wire Spring's dependency injection into Axon's parameter resolution pipeline.

extensions/spring/spring/src/main/java/org/axonframework/extension/spring/config/annotation · high confidence

The multi-tenancy demo now includes a shared messaging package that provides tenant-aware command and query helpers. Enrollments and StatisticsQueries drive the command and query gateways by attaching tenant metadata, ensuring messages are routed to the correct tenant's isolated components. TenantMetadataFactory builds this metadata, while RemoteExceptions and TenantRejections handle exception matching and tenant resolution failures, including transient states. StatisticsSubscription manages live statistics subscriptions, completing when a tenant's courses are full.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/shared/messaging · high confidence

The university multi-tenancy demo now includes a dedicated statistics read slice that tracks course enrollment counts and audit log sizes per tenant. This change introduces a \CourseStatisticsProjection\ that updates a tenant-scoped \CourseStatisticsStore\ via a single pooled streaming event processor (or persistent streams), ensuring that statistics are isolated to each tenant's context. A new \TenantStatisticsQueryHandler\ allows tenants to query their own enrollment statistics using \@TenantScoped\ injection, demonstrating that tenant-aware component resolution works for both command and query handlers. The implementation includes in-memory backing for the demo, configuration for the event processor, and logic to emit query updates and complete subscriptions when a tenant's courses are full.

examples/university-multi-tenancy-examples/university-multi-tenancy-core/src/main/java/org/axonframework/examples/demo/multitenancy/university/read · high confidence

The \stash/legacy\ module now contains a collection of deprecated Axon Framework classes (such as \Serializer\, \SerializedMessage\, \UnitOfWorkAwareConnectionProviderWrapper\, and saga configuration types) that are marked for removal in version 5.0.0. These files are preserved in a stashed location as a reference for legacy behavior and are not actively maintained, reflecting the framework's shift from the \Serializer\ to the \Converter\ interface and the deprecation of older saga and JDBC connection management patterns.

stash/legacy · high confidence

The JPA event store now recognizes MariaDB-specific duplicate key errors (codes 1022, 1061, and 1062) via the new SQLErrorCode.properties file. This ensures that constraint violations during event persistence are correctly identified and handled as duplicate key exceptions rather than generic database errors.

eventsourcing/src/main/resources/org · high confidence

The in-memory event storage engine now ensures that committed batches of events are visible to consumers atomically. Events are stored individually, but the position advanced for readers is only updated after the entire batch is persisted, meaning a reader sourcing or streaming during a commit will observe either none of the batch or all of it, never a partial prefix.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore/inmemory · high confidence

The command handling API in the messaging module has been restructured to align with the new core messaging abstractions. The CommandBus now dispatches commands using a ProcessingContext and returns a CompletableFuture\<CommandResultMessage\>. Command handlers are defined via the CommandHandler functional interface, which returns a MessageStream.Single\<CommandResultMessage\>. New interfaces and classes include CommandHandlerRegistry for subscribing handlers by QualifiedName, CommandHandlingComponent to group handlers, and CommandHandlingExceptionHandler for custom error handling. CommandMessage now supports routingKey and priority, and GenericCommandMessage implements these with metadata and conversion support. Exceptions like CommandExecutionException and CommandDispatchException are updated to fit the new HandlerExecutionException hierarchy and detail conversion model.

messaging · high confidence

The Event Sourcing module now registers its tracing-related configuration enhancers via Java SPI service files, allowing them to be loaded conditionally. Specifically, the new \META-INF/services/org.axonframework.common.configuration.ConfigurationEnhancer\ file declares \EventSourcingConfigurationDefaults\, \EventSourcingSpanAttributesProviderConfigurationEnhancer\, and \EventSourcingTracingConfigurationEnhancer\, while \META-INF/services/org.axonframework.messaging.core.annotation.HandlerEnhancerDefinition\ registers \TracingEventTagsHandlerEnhancerDefinition\. This enables the framework to apply tracing enhancements to event handlers and configuration only when tracing is explicitly enabled or configured, rather than unconditionally.

eventsourcing/src/main/resources/META-INF · high confidence

The Spring Boot auto-configuration for Dropwizard metrics in the Axon Framework extension no longer requires the explicit setting of \axon.metrics.enabled=true\; it now activates automatically when the required classes are present. Users can still disable this behavior by setting \axon.metrics.enabled=false\. This change simplifies setup for users who want metrics out-of-the-box, while preserving the ability to opt out via configuration.

extensions/metrics/metrics-dropwizard/src/main/java/org/axonframework/extension/metrics/dropwizard/springboot · high confidence

The Dropwizard metrics extension has been refactored to provide a more modular and configurable monitoring experience. The new implementation introduces dedicated monitor classes: CapacityMonitor for tracking processing capacity, EventProcessorLatencyMonitor for measuring event processing lag, MessageCountingMonitor for aggregate message counts, and MessageTimerMonitor for detailed timing histograms. These are orchestrated by a new MetricsConfigurationEnhancer that automatically decorates CommandBuses, EventSinks, EventProcessors, and QueryBuses with the appropriate monitors. Additionally, a PayloadTypeMessageMonitorWrapper allows for granular, per-payload-type monitoring. The extension now relies on the JSpecify nullability annotations and uses the application-wide Clock configuration.

extensions/metrics/metrics-dropwizard/src/main/java/org/axonframework/extension/metrics/dropwizard · high confidence

The University Demo application now includes an application.properties file that explicitly enables Axon Server connectivity by setting axon.server.enabled to true, allowing the demo to interact with an Axon Server instance.

examples/university-demo/src/main/resources · high confidence

The Spring Boot auto-configuration module now provides dedicated auto-configuration classes for specific serialization formats, including Avro, CBOR, and the default converter. This change replaces the previous monolithic approach with separate classes (such as AvroConverterAutoConfiguration, CBORMapperAutoConfiguration, and CBORConverterAutoConfiguration) that conditionally register beans based on the 'axon.converter' properties. Users can now select their preferred serialization format (e.g., Avro or CBOR) via configuration, and the framework will automatically wire the necessary converters and schema stores without requiring manual bean setup.

extensions/spring/spring-boot-autoconfigure/src/main/java/org/axonframework/extension/springboot/autoconfig · high confidence

The Jackson message conversion classes in the \org.axonframework.conversion.jackson\ package have been updated to use Jackson 3 (package \tools.jackson\), introducing a new \JacksonConverter\ that detects and rejects incompatible Jackson 2 tree nodes to prevent silent data corruption. A parallel set of converters in the \org.axonframework.conversion.jackson2\ package (using \com.fasterxml.jackson\) provides the existing \Jackson2Converter\ for users who need to maintain Jackson 2 compatibility.

conversion/src/main/java/org/axonframework/conversion/jackson · high confidence

The Dropwizard and Micrometer metrics extensions now explicitly declare their Spring Boot auto-configuration classes and Axon configuration enhancers via standard service-loader files. This ensures that the respective auto-configurations (DropwizardMetricsAutoConfiguration and MicrometerMetricsAutoConfiguration) and configuration enhancers are automatically detected and applied when these modules are on the classpath, removing the need for manual configuration wiring in Spring Boot applications.

extensions/metrics/metrics-dropwizard/src/main/resources, extensions/metrics/metrics-micrometer/src/main/resources · high confidence

The JPA event storage implementation has been replaced with a new aggregate-based design. The storage engine now uses an \AggregateEventEntry\ JPA entity with a unique constraint on the aggregate identifier and sequence number, and it supports a polling-based \JpaPollingEventCoordinator\ to detect new events. Configuration is handled via \AggregateBasedJpaEventStorageEngineConfiguration\, which introduces settings for batch size, gap cleaning thresholds, and an \EventTypeResolver\ to handle event type resolution, while \SQLErrorCodesResolver\ and \SQLStateResolver\ provide database-specific duplicate key detection.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore/jpa · high confidence

The snapshotting subsystem introduces a new \SnapshotStore\ interface in the \org.axonframework.eventsourcing.snapshot.store\ package, replacing previous mechanisms with an asynchronous API that accepts a \ProcessingContext\ for correlation. This change enables automatic tracing of snapshot operations via the new \TracingSnapshotStore\ decorator, which wraps store and load calls with spans labeled by the snapshot's qualified name and entity identifier, improving observability for event-sourced entities.

eventsourcing/src/main/java/org/axonframework/eventsourcing/snapshot/store · high confidence

The event sourcing event store now uses a new \ConsistencyMarker\ interface and \AppendCondition\ sealed interface to manage concurrency and conflict detection. \ConsistencyMarker\ defines boundaries (ORIGIN, INFINITY, lower/upper bounds) to track event stream positions, with specific implementations like \AggregateBasedConsistencyMarker\ for per-aggregate tracking. \AppendCondition\ specifies the criteria and marker against which new events are validated during append operations, replacing previous mechanisms. This change introduces \AppendEventsTransactionRejectedException\ to report conflicts with details on tags and conflicting events, and \ConflictDiagnosingEventStorageEngine\ to help identify the specific event causing a rejection. Additionally, \AnnotationBasedTagResolver\ allows tagging events via \@EventTag\ annotations on payload fields/methods.

eventsourcing/src/main/java/org/axonframework/eventsourcing/eventstore · high confidence

The event sourcing repository now delegates entity loading, initialization, and live updates to a new EntityLifecycleHandler, simplifying repository construction and allowing custom lifecycle logic. A new EventSourcedEntityFactory interface replaces previous factory patterns, providing explicit support for mutable entities (via no-argument or identifier constructors) and immutable entities (via event-message constructors), with stricter validation that throws EntityMissingAfterFirstEventException if a factory returns null after the first event. Snapshotting has been reworked to support both single-request snapshots and event-stream-based triggering, exposed through a new SnapshotPolicy API that allows decisions based on event counts, sourcing time, or custom event predicates, with metrics captured in EvolutionResult.

eventsourcing/src/main/java/org/axonframework/eventsourcing · high confidence

The Spring Boot auto-configuration entry point has been updated to register a new set of auto-configuration classes, including specific converters (Avro, CBOR, Jackson2), transaction managers (JDBC, JPA), and infrastructure components (QueryShutdown, Reactor, Tracing). This change reflects the modularization of the framework, ensuring that the correct auto-configurations are loaded for the current Spring Boot version while removing legacy or deprecated configurations.

extensions/spring/spring-boot-autoconfigure/src/main/resources · high confidence

Added ArchUnit test configuration for tracing snapshot store; Added ArchUnit tests to enforce nullability conventions; Added JUnit 5 tests for JPA event store configuration and SQL error resolution; Added Quartz test resources for Spring integration; Added Spring Boot integration tests for PooledStreamingEventProcessor token stores; Added architecture tests for the snapshot package; Added compatibility tests for Spring Boot 3 and 4; Added comprehensive test coverage for the course catalog message transformation chain; Added contract tests for saga recipe implementations; Added integration test for JPA token store initialization on foreign threads; Added integration tests for JDBC saga store transaction isolation and event processing; Added integration tests for JPA event storage engine in Spring Boot; Added integration tests for Spring Boot auto-configuration components; Added integration tests for administration command commands; Added integration tests for annotation-based event-sourced entities; Added integration tests for command handling, sequencing, and event processing; Added integration tests for course command and event models; Added integration tests for entity administration with polymorphic and child entities; Added integration tests for entity creation and state mutation behaviors; Added integration tests for immutable entity administration; Added integration tests for message handler return values and timeout behavior; Added integration tests for multi-entity event filtering; Added integration tests for polymorphic sealed interface entity evolution; Added integration tests for student command handling; Added integration tests for the multi-tenancy Spring Boot demo; Added integration tests for the new event-sourcing module and sealed interface support; Added legacy saga test fixture support; Added shared test infrastructure for Spring Boot compatibility matrix; Added smoke tests for the multi-tenancy demo; Added test coverage for Axon Framework Event Sourcing components; Added test coverage for Spring Boot autoconfiguration; Added test event definitions for the student integration test suite; Added test event models for the administration testsuite; Added test fixtures for Spring Boot autoconfigure; Added test fixtures for Spring annotation configuration; Added test for course creation in the university example; Added test resources for EhCache and MySQL integration tests; Added test resources for event sourcing benchmarks; Added test service provider files for ConfigurationEnhancer and NullabilityResolver; Added test suite for ComponentDescriptor implementations; Added test suite for the new extensible configuration system; Added test support classes for administration testsuite; Added test utilities for MySQL integration and domain events; Added test utilities for event handling scheduling; Added test utility for time-based assertions; Added tests for Avro schema loading from SpecificRecordBase classes; Added tests for AxonSpringBootTest fixture injection and child entity event routing; Added tests for Dropwizard metrics auto-configuration behavior; Added tests for InMemoryEventStorageEngine and StorageEngineBackedEventStore; Added tests for JPA token store row locking behavior; Added tests for Micrometer metrics auto-configuration; Added tests for Spring Data Page Jackson deserialization; Added tests for Spring configuration and component registry behavior; Added tests for TracingSnapshotStore span creation and context threading; Added tests for annotation-based entity creation and forced entity creators; Added tests for annotation-based event criteria resolution; Added tests for course enrollment composition and remote exception handling; Added tests for course snapshot serialization in the multi-tenancy demo; Added tests for event sourcing tracing configuration and handler behavior; Added tests for event store consistency markers, tagging, and transactional behavior; Added tests for event-sourced saga recipe variants; Added tests for nullability resolution chain and entry points; Added tests for payment context isolation and command handlers; Added tests for tenant course statistics projection and store; Added tests for the conversion module; Added tests for the deadline replacement and vertical slices saga recipes; Added tests for the legacy PaymentSaga recipe; Added tests for the new event sourcing configuration modules and defaults; Added tests for the rental payment sequencing policy; Added tests for the repository-based saga recipe; Added tests for tracing event storage engine and span attributes; Added unit and integration tests for the University Demo faculty module; Added unit tests for AnnotationUtils and PriorityAnnotationComparator; Added unit tests for Avro conversion components; Added unit tests for Dropwizard metrics monitors; Added unit tests for JDBC connection wrapping and locking mechanisms; Added unit tests for Jackson 3 JSON conversion components; Added unit tests for Micrometer metrics monitors and configuration enhancer; Added unit tests for Spring messaging integration components; Added unit tests for SpringTransactionManager; Added unit tests for common utility classes and architecture conventions; Added unit tests for conversion converters; Added unit tests for event filtering and snapshotting in entity lifecycle handlers; Added unit tests for event sourcing tracing components; Added unit tests for property access strategies; Added unit tests for rental command handlers; Frozen ArchUnit violation store for common module; Integration tests for QueryBus interceptors and subscription queries; Integration tests for entity creation and nullability styles; New in-memory test infrastructure for integration tests; Standardized test logging configuration across Axon Framework modules; Test infrastructure setup for saga recipes example.

This release updates various build plugins and library dependencies across the project, including bumps to Spring Boot, Spring Framework, Hibernate, Project Reactor, and the PostgreSQL JDBC driver. These changes ensure compatibility with newer Java versions and incorporate upstream fixes and improvements from the underlying libraries.

(dependencies) · high confidence

The Maven Wrapper configuration has been updated to use version 3.3.4, which downloads and uses Apache Maven 3.9.16. This ensures consistent build behavior across environments by pinning the specific Maven distribution version.

.mvn · high confidence

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

• CAI 72 → 58 (-13.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 91 → 94 (+2.6)
• Architecture 94 → 54 (-39.7)
• Maturity 78 → 78 (+0.1)
• Readiness 71 → 72 (+1.6)
• Security 63 → 66 (+3.3)
• Domain Modelling 100 → 51 (-48.6)
• Event Sourcing 100 → 100 (+0.0)

• 1.extractClassLiteralType (cognitive 16) (migration/src/main/java/org/axonframework/migration/MigrateAggregateTestFixtureSetup.java)
• 1.visitMethodInvocation (cyclomatic 18) (migration/src/main/java/org/axonframework/migration/MigrateAxonTestFixtureFluentApi.java)
• 1.visitNewClass (cognitive 17) (migration/src/main/java/org/axonframework/migration/MigrateAggregateTestFixtureSetup.java)
• 12330.classFields (cognitive 25) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• 12330.resolveIndent (cognitive 23) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• 6947.visitClassDeclaration (cognitive 21) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• ADR not followed: 1. JacksonConverter rejects Jackson 2 tree nodes (fail loud) (decisions/0001-jackson-converter-jackson2-handling.md)
• Change coupling: ArtifactAvailableUpgrade.java ↔ DetectedVulnerabilitySeverity.java (update/src/main/java/org/axonframework/update/api/ArtifactAvailableUpgrade.java)
• Change coupling: ConcatenatingMessageStream.java ↔ OnNextMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/ConcatenatingMessageStream.java)
• Change coupling: DetectedVulnerabilitySeverity.java ↔ UpdateCheckRequest.java (update/src/main/java/org/axonframework/update/api/DetectedVulnerabilitySeverity.java)
• Change coupling: FailedMessageStream.java ↔ MappedMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/FailedMessageStream.java)
• Change coupling: FailedMessageStream.java ↔ OnNextMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/FailedMessageStream.java)
• Change coupling: FieldChildEntityFieldDefinition.java ↔ GetterEvolverChildEntityFieldDefinition.java (modelling/src/main/java/org/axonframework/modelling/entity/child/FieldChildEntityFieldDefinition.java)
• Change coupling: FieldChildEntityFieldDefinition.java ↔ GetterSetterChildEntityFieldDefinition.java (modelling/src/main/java/org/axonframework/modelling/entity/child/FieldChildEntityFieldDefinition.java)
• Change coupling: GetterEvolverChildEntityFieldDefinition.java ↔ GetterSetterChildEntityFieldDefinition.java (modelling/src/main/java/org/axonframework/modelling/entity/child/GetterEvolverChildEntityFieldDefinition.java)
• Change coupling: MappedMessageStream.java ↔ OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/MappedMessageStream.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (common/src/main/java/org/axonframework/common/configuration/DefaultComponentRegistry.java)
• Duplicated block (10 lines × 2) (examples/university-demo/src/main/java/org/axonframework/examples/demo/university/faculty/write/subscribestudent/SubscribeStudentToCourseCommandHandler.java)
• …and 95 more

• 15831.classFields (cognitive 25) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• 15831.resolveIndent (cognitive 23) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• 8892.visitClassDeclaration (cognitive 25) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• 8892.visitClassDeclaration (cyclomatic 17) (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• ADR not followed: 1. JacksonConverter rejects Jackson 2 tree nodes (fail loud) (specs/137-message-transformation/0001-jackson-converter-jackson2-handling.md)
• AssociationValueComparator.compare (cognitive 21) (stash/legacy/src/main/java/org/axonframework/modelling/saga/repository/AssociationValueMap.java)
• AssociationValueComparator.compare (cyclomatic 16) (stash/legacy/src/main/java/org/axonframework/modelling/saga/repository/AssociationValueMap.java)
• CI installs an unverified third-party binary (.github/workflows/docs.yml)
• Change coupling: DefaultProcessorModuleFactory.java ↔ MessageHandlerConfigurer.java (extensions/spring/spring/src/main/java/org/axonframework/extension/spring/config/DefaultProcessorModuleFactory.java)
• Change coupling: DelayedMessageStream.java ↔ OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/DelayedMessageStream.java)
• Change coupling: InterceptingCommandBus.java ↔ TracingCommandBus.java (messaging/src/main/java/org/axonframework/messaging/commandhandling/interception/InterceptingCommandBus.java)
• Change coupling: MergedMessageStream.java ↔ SingleValueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/MergedMessageStream.java)
• Change coupling: MessageStreamUtils.java ↔ SingleValueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/MessageStreamUtils.java)
• Change coupling: RetryingCommandBus.java ↔ TracingCommandBus.java (messaging/src/main/java/org/axonframework/messaging/commandhandling/retry/RetryingCommandBus.java)
• Change coupling: SimpleContext.java ↔ SimpleEntry.java (messaging/src/main/java/org/axonframework/messaging/core/SimpleContext.java)
• Change-coupling hub: MappedMessageStream.java → ConcatenatingMessageStream.java, EmptyMessageStream.java, FailedMessageStream.java, FluxMessageStream.java, OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/MappedMessageStream.java)
• Change-coupling hub: OnNextMessageStream.java → ConcatenatingMessageStream.java, EmptyMessageStream.java, FailedMessageStream.java, FluxMessageStream.java, OnErrorContinueMessageStream.java (messaging/src/main/java/org/axonframework/messaging/core/OnNextMessageStream.java)
• ClassTooLong: AddEventTagAnnotation (migration/src/main/java/org/axonframework/migration/AddEventTagAnnotation.java)
• ClassTooLong: Coordinator (messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/pooled/Coordinator.java)
• ClassTooLong: JdbcTokenStore (messaging/src/main/java/org/axonframework/messaging/eventhandling/processing/streaming/token/store/jdbc/JdbcTokenStore.java)
• …and 829 more

• 300 commits — 283 feature/other, 17 fixes

• legacy/src — 59 commits
• (repo) — 45 commits
• legacy-test/src — 28 commits
• docs/reference-guide — 24 commits
• docs/saga-guide — 24 commits
• extensions/spring — 21 commits
• messaging/src — 17 commits
• examples/saga-recipes — 15 commits
• axon-5/api-changes — 12 commits
• test/src — 11 commits
• eventsourcing/src — 7 commits
• integrationtests/src — 7 commits
• (root) — 3 commits
• build/parent — 3 commits
• examples/university-java-springboot-4 — 3 commits
• modelling/src — 3 commits
• stash/legacy — 3 commits
• update/src — 3 commits
• .github/workflows — 2 commits
• docs/_playbook — 2 commits

• fix: Fix NullPointerException for @CommandHandlerInterceptor on creational commands
• fix: Fix broken tests due to decoration change for the...
• fix: Fix constant JavaDoc referring to private constructor
• fix: Fix incorrect constant description
• fix: Fix race between AxonTimeLimitedTask's interrupt lambda and complete()
• fix: Merge branch 'main' into bug/coordinator-claim-extension-starvation
• fix: Merge pull request #4994 from AxonIQ/bug/enforce-null-command-result-message
• fix: Merge pull request #5014 from AxonIQ/bug/3728/prepare-commit-event-loss
• fix: Merge pull request #5027 from AxonIQ/fix/machine-user-encoding
• fix: Merge pull request #5032 from AxonIQ/bug/interceptor-support-entities
• fix: Merge pull request #5034 from AxonIQ/af5-lts-fix-parity
• fix: Merge pull request #5041 from AxonIQ/bug/spring-boot-eagerness
• fix: Merge pull request #5050 from AxonIQ/bug/coordinator-claim-extension-starvation
• fix: Merge pull request #5051 from AxonIQ/bug/compounding-processor-customizations
• fix: Merge pull request #5063 from AxonIQ/bugfix/creational-command-interceptor-npe
• fix: Revert "Rough sketch to port the SagaLifecycle"
• fix: [#3728] Remove a stray TODO and fix a misplaced Javadoc block
• change: Add deprecation warning to StartSaga annotaion
• change: Add failing test: before-interceptor invokes command handler 3 times
• change: Add missing @EventTag annotation
• …and 280 more

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

AxonIQ/AxonFramework 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.