RayTale/Vertex

This is a .NET-based actor runtime framework built on top of Orleans, designed to manage stateful actors with event sourcing and snapshotting capabilities. It provides a comprehensive toolkit for building distributed systems, featuring built-in support for distributed transactions, event streaming (via RabbitMQ, Kafka, or in-memory), and flexible storage backends. The system includes utilities for high-performance concurrency, such as distributed locking and ID generation, alongside a robust testing and benchmarking infrastructure.

Added a new console application example for the Transfer service that allows users to interact with both standard account operations and distributed transaction (DTx) workflows. The client connects to an Orleans silo using localhost clustering and provides an interactive menu to choose between normal account transfers or DTx-based transfers, demonstrating the usage of IAccount and IDTxAccount grains.

examples/Transfer.Client · high confidence

A new example application (Transfer.Server) is introduced, demonstrating an Orleans-based silo host configured for local clustering and in-memory streams. The server integrates the Vertex runtime for transaction handling and uses Linq2db with an in-memory SQLite database, providing a complete, runnable demo of the transfer functionality.

examples/Transfer.Server · high confidence

New grain interfaces are introduced for the Transfer example: IAccount and IAccountDb/IAccountFlow for standard account operations (balance, top-up, transfer, arrival, and refund), and IDTxAccount/ITransferDtxUnit/TransferRequest for distributed transaction (DTx) support, including serialization attributes on the request model.

examples/Transfer.IGrains · medium confidence

Introduced the core domain models and actors for a banking-style transfer system. Added event classes (TopupEvent, TransferEvent, TransferArrivedEvent, TransferRefundsEvent) and an AccountSnapshot with serialization attributes. Implemented the Account grain for standard transfer/top-up logic, the AccountDb grain for database synchronization, and the AccountFlow grain for event-driven flow control. Additionally, added the DTxAccount grain and TransferDtxUnit actor to support distributed transactions with commit/rollback capabilities.

examples/Transfer.Grains · high confidence

The \src/Vertex.Utils\ library introduces several new components: an \AssemblyHelper\ to load assemblies from the dependency context; a \SharedArray\ class for efficient, pooled byte buffer management; a \TaskSourcePool\ system using \ManualResetValueTaskSource\ for high-performance async state management; and a multi-producer, single-consumer channel implementation (\BufferBlockChannel\ and \ThreadChannel\) supporting batched, delayed consumption and sequential chaining.

src/Vertex.Utils · high confidence

New benchmark files were added to the Vertex.Utils.Benchmark project, introducing performance tests for MPSC channels and TaskSource implementations. Additionally, new exception classes (EventVersionException, SnapshotException, VertexEventHandlerException) and transaction abstraction interfaces (DTxCommit, IDTxActor, ITxSnapshot, etc.) were introduced to support transactional workflows and error handling.

benchmark, src/Vertex.Runtime/Exceptions, src/Vertex.Transaction.Abstractions · high confidence

Added new Orleans grain implementations for inner service operations: DIDActor for generating unique IDs, HoldLockActor for simple lock/unlock operations, LockActor for queue-based distributed locking with wait support, and WeightHoldLockActor for weight-based locking. These components provide core concurrency control and identity generation capabilities for the runtime.

src/Vertex.Runtime/InnerService · high confidence

Introduced new attributes (NoStreamAttribute, StreamAttribute, StreamSubAttribute) to mark classes for stream processing, along with a BytesBox wrapper for event data, extension methods for Orleans IGrainFactory to simplify grain retrieval, and the IStreamSubHandler/StreamSubHandler implementation to route and process incoming stream events by actor ID.

src/Stream/Vertex.Stream.Common · high confidence

Added a new Kafka stream implementation in the Vertex.Stream.Kafka module, including the IKafkaClient interface and its KafkaClient implementation that manages pooled PooledConsumer and PooledProducer instances. The change introduces a background ConsumerManager that discovers stream subscribers via reflection, manages distributed locking for consumer runners, and handles batched message consumption and error retry logic. This provides the underlying Kafka connectivity and streaming infrastructure for the application.

src/Stream/Vertex.Stream.Kafka · high confidence

Added a new Linq2db-based storage implementation for the storage module, including entity models (EventEntity, SnapshotEntity, SubSnapshotEntity), database connection factories, and storage classes (EventStorage, SnapshotStorage, EventArchive) that handle data persistence. The change introduces attribute-based configuration for table naming and sharding, along with index generation logic for multiple database providers (PostgreSQL, MySQL, SQLite, SQL Server). This provides an alternative to the existing EF Core-based storage, supporting features like event archiving, snapshot management, and transactional event storage with configurable sharding strategies.

src/Storage · high confidence

Added a new RabbitMQ-based event stream implementation in the Vertex.Stream.RabbitMQ module. This includes a connection and model pooling system (ConnectionWrapper, ModelWrapper, PooledModelPolicy) to manage RabbitMQ client resources efficiently. The module also introduces a ConsumerManager and ConsumerRunner to handle message consumption, including batch processing, retry logic, and health checks. An EventStream and EventStreamFactory are provided to publish events to RabbitMQ exchanges. The implementation is registered via DI extensions, allowing users to configure and use RabbitMQ for streaming data.

src/Stream/Vertex.Stream.RabbitMQ · high confidence

Added a new abstract base class, SnapshotHandlerBase, which provides a dynamic, high-performance mechanism for routing and invoking event handlers. This change improves the extensibility of the snapshotting system by allowing derived classes to define multiple event handling methods that are automatically discovered and optimized via IL generation.

src/Vertex.Runtime/Snapshot · high confidence

The Vertex runtime now provides an \AddVertex\ extension method to register core services—including snapshot handlers, serialization, event type containers, and channel implementations—via dependency injection, and exposes the \eventflowid\ constant for event flow identification.

src/Vertex.Runtime · high confidence

Added a new set of interfaces and data models in the Vertex.Abstractions library to support actor-based architecture and event sourcing. This includes actor interfaces (IActor, IFlowActor, IVertexActor), event handling components (IEvent, EventUnit, EventMeta, EventNameAttribute), and storage abstractions for events and snapshots (IEventStorage, ISnapshotStorage, ISubSnapshotStorage). These changes provide the foundational contracts for managing state, serializing events, and persisting snapshots within the system.

src/Vertex.Abstractions · high confidence

The framework now includes a default JSON serialization implementation (DefaultJsonSerializer) that uses System.Text.Json with camel-case naming and case-insensitive property matching. Additionally, an EventTypeContainer is added to automatically scan assemblies for types implementing IEvent, registering them by name (via EventNameAttribute or a name generator) to enable runtime type-to-name lookups.

src/Vertex.Runtime/Serialization · medium confidence

Added new actor classes (DTxActor, DTxUnitActor, InnerTxActor, ReentryActor, ReentryDTxActor) and associated event types (TxCommitEvent, TxCommitedEvent, TxFinishedEvent, TxRollbackEvent, UnitCommitEvent, UnitCommitedEvent, UnitFinishedEvent, UnitRollbackEvent) to support distributed transaction workflows. This includes a new EventBufferUnit for event serialization and a TxEventTaskBox for managing concurrent transaction tasks. The implementation also introduces configuration options (VertexDtxOptions, VertexTxOptions) and a custom exception hierarchy (TxException, TxSnapshotException) to handle transaction states and errors.

src/Vertex.Transaction · high confidence

Added the in-memory stream implementation for the Vertex framework, including the ConsumerManager and ConsumerRunner classes to handle background processing of stream events, an EventStream and EventStreamFactory to manage stream creation and routing, and supporting types like QueueInfo, ConsumerOptions, and the StreamIdActor grain. This provides a fully functional, in-memory event streaming solution that can be registered via the AddInMemoryStream extension method.

src/Stream/Vertex.Stream.InMemory · high confidence

Added new files in src/Vertex.Runtime/Actor, including ActorBase, FlowActor, ShadowActor, and VertexActor, which provide the core runtime implementation for actor state management, event handling, and snapshot recovery. The ActorBase class introduces a generic primary key mechanism and supports cancellation tokens in activation methods. New attributes (EventReentrantAttribute, FollowPolicyAttribute, VertexPolicyAttribute) are added to configure actor behavior and policy options. Extension methods in Extentions.cs handle version updates for snapshots and events, ensuring consistency during state transitions.

src/Vertex.Runtime/Actor · high confidence

Added configuration classes (ActorOptions, ArchiveOptions, FlowActorOptions, ShadowActorOptions) and the FlowInitType enum to the runtime's options layer. These classes, decorated with Orleans serialization attributes, expose settings for snapshot versioning intervals, event page sizes, and cache behaviors for various actor types, alongside an enum defining how FlowActors initialize from events.

src/Vertex.Runtime/Options · high confidence

Added tests for account actor lifecycle and event handling; Added tests for transactional account actors; Added unit tests for protocol, utility, and channeling components.

The project files for the core libraries (Vertex.Abstractions, Vertex.Runtime, Vertex.Transaction, etc.), their corresponding test projects, and the Transfer example applications have been added with a .NET 8.0 target framework. These .csproj files establish the dependency graph for the Orleans-based runtime, storage, streaming, and transaction modules, while also introducing a new benchmarking project. This change updates the build system to use .NET 8.0 and includes references to key packages such as Microsoft.Orleans.Sdk, Microsoft.Orleans.Server, and various Microsoft.Extensions.\* libraries.

(dependencies) · medium confidence

The project has been upgraded to target the .NET 8.0 runtime, as specified in \Directory.Build.props\ and \global.json\. All dependencies have been updated to their latest versions, including Microsoft.Orleans 8.2.0, Microsoft.Extensions packages at 8.0.x, and linq2db 5.4.1. Additionally, the .editorconfig file was added to configure code analysis rules, and the solution file was updated to reflect the new project structure.

(repo-wide) · high confidence

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

• CAI 48 → 54 (+5.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 55 → 50 (-5.0)
• Architecture 99 → 99 (+0.2)
• Maturity 46 → 46 (+0.1)
• Readiness 60 → 64 (+3.6)
• Security 39 → 63 (+24.2)
• Event-Driven 86 → 86 (+0.0)
• Performance 81 → 81 (+0.0)

• Bounded contexts not declared
• Duplicate method signature 'EventHandle' exists in different namespaces for similar functionality, potentially causing confusion or ambiguity.
• Duplicated block (10 lines × 2) (src/Stream/Vertex.Stream.Kafka/Consumer/ConsumerManager.cs)
• Duplicated block (10 lines × 2) (src/Vertex.Runtime/Actor/FlowActor.cs)
• Duplicated block (10 lines × 2) (src/Vertex.Transaction/Actor/DTxActor.cs)
• Duplicated block (10 lines × 3) (src/Stream/Vertex.Stream.RabbitMQ/Consumer/ConsumerManager.cs)
• Duplicated block (11 lines × 2) (src/Storage/Vertex.Storage.Linq2db/Storage/SnapshotStorage.cs)
• Duplicated block (11 lines × 2) (src/Vertex.Utils/Channels/BufferBlockChannel.cs)
• Duplicated block (12 lines × 2) (src/Storage/Vertex.Storage.Linq2db/Storage/EventStorage.cs)
• Duplicated block (12 lines × 2) (src/Vertex.Runtime/Actor/ShadowActor.cs)
• Duplicated block (12 lines × 2) (src/Vertex.Runtime/Actor/ShadowActor.cs)
• Duplicated block (12 lines × 3) (src/Vertex.Runtime/Snapshot/SnapshotHandlerBase.cs)
• Duplicated block (13 lines × 2) (src/Storage/Vertex.Storage.Linq2db/Storage/EventStorage.cs)
• Duplicated block (13 lines × 2) (src/Storage/Vertex.Storage.Linq2db/Storage/EventStorage.cs)
• Duplicated block (13 lines × 2) (src/Vertex.Utils/Channels/BufferBlockChannel.cs)
• Duplicated block (14 lines × 2) (src/Stream/Vertex.Stream.Kafka/Consumer/ConsumerManager.cs)
• Duplicated block (14 lines × 3) (src/Stream/Vertex.Stream.RabbitMQ/Consumer/ConsumerRunner.cs)
• Duplicated block (14 lines × 3) (src/Stream/Vertex.Stream.RabbitMQ/EventStreamFactory.cs)
• Duplicated block (15 lines × 3) (src/Stream/Vertex.Stream.RabbitMQ/Consumer/ConsumerManager.cs)
• Duplicated block (16 lines × 2) (src/Vertex.Utils/Channels/BufferBlockChannel.cs)
• …and 33 more

• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• …and 83 more

• Unchanged — 2 containers · 0 contexts · 0 edges

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

RayTale/Vertex 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.