Elders/Cronus

Cronus is an event-sourcing framework that manages the lifecycle of aggregate roots, projections, and background jobs within a multi-tenant environment. It provides infrastructure for automatic updates, message processing, and data migration, while offering tools for integrity validation, fault handling, and distributed locking. The system supports cluster-based job execution, projection versioning, and comprehensive telemetry, all built on a modern .NET foundation.

16 changes.

This period focused on modernizing the framework's core architecture by introducing a robust event sourcing model with structured message headers, concurrency control, and integrity validation. The team refactored the message processing pipeline to support scoped workflows and added comprehensive test coverage for the new event store and middleware systems. Additionally, the project upgraded to .NET 8/9 and standardized build configurations to improve resilience and observability.

19 changes.

This period focused on introducing comprehensive projection versioning and lifecycle management, allowing for the safe creation, rebuilding, and activation of new projection states. Concurrently, the framework modernized its core infrastructure by implementing automatic service discovery, async host startup ranking, and a new workflow execution model with structured diagnostics.

14 changes.

This period focused on expanding the framework's capabilities for cluster-based job execution, event store index management, and projection rebuilding. It introduced new abstractions for job runners, heartbeat monitoring, and public event replay, while also adding comprehensive test coverage and performance benchmarks.

4 changes.

The codebase introduced a new AutoUpdater aggregate and saga-based strategy to track and execute multiple concurrent auto-updates independently of the core version. Additionally, a DangerZone feature was added to allow safe tenant data wiping with protection for critical tenants, accompanied by corresponding test coverage.

A new heartbeat mechanism has been introduced to monitor service health. The \CronusHeartbeat\ class periodically publishes \HeartbeatSignal\ messages containing the bounded context, tenant list, machine name, and environment configuration. The interval is configurable via \HeartbeatOptions\ (defaulting to 5 seconds) and supports hot-reloading of options at runtime. A \BackgroundService\ (\CronusHeartbeatService\) manages the lifecycle of the heartbeat loop.

src/Elders.Cronus/Hosting/Heartbeat · high confidence

The framework now exposes three new system signals—RebuildProjectionStarted, RebuildProjectionProgress, and RebuildProjectionFinished—to track the lifecycle of a projection rebuild. Each signal includes a Timestamp for when the event occurred, and the progress signal additionally exposes ProcessedCount and TotalCount to track rebuild status. These signals implement ISystemSignal, allowing consumers to monitor and react to rebuild state changes.

src/Elders.Cronus/Projections/Signals · high confidence

A new exception class, UnableToResolveTenantException, has been introduced in the Elders.Cronus.AspNetCore.Exceptions namespace. This change provides a specific error type to handle scenarios where tenant resolution fails, improving error handling and debugging for multi-tenant applications.

src/Elders.Cronus/Exception · high confidence

Introduced a new capability to replay public events from the event store. This includes the PublicEventsPlayer to trigger the process, a ReplayPublicEventsRequested signal to initiate it, and a ReplayPublicEvents\_Job that handles the actual replay logic, including pagination and parallelism options. This allows users to re-process public events, which is useful for rebuilding projections or syncing data across clusters.

src/Elders.Cronus/EventStore/Players · high confidence

Users can now wipe data for a specific tenant through the new DangerZone functionality. The system includes a configurable list of protected tenants that cannot be wiped, ensuring critical data is preserved. The implementation adds an IDangerZone interface for defining wipe operations, a DangerZoneExecutor that iterates through registered zones to perform the wipe, and a CronusDangerZoneOptions class to manage configuration, including the list of protected tenants.

src/Elders.Cronus/DangerZone · high confidence

The fault handling module now supports asynchronous retry workflows, allowing operations to be retried without blocking threads. This includes a new \InMemoryRetryWorkflow\ that wraps existing workflows with retry logic, and a \RetryPolicy\ class that manages transient error detection and execution of actions. The update introduces several retry strategies—\FixedInterval\, \Incremental\, and \ExponentialBackoff\—which define how delays are calculated between attempts. Additionally, a \RetryLimitExceededException\ is provided to allow user code to explicitly stop the retry loop. The implementation also integrates \Microsoft.Extensions.Logging\ for structured logging of retry attempts and failures, replacing the previous custom logging approach.

src/Elders.Cronus/FaultHandling · high confidence

New system commands are introduced to control the state of projection versions, allowing users to register, create, fix, finalize, pause, cancel, or timeout specific versions. These commands provide explicit control over the projection versioning process, enabling operations such as rebuilding or halting versioned projections.

src/Elders.Cronus/Projections/Versioning/Commands · high confidence

The library introduces several new components to support internal operations and logging. A static CronusLogger class is added to manage logging via Microsoft.Extensions.Logging, including helper methods for creating loggers and managing startup logging. A Result\<T\> struct is introduced to handle success/failure states with error tracking. Additionally, utility classes such as FastActivator for optimized object instantiation, RetryableOperation for handling transient failures with exponential or linear retry policies, and SerializableException for cross-boundary exception handling are added. These changes enhance the framework's resilience and observability.

src/Elders.Cronus/Userfull · high confidence

Introduces the \ProjectionBuilder\ saga to manage the lifecycle of projection rebuilds, handling timeouts, cancellations, and job execution status. Adds the \ProjectionVersionsHandler\ to maintain a complete history of all projection versions, including canceled and timed-out requests. This enables the system to track and manage the full history of projection versions per tenant.

src/Elders.Cronus/Projections/Versioning/Handlers · high confidence

Added new interfaces and classes to support integrity validation, including IIntegrityPolicy, IResolver, IValidator, IValidatorResult, IntegrityResult, IntegrityRule, and ValidatorResult. These provide the foundation for validating aggregate roots upon loading, with resolvers applying in-memory fixes without writing to the database.

src/Elders.Cronus/IntegrityValidation · medium confidence

Added new system events to track the state of projection version requests, including \NewProjectionVersionIsNowLive\, \ProjectionVersionRequested\, \ProjectionVersionRequestCanceled\, \ProjectionVersionRequestTimedout\, and \ProjectionVersionRequestPaused\. These events capture the full lifecycle of a version request, allowing the system to monitor, pause, cancel, or confirm the activation of new projection versions.

src/Elders.Cronus/Projections/Versioning/Events · high confidence

The framework now supports a configurable BoundedContext, defined via the \Cronus:BoundedContext\ setting, which is exposed through the new \BoundedContext\ class and \BoundedContextProvider\. This context name is automatically attached to every published message via the \MessageHeader.BoundedContext\ header. Additionally, the \CronusMessage\ class has been introduced to standardize message handling, carrying an \Id\, \Payload\, and a \Headers\ dictionary that includes metadata such as \AggregateRootId\, \Tenant\, and \PublishTimestamp\. The \MessageHeader\ class defines the constants for these headers, enabling consistent access to message metadata across the system.

src/Elders.Cronus · high confidence

The \src/Elders.Cronus/Cluster\ area now includes a new \Job\ subdirectory containing the core abstractions for cluster-based job execution. This includes the \CronusJob\<TData\>\ base class, \ICronusJob\ and \ICronusJobRunner\ interfaces, and supporting types like \JobExecutionStatus\ and \IJobData\. The diff also adds an \InMemory\ implementation for testing or lightweight scenarios, along with job name building and discovery logic, enabling the framework to run and manage jobs within a cluster environment.

src/Elders.Cronus/Cluster · high confidence

The workflow system has been refactored to support a new execution model via the \Execution\ and \ExecutionChain\ classes, enabling a chain of \Workflow\ steps. This change introduces \DiagnosticsWorkflow\ for structured logging and activity-based telemetry (using \DiagnosticListener\ and \ActivitySource\), and adds \ActionWorkflow\ to allow inline actions within the execution chain. Additionally, an \ExceptionEaterWorkflow\ is introduced to catch and log exceptions without failing the entire workflow.

src/Elders.Cronus/Workflow · high confidence

The Cronus host now implements the standard async StartAsync/StopAsync pattern, allowing for non-blocking initialization and shutdown of services. The framework introduces a startup ranking system via the CronusStartupAttribute, which orders the execution of different startup types (e.g., Environment, ExternalResource, Aggregates, Projections) to ensure correct initialization order. Additionally, the host options now support enabling or disabling specific service categories (such as application services, sagas, projections, and migrations) at runtime, allowing for more granular control over the host's behavior.

src/Elders.Cronus/Hosting · high confidence

The framework now includes an AutoUpdater aggregate to track and manage auto-updates, allowing multiple updates to be queued and executed sequentially. Additionally, new managers handle the lifecycle of projection versions, supporting operations like replaying events, rebuilding projections, and canceling or timing out version requests. This enables more robust control over projection state and automatic recovery mechanisms.

Elders.Cronus · high confidence

The framework now automatically scans assemblies to discover and register services such as commands, events, projections, and handlers. This replaces manual configuration with a new \DiscoveryScanner\ and \DiscoveryBase\ architecture, allowing the application to bootstrap itself by finding types like \ICommand\, \IEvent\, and \IProjection\ without explicit registration code.

src/Elders.Cronus/Discoveries · high confidence

The AtomicAction module now exposes new interfaces for managing concurrency and distributed locking: ILock defines methods for checking and acquiring locks on resources, while IAggregateRootAtomicAction provides an async ExecuteAsync method for performing atomic operations on aggregate roots. To ensure the system remains functional without external dependencies, a MissingAggregateRootAtomicAction implementation is provided that throws a NotImplementedException with a clear message guiding users to install the appropriate package (e.g., Cronus.AtomicAction.Redis) or disable the feature. Additionally, a new exception type, AggregateStateFirstLevelConcurrencyException, is introduced to handle specific concurrency failure scenarios.

src/Elders.Cronus/AtomicAction · high confidence

Adds a new set of components for managing and rebuilding event store indices, including the \EventStoreIndexManager\ aggregate root, its associated state and ID classes, and the \EventStoreIndexManagerAppService\ to handle index registration, rebuilding, and finalization. The change introduces new domain events (\EventStoreIndexRequested\, \EventStoreIndexIsNowPresent\) and index-related interfaces (\IEventStoreIndex\, \IIndexStore\, \IIndexStatusStore\) to support the new indexing workflow. Additionally, a \RebuildIndex\_MessageCounter\_Job\ is added to handle the background task of resetting and rebuilding message counters, ensuring the system can recover and maintain index consistency.

src/Elders.Cronus/EventStore/Index · high confidence

Added EventStoreIndexBuilder and EventStoreIndexStatus handlers to manage the building and status of the event store index. The builder handles index rebuild requests with configurable parallelism and timeout logic, while the status handler tracks whether the index is building or present.

src/Elders.Cronus/EventStore/Index/Handlers · high confidence

The projection subsystem is restructured with new interfaces including \IProjectionStore\, \IInitializableProjectionStore\, \IProjectionWriter\, and \IProjectionReader\. A new \CronusProjectionBootstrapper\ handles the initialization of projections per tenant, while \ProjectionRepository\ and \ProjectionRepositoryWithFallback\ manage the actual data operations. This change also introduces \ProjectionVersion\ and \ProjectionStatus\ to track the state of projections, enabling better management of projection lifecycles and fallback mechanisms.

src/Elders.Cronus/Projections · high confidence

Adds the core components for managing projection versions, including a versioning policy interface, a hasher for computing projection hashes, and an application service to handle commands for registering, fixing, finalizing, and canceling projection versions. The update also introduces a timebox mechanism to control the lifespan of version requests and provides an in-memory store for tracking projection versions.

src/Elders.Cronus/Projections/Versioning · high confidence

The EventToAggregateRootId index is now implemented with a new \EventLookupInByteArray\ class that uses a dictionary of UTF-8 encoded contract IDs for faster lookups. The \EventToAggregateRootId\ indexer now handles both standard and public events, ensuring public events are only indexed if they belong to the current bounded context. A new \RebuildIndex\_EventToAggregateRootId\_Job\ has been added to rebuild this index, supporting a configurable \MaxDegreeOfParallelism\ for parallel processing and logging progress metrics like average speed and processed count.

src/Elders.Cronus/EventStore/Index/EventToAggregateRootId · high confidence

Added three new system commands to manage the event store index lifecycle: \RegisterIndex\ to register an index, \RebuildIndexCommand\ to trigger a rebuild (now supporting an optional \MaxDegreeOfParallelism\ parameter), and \FinalizeEventStoreIndexRequest\ to signal that the index is present.

src/Elders.Cronus/EventStore/Index/Commands · high confidence

The system introduces a new migration framework that enables migrating and validating event store data, as well as transforming aggregate commits. This includes new classes like CopyEventStore and ValidateEventStore for handling event store migrations, and AggregateCommitMigrationWorkflow for processing aggregate commits. The framework supports custom logic injection via IMigrationCustomLogic and provides interfaces (ICronusMigrator, IMigration) to define and apply migrations. This change allows for more flexible and robust data migration and validation processes within the application.

src/Elders.Cronus/Migrations · high confidence

Added new \RebuildProjectionSequentially\_Job\ and \RebuildProjection\_Job\ classes to handle projection rebuilding workflows, along with their corresponding data models (\RebuildProjectionSequentially\_JobData\, \RebuildProjection\_JobData\) and factories (\RebuildProjectionSequentially\_JobFactory\, \RebuildProjection\_JobFactory\). Supporting infrastructure includes \ProgressTracker\ for monitoring rebuild progress and \ProjectionVersionHelper\ for version management. These components enable the system to rebuild projections sequentially or in parallel, with progress tracking and cancellation support.

src/Elders.Cronus/Projections/Rebuilding · high confidence

The system now tracks auto-updates using a new \AutoUpdater\ aggregate root, which supports multiple concurrent updates and is no longer tied to the Cronus version. This change adds the \AutoUpdaterApplicationService\ and associated commands (\RequestAutoUpdate\, \BulkRequestAutoUpdate\, \FinishAutoUpdate\, \FailAutoUpdate\) and events (\AutoUpdateRequested\, \AutoUpdateTriggered\, \AutoUpdateFinished\, \AutoUpdateFailed\) to manage the lifecycle of individual updates.

src/Elders.Cronus/EventStore/AutoUpdater · high confidence

The system now uses a new \AutoUpdateSaga\ and \AutoUpdaterStrategy\ to manage auto-updates. This change introduces a saga-based approach where an \AutoUpdateSaga\ handles \AutoUpdateTriggered\ events and delegates execution to registered \IAutoUpdate\ strategies. This allows for multiple auto-updates to be tracked and executed independently of the Cronus version, providing a more flexible and decoupled way to handle automatic updates across tenants.

src/Elders.Cronus/AutoUpdates · medium confidence

The EventStore integrity checks now enforce three new validation rules for event streams: duplicate revisions, missing revisions, and unordered revisions. The system will now detect and report streams with duplicate or missing revision numbers, and automatically resolve streams with unordered revisions by sorting them by revision number.

src/Elders.Cronus/EventStore/Integrity · medium confidence

The message processing layer has been refactored to use a new workflow-based architecture. Key changes include the introduction of \CronusContext\ and \ICronusContextAccessor\ to manage per-tenant state and service providers within a DI scope. Message handling is now orchestrated through \MessageHandleWorkflow\ and \ScopedMessageWorkflow\, ensuring each message is processed within its own service scope. Additionally, new classes like \AggregateCommitPublisher\ and \AggregateRepositoryAndEventPublisher\ handle the publishing of aggregate commits and events, while \DefaultSubscriberWorkflow\ and \DefaultSubscriberWorkflow\<T\>\ define the execution chain for standard and generic subscribers.

src/Elders.Cronus/MessageProcessing · high confidence

The multitenancy subsystem has been refactored to use the .NET Options pattern for configuration, introducing TenantsOptions and TenantsOptionsProvider to manage the list of valid tenants. A new IHaveTenant interface allows classes to opt-in to automatic tenant value injection. The tenant resolution logic has been reworked with a new TenantResolver class and ITenantResolver\< T \> interfaces, enabling more flexible tenant extraction from various sources like messages, aggregate IDs, and blobs. The MultitenancyDiscovery class now automatically registers all ITenantResolver\< T \> implementations found in the application assemblies.

src/Elders.Cronus/Multitenancy · high confidence

The event store implementation has been completely reworked, introducing new domain models such as \AggregateCommit\ and \AggregateEventRaw\ to represent commit and raw event data. The \AggregateRepository\ now utilizes an \IAggregateCommitInterceptor\ pipeline, allowing custom logic to be injected for modifying or validating aggregate commits before they are persisted. Additionally, the \EventStore\ interface now supports loading raw events with paging options and includes a \DeleteAsync\ method, while the \Player\ interface gains async replay capabilities.

src/Elders.Cronus/EventStore · high confidence

The project now uses a shared Directory.Build.props file to centralize common MSBuild properties, including authoring metadata, symbol packaging settings, and a reference to Microsoft.SourceLink.GitHub for source link support. The solution file has been updated to include the Elders.Cronus.Performance project alongside the main library and its tests, ensuring consistent build configurations across all projects.

src · high confidence

The repository's documentation and configuration have been updated. The README.md has been rewritten to include status badges, a description of the framework, links to external documentation and Discord, and a call for contributors. Additionally, new configuration files have been added: .editorconfig for code formatting, .gitattributes for text normalization, .gitbook.yaml for documentation structure, .gitignore for build artifacts, and release.config.js for automated semantic versioning and NuGet packaging via Azure Pipelines.

(repo-wide) · high confidence

Added in-memory test doubles for the event store; Added in-memory test suite for the event store; Added performance benchmarks for logging and Urn initialization; Added performance test placeholder; Added sanity test suite for event contracts; Added test infrastructure for tenant configuration; Added test migrations for event store transformations; Added test model classes for the TestModel namespace; Added test model for migration middleware tests; Added tests for CronusStartupScanner ordering; Added tests for EventStream and SingletonPerTenantContainer; Added tests for InMemoryLock behavior; Added tests for Publisher message logging behavior; Added tests for event stream integrity validation; Added tests for middleware execution and control flow; Added tests for migration scenarios; Added tests for projection versioning and hashing; Added unit tests for service discovery and registration.

The main library and test projects now target .NET 8 and .NET 9, enabling support for the latest .NET runtime versions. The core library has been updated to use Cronus.DomainModeling version 11.0.1 and Microsoft.Extensions packages version 9.0.1, ensuring compatibility with the new .NET versions and providing access to the latest features and improvements in the Microsoft.Extensions ecosystem.

(dependencies) · high confidence

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

• CAI 55 → 49 (-6.2)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 53 → 37 (-16.7)
• Architecture 82 → 83 (+0.1)
• Maturity 49 → 49 (-0.3)
• Readiness 52 → 57 (+4.6)
• Security 91 → 89 (-1.5)
• Performance 74 → 73 (-0.3)

• Bounded contexts not declared
• Change coupling: FixProjectionVersion.cs ↔ RegisterProjection.cs (src/Elders.Cronus/Projections/Versioning/Commands/FixProjectionVersion.cs)
• Change coupling: NewProjectionVersionIsNowLive.cs ↔ ProjectionBuilder.cs (src/Elders.Cronus/Projections/Versioning/Events/NewProjectionVersionIsNowLive.cs)
• Change coupling: NewProjectionVersionIsNowLive.cs ↔ ProjectionVersionRequestTimedout.cs (src/Elders.Cronus/Projections/Versioning/Events/NewProjectionVersionIsNowLive.cs)
• Change coupling: NewProjectionVersionIsNowLive.cs ↔ ProjectionVersionRequested.cs (src/Elders.Cronus/Projections/Versioning/Events/NewProjectionVersionIsNowLive.cs)
• Change coupling: ProjectionBuilder.cs ↔ ProjectionVersionManagerState.cs (src/Elders.Cronus/Projections/Versioning/Handlers/ProjectionBuilder.cs)
• Change coupling: ProjectionVersionRequestTimedout.cs ↔ ProjectionVersionRequested.cs (src/Elders.Cronus/Projections/Versioning/Events/ProjectionVersionRequestTimedout.cs)
• Change coupling: RegisterProjection.cs ↔ NewProjectionVersionIsNowLive.cs (src/Elders.Cronus/Projections/Versioning/Commands/RegisterProjection.cs)
• Change coupling: RegisterProjection.cs ↔ ProjectionBuilder.cs (src/Elders.Cronus/Projections/Versioning/Commands/RegisterProjection.cs)
• Change coupling: RegisterProjection.cs ↔ ProjectionVersionRequestTimedout.cs (src/Elders.Cronus/Projections/Versioning/Commands/RegisterProjection.cs)
• Change coupling: RegisterProjection.cs ↔ ProjectionVersionRequested.cs (src/Elders.Cronus/Projections/Versioning/Commands/RegisterProjection.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemory/InMemoryIndexStore.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemory/InMemoryPublisher.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemory/InMemoryPublisher.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemory/InMemoryPublisher.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemory/InMemoryPublisher.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemoryEventStoreSuite/When_loading_aggregate_root_with_entity_from_event_store.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemoryEventStoreSuite/When_loading_aggregate_root_with_entity_from_event_store.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemoryEventStoreSuite/When_loading_aggregate_root_with_entity_from_event_store.cs)
• CommentedOutCode (src/Elders.Cronus.Tests/InMemoryEventStoreSuite/When_loading_events_for_replay.cs)
• …and 30 more

• Documentation: contradicts the code (docs/cronus-framework/configuration.md)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (11 lines × 2) (src/Elders.Cronus/Projections/Versioning/Events/ProjectionVersionRequestTimedout.cs)
• Duplicated block (11 lines × 3) (src/Elders.Cronus/Projections/Versioning/Commands/FixProjectionVersion.cs)
• Duplicated block (12 lines × 2) (src/Elders.Cronus/Projections/Rebuilding/RebuildProjectionSequentially_Job.cs)
• Duplicated block (12 lines × 2) (src/Elders.Cronus/PublisherBase.cs)
• Duplicated block (12 lines × 2) (src/Elders.Cronus/Userfull/LateBoundMethod.cs)
• Duplicated block (12–13 lines × 2) (src/Elders.Cronus/Discoveries/ProjectionsDiscovery.cs)
• Duplicated block (13 lines × 2) (src/Elders.Cronus/EventStore/Index/EventStoreIndexManagerAppService.cs)
• Duplicated block (13 lines × 2) (src/Elders.Cronus/Hosting/CronusOptionsProviderBase.cs)
• Duplicated block (13 lines × 2) (src/Elders.Cronus/Projections/ProjectionRepository.cs)
• Duplicated block (14 lines × 2) (src/Elders.Cronus/Projections/Rebuilding/RebuildProjectionSequentially_Job.cs)
• Duplicated block (14 lines × 2) (src/Elders.Cronus/Projections/Rebuilding/RebuildProjectionSequentially_Job.cs)
• Duplicated block (17 lines × 4) (src/Elders.Cronus/EventStore/AutoUpdater/Events/AutoUpdateFailed.cs)
• Duplicated block (18 lines × 2) (src/Elders.Cronus/Projections/ProjectionRepository.cs)
• Duplicated block (21 lines × 2) (src/Elders.Cronus/PublisherBase.cs)
• Duplicated block (6 lines × 2) (src/Elders.Cronus/Discoveries/ProjectionsDiscovery.cs)
• Duplicated block (6 lines × 2) (src/Elders.Cronus/MessageProcessing/ApplicationServiceSubscriberWorkflow.cs)
• Duplicated block (7 lines × 2) (src/Elders.Cronus/Projections/Rebuilding/RebuildProjectionSequentially_JobData.cs)
• Duplicated block (8 lines × 2) (src/Elders.Cronus/EventStore/Index/RebuildIndex_MessageCounter_Job.cs)
• …and 329 more

• Unchanged — 0 containers · 1 contexts · 0 edges

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

Elders/Cronus 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.