dotnet/orleans

This system is Microsoft Orleans, a distributed virtual actor framework for .NET that manages grain lifecycle, clustering, and state persistence. It provides a comprehensive ecosystem of providers for clustering, storage, reminders, and streaming, supporting backends such as Azure Cosmos DB, AWS DynamoDB, ADO.NET relational databases, and Google Firestore. The codebase also includes extensive sample applications and playgrounds that demonstrate core features like event sourcing, real-time streaming, and chaos engineering resilience.

55 changes.

The project overhauled its build infrastructure and migrated all Azure and AWS storage providers to modern SDKs and Microsoft.Extensions.Hosting configuration patterns. This period also introduced new clustering, persistence, and streaming backends for Consul, DynamoDB, and ADO.NET, while establishing core abstractions for transactions and event sourcing.

56 changes.

This period focused on expanding Orleans' cloud-native capabilities by introducing native support for Kubernetes hosting, Redis clustering, and Azure Table Storage for grain directories and reminders. The serialization engine was significantly enhanced with new abstractions, F\# support, and multiple JSON codecs, while the code generator was refactored to improve build performance and enable hot reload compatibility. Additionally, the project introduced a new BroadcastChannel pub/sub system and expanded its sample library to demonstrate modern .NET integration patterns.

51 changes.

This period focused on significantly expanding Orleans' storage and streaming capabilities by introducing native providers for Azure Cosmos DB, Cassandra, ADO.NET, and NATS JetStream. It also established a new durable journaling subsystem for state management and introduced a dedicated DurableJobs subsystem for scheduled tasks. Concurrently, the Orleans Dashboard was modernized with a React frontend and OpenTelemetry integration.

24 changes.

This period focused on expanding Orleans' cloud ecosystem by introducing comprehensive support for Google Cloud Firestore and AWS services, including Kinesis, DynamoDB, and S3 Express. Concurrently, the team established robust validation frameworks by releasing dedicated test kits for grain storage, reminders, and clustering membership providers to ensure third-party integration reliability.

Orleans applications can now store reminders in ADO.NET-compatible databases (SQL Server, MySQL, PostgreSQL, Oracle) instead of relying solely on in-memory storage. This change introduces the \Microsoft.Orleans.Reminders.AdoNet\ package, which provides the \UseAdoNetReminderService\ extension method for configuring the reminder table, invariant, and connection string. It includes database-specific SQL scripts for schema creation and query storage, enabling reminders to persist across silo restarts and grain deactivations.

src/AdoNet/Orleans.Reminders.AdoNet · high confidence

The ADO.NET grain storage provider now allows users to configure a custom grain storage serializer via the \SerializerKey\ configuration option. This change enables the provider to use alternative serialization strategies instead of the default, giving users control over how grain state is serialized before being persisted to the database.

src/AdoNet/Orleans.Persistence.AdoNet · high confidence

The ADO.NET reminder table implementation has been updated to accept a DbDataSource in addition to a connection string, allowing users to leverage connection pooling and management provided by the data source. Configuration validation ensures that exactly one of ConnectionString or DataSource is provided, and the service now uses the cluster's ServiceId to scope reminder operations.

src/AdoNet/Orleans.Reminders.AdoNet/ReminderService · high confidence

The ADO.NET grain storage provider now allows you to customize how grain keys are hashed for database indexing. This change introduces a new \IHasher\ interface and an \IStorageHasherPicker\ API, enabling you to provide your own hashing logic or select from built-in implementations like the default Orleans hash or a Jenkins-based hasher compatible with Orleans v3. This is particularly useful for migration scenarios or to optimize database performance by reducing hash collisions for specific grain key patterns.

src/AdoNet/Orleans.Persistence.AdoNet/Storage · high confidence

A new SQL script (Sqlite-Main.sql) has been added to the shared ADO.NET persistence scripts, enabling Orleans to use SQLite as a storage backend. This script defines the required OrleansQuery table structure compatible with SQLite, allowing users to persist Orleans state using this lightweight database engine alongside the existing support for MySQL, Oracle, PostgreSQL, and SQL Server.

src/AdoNet/Shared · high confidence

This change introduces the AWS Kinesis streaming provider for Orleans, enabling applications to use Amazon Kinesis as a persistent stream provider. The update adds configuration options for Kinesis streams (including region, stream name, and credentials) and integrates a DynamoDB-based checkpointer to manage stream offsets reliably. Users can now register the provider via \AddKinesisStreams\ on both client and silo builders, configuring it with specific Kinesis settings and optionally customizing the DynamoDB checkpointer behavior.

src/api/AWS/Orleans.Streaming.Kinesis · high confidence

A new playground example has been added to demonstrate Orleans' activation shedding feature. The sample configures the grain collection system to activate shedding when memory usage exceeds 80%, targeting a reduction to 50%. It includes a hosted service that rapidly creates grains to trigger this behavior, monitors environment statistics, and prints marginal memory usage per grain to help visualize the impact of shedding.

playground/ActivationSheddingToy · high confidence

Orleans applications can now use Amazon Kinesis Data Streams as a backend for persistent streaming. This change introduces the \Microsoft.Orleans.Streaming.Kinesis\ package, providing silo and client builder extensions (\AddKinesisStreams\) to configure the provider. It supports two checkpoint persistence strategies: the default grain-based checkpointer (using Orleans grain storage like \PubSubStore\) and a dedicated DynamoDB checkpointer (\UseDynamoDBCheckpointer\) for durable, external state management. The implementation handles Kinesis shard topology monitoring, sequence token management, and AWS credential configuration.

src/AWS/Orleans.Streaming.Kinesis · high confidence

Introduces a new persistence provider for Orleans reminders backed by Azure Cosmos DB. Users can now configure this storage backend via the \UseCosmosReminderService\ extension method, which registers the \CosmosReminderTable\ implementation and configures resilience policies to automatically retry transient read timeouts. The provider handles reminder storage using a dedicated container (defaulting to \OrleansReminders\) and includes logic to correctly drain feed iterators across pages, ensuring reminders are not missed during queries.

src/Azure/Orleans.Reminders.Cosmos · high confidence

The Azure Table Storage provider for Orleans transactions is now registered using the standard Microsoft.Extensions.Hosting APIs. Users can configure the provider via new extension methods on ISiloBuilder (AddAzureTableTransactionalStateStorage) and the underlying service collection, which register the necessary transactional state storage factories and lifecycle participants.

src/Azure/Orleans.Transactions.AzureStorage/Hosting · high confidence

The samples/BankAccount directory now includes a complete example of implementing ACID transactions in Orleans. It features an AccountGrain that manages balances using transactional state and prevents overdrawing, and an AtmGrain that coordinates transfers between accounts. The sample includes a console-based client and server setup, illustrating how to use the Orleans transaction API for consistent distributed operations.

samples/BankAccount · high confidence

The Chirper sample application is introduced, demonstrating a simple social network pub/sub system built on Orleans. The solution includes a server hosting Orleans grains with in-memory persistence and a console-based client for user interaction. Key Orleans features showcased include reentrant grains for concurrent message handling, grain observers for real-time push notifications to clients, and grain persistence for storing user state such as followers and message history.

samples/Chirper · high confidence

A new sample demonstrates how to integrate Orleans streaming with external, non-Orleans publishers using a custom data adapter. The sample includes a \CustomDataAdapter\ that extends \EventHubDataAdapter\ to interpret Azure Event Hubs messages, a \ConsumerGrain\ that implicitly subscribes to streams within a specific namespace, and a \NonOrleansClient\ that publishes events directly to Event Hubs. This allows users to see how Orleans can consume streams from external systems by mapping external message formats to Orleans stream identities.

samples/Streaming/CustomDataAdapter · high confidence

Users can now persist Orleans reminders using Amazon DynamoDB. This change introduces the \Microsoft.Orleans.Reminders.DynamoDB\ package, which provides \UseDynamoDBReminderService\ extension methods for both \ISiloBuilder\ and \IServiceCollection\. The provider supports configuration via options (such as AWS region, table name, and capacity units) or via \IConfiguration\ sections, allowing reminders to survive silo restarts and grain deactivation.

src/AWS/Orleans.Reminders.DynamoDB · high confidence

A new EventDataGeneratorStreamProvider has been added to the Orleans.Streaming.EventHubs package to support local testing without requiring a connection to Azure Event Hubs. This provider generates simulated events locally, allowing developers to test streaming functionality in isolation. The implementation includes configuration options for partition counts, a no-op checkpointer since generated events do not persist, and interfaces for controlling data generation per stream.

src/Azure/Orleans.Streaming.EventHubs/Providers/EventDataGeneratorStreamProvider · high confidence

A new sample application demonstrating how to use F\# to write Orleans grains has been added. The sample consists of a C\# interface project, an F\# grain implementation project, and a C\# host application, illustrating how the Orleans code generator can analyze F\# assemblies to emit C\# code for consumption by the host.

samples/FSharpHelloWorld · high confidence

Introduces a new grain directory implementation backed by Google Cloud Firestore, allowing Orleans silos to store and retrieve grain activation locations using Firestore documents. The change adds the \FirestoreGrainDirectory\ class which implements the \IGrainDirectory\ interface to handle lookups, registrations, and unregistrations, along with extension methods (\UseFirestoreGrainDirectoryAsDefault\ and \AddFirestoreGrainDirectory\) to configure the provider via dependency injection and silo builder options.

src/Google/Orleans.GrainDirectory.Firestore · high confidence

This change introduces new Google Cloud Firestore integration providers for Orleans, enabling developers to use Firestore as a backend for both silo clustering (membership and gateway discovery) and grain state persistence. The implementation includes hosting extensions to register the clustering and storage services, entity models for mapping silo instances and grain states to Firestore documents, and a shared data manager for handling Firestore operations with support for optimistic concurrency via ETags and emulator-based testing.

src/Google/Orleans.Clustering.Firestore · high confidence

Users can now store Orleans reminders in Google Cloud Firestore. This change introduces the \FirestoreReminderTable\ implementation of \IReminderTable\ and the \FirestoreReminderServiceExtensions\ registration methods (\UseFirestoreReminderService\), allowing silos to configure and use Firestore as the backing store for reminder persistence.

src/Google/Orleans.Reminders.Firestore · high confidence

This change introduces new API surface files for integrating Google Cloud Firestore into Orleans. It adds hosting extensions to configure Firestore for clustering (\UseFirestoreClustering\), grain directory operations (\AddFirestoreGrainDirectory\, \UseFirestoreGrainDirectoryAsDefault\), grain state persistence (\AddFirestoreGrainStorage\, \AddFirestoreGrainStorageAsDefault\), and reminder services (\UseFirestoreReminderService\). It also defines the corresponding configuration options classes (\FirestoreOptions\, \FirestoreStateStorageOptions\) and the \FirestoreGrainDirectory\ implementation interface, enabling users to replace default storage and clustering mechanisms with Firestore-backed providers.

src/api/Google · high confidence

A new 'Journaled Todo List' sample has been added to the samples directory, demonstrating durable, journaled grain state using Orleans log-consistency providers. The application is hosted via .NET Aspire, configuring Azure Table Storage for clustering and Azure Blob Storage for grain state. It features a Blazor Web frontend that allows users to create todo lists, add items, and view the complete event history of changes, showcasing how Orleans grains can maintain state through event sourcing.

samples/ShoppingCart · high confidence

Introduces a new \Microsoft.Orleans.Serialization.MessagePack\ package that allows developers to use the MessagePack binary format for serializing and deserializing Orleans grain data. This includes the \MessagePackCodec\ implementation, configuration options via \MessagePackCodecOptions\, and hosting extensions (\AddMessagePackSerializer\) to register the codec with the Orleans service provider, enabling high-performance serialization as an alternative to the default serializer.

src/Orleans.Serialization.MessagePack · high confidence

Microsoft Orleans now includes a new serialization codec that uses Newtonsoft.Json, allowing developers to leverage its comprehensive JSON features for serializing and deserializing grain data. This change introduces the \Microsoft.Orleans.Serialization.NewtonsoftJson\ package, which provides the \NewtonsoftJsonCodec\ implementation and hosting extensions (\AddNewtonsoftJsonSerializer\) to register the serializer with type filtering and custom \JsonSerializerSettings\ configuration.

src/Orleans.Serialization.NewtonsoftJson · high confidence

The samples/ChatRoom directory now contains a new Orleans Chat Room sample, including the solution file (ChatRoom.sln), project references for the client, service, and common components, launch configurations, and cross-platform run scripts (run.cmd, run.sh). The sample demonstrates Orleans Streaming by allowing clients to set names, join/leave channels, send/receive messages, list members, and view chat history via ChannelGrain instances.

samples/ChatRoom · high confidence

A new Hello World sample has been added to the repository, providing a complete, runnable C\# application that demonstrates core Orleans concepts. The sample includes the grain interface (IHelloGrain), its implementation (HelloGrain), and a console host (Program.cs) configured with localhost clustering. It serves as a starting point for developers to understand how to define grains, obtain grain references via the grain factory, and invoke grain methods within a .NET Generic Host.

samples/HelloWorld · high confidence

Added a new sample demonstrating how to secure Orleans client-silo communication using mutual TLS (mTLS). The sample includes a server and client application that automatically generate and manage self-signed certificates for development, configure TLS via \UseTls\ on both the silo and client builders, and handle certificate validation settings appropriate for development versus production environments.

samples/TransportLayerSecurity · high confidence

Introduces the new Microsoft.Orleans.Serialization.FSharp NuGet package, which provides high-fidelity, version-tolerant serialization support for F\#-specific types such as Unit, FSharpOption, FSharpValueOption, discriminated unions, and records. This enables seamless integration of F\# code with the Orleans serialization system, allowing F\# types to be used directly in grain interfaces and state without manual mapping.

src/Orleans.Serialization.FSharp · high confidence

The Orleans.Serialization.Protobuf package now provides native serialization and deep-copy support for Protocol Buffers messages generated by Google.Protobuf. This change introduces a new ProtobufCodec that handles core message types, along with dedicated codecs and copiers for Google.Protobuf collection types such as ByteString, RepeatedField, and MapField. Users can enable this functionality by calling AddProtobufSerializer in their host configuration, allowing seamless use of Protobuf messages in grain interfaces and implementations.

src/Serializers · high confidence

Users can now store Orleans grains in a Redis-backed journal by registering the new Redis journal storage provider via the \AddRedisJournalStorage\ extension method on \ISiloBuilder\. The provider exposes configuration options for Redis connection details, key prefixes, read chunk sizes, and compaction thresholds, allowing integration of Redis as a durable storage backend for journaling.

src/api/Redis/Orleans.Journaling.Redis · high confidence

The S3 journaling storage component now includes a new \UseS3ExpressAppend\ option within \S3JournalStorageOptions\, enabling users to configure the storage provider for AWS S3 Express One Zone. This addition allows for lower-latency, high-throughput journaling by leveraging S3 Express capabilities, alongside existing options for bucket configuration, client setup, and conflict retry policies.

src/api/AWS/Orleans.Journaling.S3 · high confidence

The Stocks sample has been added to the repository, providing a C\# application that demonstrates how to use Orleans grains within a .NET BackgroundService. The sample implements a StocksHostedService that periodically fetches stock prices for symbols like MSFT and AAPL by calling IStockGrain instances, which in turn use HttpClient to retrieve data from the Alpha Vantage API and cache it using grain timers. It includes the necessary project structure, solution file, and run scripts for both Windows and Linux environments.

samples/Stocks · high confidence

The Orleans.Serialization.SystemTextJson package introduces a new JSON codec that leverages the System.Text.Json library for serializing and deserializing Orleans messages. This allows applications to use System.Text.Json attributes (such as JsonPropertyName and JsonIgnore) on grain data types and configure serialization behavior via standard JsonSerializerOptions. The feature is enabled by calling AddSystemTextJsonSerializer on the serializer builder, which registers the JsonCodec and associated type selectors to handle supported types.

src/Orleans.Serialization.SystemTextJson · high confidence

The TicTacToe sample has been added to the repository, demonstrating a web-based game built with ASP.NET Core MVC and the Orleans distributed virtual actor framework. The sample includes a complete solution with controllers (GameController, HomeController) that expose REST endpoints, and Orleans grains (PlayerGrain, GameGrain, PairingGrain) that manage game state, player sessions, and matchmaking. The application uses a JavaScript client with Handlebars templates to poll the server for updates, and is configured to run on HTTPS with localhost clustering support for multi-instance testing.

samples/TicTacToe · high confidence

A new Visual Basic sample application has been added to demonstrate how to write Orleans grain code in VB. The sample includes a C\# host project, a VB grain implementation, and a C\# interface definition, along with solution files and run scripts to build and execute the application.

samples/VBHelloWorld · high confidence

Users can now configure the Azure Table Storage grain directory via a dedicated options class, which allows specifying the table name (defaulting to 'GrainDirectory') and inherits standard storage operation settings. A corresponding validator is included to ensure these configuration values are valid before use.

src/Azure/Orleans.GrainDirectory.AzureStorage/Options · high confidence

The samples/Streaming/Simple location now includes a complete, runnable demonstration of Orleans pub/sub streaming. The sample features a Producer grain that emits events and a Consumer grain that utilizes implicit stream subscriptions to receive them. It supports both local in-memory streaming for development and production-grade streaming via Azure Event Hubs with Azure Table Storage for checkpointing, automatically switching based on the presence of configuration secrets.

samples/Streaming/Simple · high confidence

A new TestKit library for the Orleans Reminders subsystem has been introduced, providing tools to validate reminder provider implementations against standard conformance tests. This includes an idealized in-memory reminder table implementation for testing, a test runner to execute conformance suites, and helper classes for reporting failures and managing test state, allowing developers to ensure their custom reminder providers behave correctly.

src/api/Orleans.Reminders.TestKit · high confidence

This release introduces two new storage backends for the Orleans Journaling system, allowing users to persist journal data to Azure Blob Storage or Azure Table Storage. Users can now register these providers via the \AddAzureBlobJournalStorage\ and \AddAzureTableJournalStorage\ extension methods on the silo builder. The new \AzureBlobJournalStorageOptions\ and \AzureTableJournalStorageOptions\ classes expose configuration for connection strings, container/table names, retry policies for metadata-only conflicts, and compaction thresholds (for Table storage), enabling flexible integration with existing Azure accounts.

src/api/Azure/Orleans.Journaling.AzureStorage · high confidence

The Azure Queue stream provider now includes an experimental JSON serialization path, allowing stream events to be stored as compact JSON in Azure Queue messages instead of the previous binary format. This is enabled via the new \ISiloAzureQueueJsonStreamConfigurator\ and \IClusterClientAzureQueueStreamConfigurator\ interfaces, which expose \ConfigureJsonSerialization\ and \ConfigureJsonAdapter\ methods. The implementation introduces \AzureQueueJsonDataAdapter\ with fallback support to the existing binary adapter (\AzureQueueDataAdapterV2\) if JSON serialization fails, controlled by \AzureQueueJsonDataAdapterOptions\ (e.g., \PreferJson\, \EnableFallback\). Existing binary serialization remains the default unless explicitly configured otherwise, ensuring backward compatibility for current deployments.

src/Azure/Orleans.Streaming.AzureStorage/Providers/Streams/AzureQueue · high confidence

Persistent streams backed by Azure Table Storage now record delivery and subscription failures in a dedicated table. When an event cannot be delivered or a subscription cannot be established after retries, the system persists a failure entity containing the subscription ID, stream provider name, stream GUID, namespace, and the serialized sequence token of the failed event. This enables operators to inspect and diagnose persistent stream delivery issues directly in Azure Table Storage.

src/Azure/Orleans.Streaming.AzureStorage/Providers/Streams/PersistentStreams · high confidence

The Orleans BroadcastChannel module now supports explicit configuration through new hosting extension methods. Developers can add and configure broadcast channels on both silo and client builders using \AddBroadcastChannel\, which registers the necessary services and grain extensions. Additionally, a \GetBroadcastChannelProvider\ method allows retrieving a named provider instance from the cluster client, and a provider builder enables configuration via \IConfigurationSection\ for both silo and client setups.

src/Orleans.BroadcastChannel/Hosting · high confidence

The Orleans.Hosting namespace now exposes dedicated configurators and extension methods for the ADO.NET stream provider, allowing users to wire the provider via \IClientBuilder.AddAdoNetStreams\ on clients and \ISiloBuilder.AddAdoNetStreams\ on silos. These helpers automatically register the required options (\AdoNetStreamOptions\, \SimpleQueueCacheOptions\, \HashRingStreamQueueMapperOptions\) and a configuration validator, and provide fluent methods to adjust the receiver cache size and the number of stream queues (partitioning), which defaults to one queue per provider to suit typical I/O-bound shared database scenarios.

src/AdoNet/Orleans.Streaming.AdoNet/Hosting · high confidence

A new \CosmosClusteringOptions\ class and its associated validator have been introduced in the Orleans Clustering Cosmos provider. This class serves as the configuration container for Azure Cosmos DB clustering settings, inheriting from \CosmosOptions\ and defaulting the container name to 'OrleansCluster'. The included documentation notes that membership operations inherit the client's read consistency and utilize single-partition transactions with table-version fencing, guiding users on how to configure account and client consistency levels for optimal behavior.

src/Azure/Orleans.Clustering.Cosmos/Options · high confidence

The Orleans Cosmos persistence provider has been updated to allow users to define custom logic for generating document IDs and partition keys. This is exposed via new overloads for the \AddCosmosGrainStorage\ extension methods that accept a \customPartitionKeyProviderType\ argument, and by introducing the \IDocumentIdProvider\ interface (along with a \DefaultDocumentIdProvider\ implementation) to replace the obsolete \IPartitionKeyProvider\. This enables more flexible data distribution and storage strategies within Azure Cosmos DB containers.

src/api/Azure/Orleans.Persistence.Cosmos · high confidence

Orleans now supports persisting stream queue checkpoints using Orleans grains instead of relying solely on in-memory or external storage adapters. This change introduces a new \GrainStreamQueueCheckpointer\ and associated factory, options (\GrainStreamQueueCheckpointerOptions\), and grain interfaces (\IStreamCheckpointerGrain\, \IConfiguredStreamCheckpointerGrain\) along with the \StreamCheckpointGrain\ implementation. Users can configure a named grain storage provider to store checkpoints, allowing for more robust recovery and state management of stream subscriptions. The implementation includes a reusable checkpoint state machine, support for configurable persist intervals, and a numeric comparer for checkpoint ordering.

src/Orleans.Streaming · high confidence

The Orleans BroadcastChannel system now supports implicit subscriptions, allowing grains to automatically receive messages from channels based on namespace patterns without explicit registration. This is implemented in the new ImplicitChannelSubscriberTable, which resolves grain bindings, validates channel patterns against registered namespace predicates, and generates unique subscription identifiers for consumers. The component uses keyed services to resolve channel ID mappers and employs a caching mechanism to efficiently manage subscriber lookups, with thread-safe access provided by a Lock object on .NET 9+ or a standard object lock on earlier versions.

src/Orleans.BroadcastChannel/SubscriberTable · high confidence

This change introduces the \Orleans.Hosting.Kubernetes\ package, enabling Orleans silos to automatically discover and manage cluster membership within a Kubernetes environment. By calling \UseKubernetesHosting()\, silos can automatically configure their identity (namespace, pod name, IP) and cluster identifiers from environment variables or the Kubernetes service account, and the \KubernetesClusterAgent\ will monitor pod lifecycle events to keep the Orleans membership table in sync with the actual state of the cluster.

src/Orleans.Hosting.Kubernetes · high confidence

This change introduces the SQSStorage class, which acts as the core storage provider for the Orleans SQS streaming subsystem. It handles the initialization and configuration of AWS SQS queues, including support for FIFO queues with specific attributes (deduplication, throughput limits) and configurable receive wait times. The implementation manages AWS client creation using various authentication methods (explicit credentials, session tokens, or implicit IAM roles) and parses connection strings to extract service endpoints and credentials.

src/AWS/Orleans.Streaming.SQS/Storage · high confidence

Orleans now supports storing the grain directory in a relational database via a new ADO.NET provider. This adds the \AdoNetGrainDirectory\ implementation, configuration options (\AdoNetGrainDirectoryOptions\), and hosting extensions (\UseAdoNetGrainDirectoryAsDefault\, \AddAdoNetGrainDirectory\) to register the provider. It includes database schema scripts for MySQL, PostgreSQL, and SQL Server, and allows configuration via an ADO.NET invariant, a connection string, or a \DbDataSource\.

src/AdoNet/Orleans.GrainDirectory.AdoNet · high confidence

The ADO.NET Streaming Provider is now available, allowing Orleans applications to use relational databases (SQL Server, MySQL, PostgreSQL) as the underlying infrastructure for event streaming. This new capability includes the \Microsoft.Orleans.Streaming.AdoNet\ package, which provides the necessary components to publish and subscribe to streams of events. The provider supports configuration via \AdoNetStreamOptions\, including connection strings or \DbDataSource\ instances, and handles message persistence, dead-lettering, and eviction through dedicated database tables and stored procedures. Users can now integrate Orleans streaming with their existing SQL-based data stores.

src/AdoNet/Orleans.Streaming.AdoNet · high confidence

The ADO.NET clustering implementation now includes dedicated components for managing cluster membership and discovering gateway addresses via relational storage. The new \AdoNetClusteringTable\ class implements \IMembershipTable\ to handle silo registration, status updates, and table versioning in the database, while \AdoNetGatewayListProvider\ implements \IGatewayListProvider\ to retrieve active gateway URIs. These classes initialize database queries and interact with the configured connection string or data source to support Orleans clustering and client gateway discovery using ADO.NET.

src/AdoNet/Orleans.Clustering.AdoNet/Messaging · high confidence

The \Microsoft.Orleans.Journaling.S3\ package is introduced, providing an \IJournalStorage\ implementation backed by Amazon S3 Express One Zone directory buckets. It utilizes S3 Express append writes (\WriteOffsetBytes\) for write-ahead log (WAL) appends and supports conditional-rewrite appends for S3-compatible emulators like SeaweedFS. The provider includes a catalog enumeration mechanism that handles both ordered and unordered (directory bucket) listings, along with metrics for catalog traversal and provider retries. Configuration is exposed via \AddS3JournalStorage\ hosting extensions and \S3JournalStorageOptions\, allowing customization of object key mappings, client lifetimes, and retry behaviors.

src/AWS/Orleans.Journaling.S3 · high confidence

The Orleans.Clustering.Cosmos package now provides a new clustering implementation backed by Azure Cosmos DB. Users can enable this by calling UseCosmosClustering on the silo builder and UseCosmosGatewayListProvider on the client builder. The provider supports configuration via code delegates or standard IConfiguration sections, allowing you to specify the database name, container name, throughput, and connection details (via connection string or named connection). It registers the necessary services for silo membership and client gateway discovery, enabling Orleans clusters to coordinate using Cosmos DB as the persistent store.

src/Azure/Orleans.Clustering.Cosmos · high confidence

Added new \CosmosMembershipTable\ and \CosmosGatewayListProvider\ implementations for the Orleans Azure Cosmos DB clustering provider. The membership table now supports initializing the Cosmos database and container, managing cluster version entities, and performing transactional batch deletions for silo entries. It also includes logic to clean up defunct (dead) silo entries based on their update time. The gateway list provider queries the Cosmos container to retrieve active silo URIs, enabling Orleans to discover and connect to gateway services stored in Azure Cosmos DB.

src/Azure/Orleans.Clustering.Cosmos/Membership · high confidence

Adds a new \Microsoft.Orleans.Persistence.Cosmos\ package that enables Orleans grains to persist their state in Azure Cosmos DB. The provider supports configurable document IDs and partition keys via custom providers, allows specifying the Cosmos client via connection string or named keyed service, and includes a dedicated \CosmosConditionNotSatisfiedException\ for handling Etag inconsistencies during state writes.

src/Azure/Orleans.Persistence.Cosmos · high confidence

This change adds the foundational shared components for Azure Cosmos DB integration within Orleans, enabling the use of Cosmos DB for clustering, grain persistence, and reminders. The diff introduces a base entity model with ID and ETag handling, a sanitizer for Cosmos DB-compatible identifiers, and a comprehensive options class that allows users to configure the database name, container name, throughput settings, and client creation (supporting connection strings, account keys, and Azure AD credentials). It also includes a configuration validator to ensure required settings are present and a default operation executor that implements retry logic for rate-limiting (429) errors, providing a robust baseline for these new storage backends.

src/Azure/Shared/Cosmos · high confidence

Users can now store grain location information in Azure Table Storage via the new \AzureTableGrainDirectory\ implementation. This replaces the previous \ActivationAddress\ model with \GrainAddress\ and \MembershipVersion\ for more accurate cluster state tracking, and utilizes the \Azure.Data.Tables\ SDK for storage operations. Configuration is done via \UseAzureStorageGrainDirectoryAsDefault\, allowing users to specify a connection string and table name to enable distributed grain lookup across the cluster.

src/Azure/Orleans.GrainDirectory.AzureStorage · high confidence

This change adds a new transactional state storage implementation for Orleans transactions using Azure Table Storage. It introduces configuration options (AzureTableTransactionalStateOptions) to specify the table name and initialization lifecycle stage, along with a factory and storage class that leverage the Azure.Data.Tables SDK. The implementation handles loading and storing transactional state, including support for larger state sizes by chunking JSON data across multiple table entity properties, and manages partition keys based on grain ID and state name to improve scalability.

src/Azure/Orleans.Transactions.AzureStorage/TransactionalState · high confidence

Orleans now includes a new BroadcastChannel feature that enables grains to publish and subscribe to typed message streams. This change adds the core implementation files for the feature, including the \BroadcastChannelProvider\ and \BroadcastChannelWriter\ for publishing items, and the \BroadcastChannelConsumerExtension\ and \BroadcastChannelSubscription\ for handling incoming messages and errors. It also introduces \BroadcastChannelOptions\ to configure delivery behavior (such as fire-and-forget mode), a \ChannelId\ struct for identifying channels, and \BroadcastChannelEvents\ for diagnostic tracing of published and delivered items.

src/Orleans.BroadcastChannel · high confidence

Adds a new clustering implementation for Orleans using Apache Cassandra, allowing users to configure the provider via \UseCassandraClustering\ extensions on both \IClientBuilder\ and \SiloBuilder\. The change introduces \CassandraClusteringTable\ for membership management and \CassandraGatewayListProvider\ for gateway discovery, supporting both automatic session creation and custom session delegates. It includes configuration options for controlling TTL on dead silo rows, handling initialization contention with retry delays, and setting specific consistency levels for reads and writes.

src/Cassandra · high confidence

The ChatRoom sample now demonstrates real-time messaging using Orleans streams. The service configures a 'chat' memory stream provider and a localhost silo, while the ChannelGrain implementation manages user join/leave events and message history by publishing ChatMsg records to the stream. The common layer defines the serializable ChatMsg record and the IChannelGrain interface for client interaction.

samples/ChatRoom/ChatRoom.Common, samples/ChatRoom/ChatRoom.Service · high confidence

This change adds a new clustering implementation that uses HashiCorp Consul as the membership table backend. For silos, the \ConsulBasedMembershipTable\ handles registration, heartbeat, and consistency checks via Consul's key-value store, configured via \UseConsulSiloClustering\. For clients, the \ConsulGatewayListProvider\ discovers active gateway addresses from the same Consul membership data, configured via \UseConsulClientClustering\. Configuration is managed through \ConsulClusteringOptions\, allowing users to specify the Consul address, ACL token, and optional KV root folder, with the provider automatically registering the necessary DI services.

src/Orleans.Clustering.Consul · high confidence

Adds the DynamoDBGrainStorage class, enabling Orleans applications to persist grain state to an Amazon DynamoDB table. The provider supports both JSON and binary serialization formats, handles table initialization (including optional creation and updates), manages ETags for optimistic concurrency, and allows configuring Time-To-Live (TTL) for automatic state expiration. It integrates with the Orleans silo lifecycle and uses the standard IGrainStorage interface for read/write operations.

src/AWS/Orleans.Persistence.DynamoDB/Provider · high confidence

This change adds the Orleans.Transactions.DynamoDB package, providing a new storage provider for transactional grain state backed by Amazon DynamoDB. It includes configuration options for table settings (such as read/write capacity units and provisioned throughput), silo builder extensions to register the provider, and the underlying storage implementation that handles transactional load and store operations. Additionally, the DynamoDB client options now explicitly mark access keys, secret keys, and tokens with a \[Redact\] attribute to ensure these sensitive credentials are not logged.

src/api/AWS/Orleans.Transactions.DynamoDB · high confidence

The DynamoDB reminder table implementation is now available in the Orleans.Reminders.DynamoDB package, allowing users to store grain reminders in Amazon DynamoDB. This change introduces the DynamoDBReminderTable class which manages table initialization with configurable read/write capacity units and global secondary indexes (ServiceIdGrainHashIndex, ServiceIdGrainReferenceIndex) for efficient querying. Users can configure the storage via DynamoDBReminderStorageOptions, supporting connection strings, AWS credentials, and table creation/update settings.

src/AWS/Orleans.Reminders.DynamoDB/Reminders · high confidence

This release adds the \Microsoft.Orleans.Streaming.NATS\ package, enabling Orleans silos and clients to use NATS JetStream as a persistent event stream provider. Users can configure the provider via \AddNatsStreams\ on \ISiloBuilder\ and \IClientBuilder\, specifying options such as the stream name, partition count, batch size, producer count, and storage type (File or Memory). The provider handles connection management, stream creation and updates, and message serialization using Orleans' serializer, allowing grains to produce and consume events through the standard Orleans streaming interfaces.

src/Orleans.Streaming.NATS · high confidence

The Orleans.Serialization.Abstractions package is now available, providing the core interfaces and attributes required for Orleans serialization without including the implementation itself. This package introduces the \GenerateSerializerAttribute\ for marking types as serializable, including support for automatic field ID generation via the \GenerateFieldIds\ enum (allowing automatic assignment to public properties) and automatic inclusion of primary constructor parameters for record types. It also defines attributes for remoting support, such as \GenerateMethodSerializersAttribute\ for interface-based remoting, and \InvokeMethodNameAttribute\/\DefaultInvokableBaseTypeAttribute\ for customizing how method calls are serialized and invoked. Additionally, it includes \FrameworkPartAttribute\ to mark assemblies as framework parts (excluding them from certain serialization scopes) and provides the \IsExternalInit\ shim for C\# 9+ init-only properties on older targets. Users can now reference this package directly to define serializable contracts and control code generation behavior.

src/Orleans.Serialization.Abstractions · high confidence

The Orleans.Transactions.TestKit.Base package now exposes its public API surface, including the \UseControlledFaultInjectionTransactionState\ extension for DI, fault-injection types and controls (\FaultInjectionType\, \FaultInjectionControl\), and various test runner classes (e.g., \ConsistencyTransactionTestRunner\, \ControlledFaultInjectionTransactionTestRunner\, \ExclusiveLockTransactionTestRunner\) and supporting grains/storages used to validate transaction behavior under fault conditions.

src/api/Orleans.Transactions.TestKit.Base · high confidence

Added a new cache pressure monitoring system to the EventHubs streaming provider to help manage back-pressure during message ingestion. This change introduces the ICachePressureMonitor interface and three specific implementations: AveragingCachePressureMonitor, which calculates pressure based on weighted averages; SlowConsumingPressureMonitor, which tracks the maximum pressure contribution within a time window to protect slow consumers; and AggregatedCachePressureMonitor, which combines multiple monitors to report overall system health. These components enable the provider to detect when message ingestion is too fast and trigger throttling, while logging status changes for observability.

src/Azure/Orleans.Streaming.EventHubs/Providers/Streams/EventHub/CachePressureMonitors · high confidence

The Orleans BroadcastChannel subsystem now includes a default implementation for mapping stream identifiers to grain keys. This change adds the IChannelIdMapper interface and the DefaultChannelIdMapper class, which allows broadcast channels to be associated with specific grain types. The default mapper supports both Guid and Int64 key types and can optionally include the channel namespace in the resulting grain key, enabling more flexible routing and identification for broadcast stream consumers.

src/Orleans.BroadcastChannel/IdMapping · high confidence

This change adds the public API surface for the Orleans Durable Jobs subsystem, defining the core data models (DurableJob, DurableJobRunResult), status enums, and interfaces for job handling (IDurableJobHandler, IDurableJobFeatureHandler), shard management (IJobShard, JobShard), and storage inspection (IDurableJobsStorageInspector). Users can now register job handlers, schedule and cancel jobs via ILocalDurableJobManager, and inspect storage status, establishing the foundation for reliable, long-running background job execution with retry and rescheduling capabilities.

src/api/Orleans.DurableJobs · high confidence

The DurableJobs subsystem is now available, allowing jobs to be scheduled for future execution with support for asynchronous handlers that can poll for status updates and request durable rescheduling after completion. The implementation includes built-in distributed tracing and metrics for monitoring job scheduling, execution, and shard processing, while enforcing the use of an injected TimeProvider to ensure testability and consistency.

src/Orleans.DurableJobs · high confidence

Orleans.Journaling now provides a set of built-in durable state contracts—IDurableDictionary, IDurableList, IDurableQueue, IDurableSet, IDurableValue, IDurableTaskCompletionSource, and IPersistentState—along with a DurableGrain base class and DurableStateManager extensions to easily access them. These types implement IStateMachine so that mutations are automatically recorded in the journal and replayed on activation, giving users a familiar, strongly-typed API for persistent collections and values without manual serialization or state-management boilerplate.

src/Orleans.Journaling · high confidence

The broadcast channel subscription system now supports flexible, extensible filtering of stream namespaces via a new predicate interface. Users can subscribe to all namespaces, match a specific namespace exactly, or use regular expressions by applying attributes like \[ImplicitChannelSubscription\], \[ExactMatchChannelSubscription\], or \[RegexImplicitChannelSubscription\]. The system also allows custom predicate implementations to be registered and instantiated via a constructor-based provider, enabling advanced filtering logic without modifying core Orleans code.

src/Orleans.BroadcastChannel/SubscriberTable/Predicates · high confidence

The \Orleans.TestingHost\ package now supports creating test clusters that run entirely in-process, eliminating the need for external silo processes. This new \InProcessTestCluster\ uses an in-memory transport layer for communication between silos and clients, and includes built-in support for observing grain directory convergence and collecting diagnostic events to make tests more deterministic and easier to debug.

src/Orleans.TestingHost · high confidence

The ChatRoom.Client sample has been rewritten as a modern .NET console application using the generic host builder and Spectre.Console for interactive UI. It now features a structured command loop for joining/leaving channels, setting usernames, viewing history and members, and sending messages, with a dedicated StreamObserver to display incoming chat messages in real-time.

samples/ChatRoom/ChatRoom.Client · high confidence

This change introduces a new shared storage layer (\src/AdoNet/Shared/Storage\) that provides common utilities for all ADO.NET-based Orleans providers (Clustering, Persistence, Reminders, Streaming, GrainDirectory). It includes \AdoNetFormatProvider\ for safe SQL string formatting, \DbConnectionFactory\ for vendor-agnostic connection creation, \DbConstantsStore\ for provider-specific settings (like escape characters and streaming support), and \DbExtensions\ for standardized parameter creation and data reading. This centralizes database interaction logic, ensuring consistent behavior across different relational database backends.

src/AdoNet/Shared/Storage · high confidence

The Orleans.Transactions library adds a set of new interfaces and attributes to define transactional state and service commit operations. This includes \ITransactionalState\<TState\>\ and \ITransactionalStateStorage\<TState\>\ for managing durable state with optimistic concurrency, \ITransactionCommitter\<TService\>\ for enlisting service operations to run on commit, and \TransactionalStateAttribute\ and \TransactionCommitterAttribute\ for configuring these facets via dependency injection. Additionally, \ITransactionManager\ and \ITransactionalResource\ interfaces are introduced to coordinate the prepare and commit protocol, while \ITransactionAgentStatistics\ provides metrics for transaction activity.

src/Orleans.Transactions · high confidence

The runtime now supports a shared setup phase for grain activations, allowing common components to be resolved once per grain type rather than per instance. This is enabled by the new \ActivationDataActivatorProvider\ and \GrainContextActivator\ which coordinate the creation of grain contexts. Additionally, the \DefaultGrainActivator\ is now exposed as a public, customizable component, allowing users to replace the default grain instantiation logic via the \IGrainActivator\ interface.

src/Orleans.Runtime · high confidence

The Orleans runtime now exposes a new \Orleans.Core.Abstractions\ package containing the foundational types for building grain-based applications. This includes the abstract \Grain\ and \Grain\<T\>\ base classes, the \IGrainBase\ interface, and key identity types like \GrainId\ and \SiloAddress\. The package also introduces the \GrainCancellationToken\ and \GrainCancellationTokenSource\ for cross-grain cancellation, along with concurrency attributes such as \ReentrantAttribute\, \ReadOnlyAttribute\, and \AlwaysInterleaveAttribute\ to control request interleaving. Additionally, it provides the \DeactivationReason\ struct for handling grain lifecycle events and serialization hooks like \IOnDeserialized\.

src/Orleans.Core.Abstractions · high confidence

The JournaledGrain base class in Orleans.EventSourcing now exposes a ClearLogAsync method that accepts a System.Threading.CancellationToken. This allows users to cancel the operation of clearing the event log if the request takes too long or is otherwise interrupted, providing better control over long-running consistency operations.

src/api/Orleans.EventSourcing · high confidence

The Orleans.Serialization API surface has been expanded to include native serialization and deep-copy support for F\# types (FSharpChoice, FSharpList, FSharpMap, FSharpOption, FSharpRef) via the new Orleans.Serialization.FSharp assembly. Additionally, the Orleans.Serialization.Protobuf assembly now exposes codecs and copiers for Google.Protobuf types (ByteString, MapField, RepeatedField) along with a ProtobufCodec and hosting extensions to enable Protobuf-based serialization. Finally, the Orleans.Serialization.TestKit assembly introduces abstract test harnesses (FieldCodecTester, CopierTester, SerializationTester) to standardize round-trip and deep-copy validation for custom codecs and copiers.

src/api/Orleans.Serialization · high confidence

Added a new sample application in samples/AWS/KinesisDynamoDB that demonstrates an Orleans silo using AWS DynamoDB for clustering, grain state, pub/sub storage, and reminders, alongside Amazon Kinesis Data Streams for streaming with DynamoDB-based checkpointing. The sample includes a publisher service and a stream processor grain that consumes events, persists state, and manages durable reminders, providing a complete reference for integrating Orleans with these AWS services.

samples/AWS · high confidence

Orleans now supports Azure Blob Storage and Azure Table Storage as backends for the journaling system. The new \AzureBlobJournalStorageProvider\ stores write-ahead logs and checkpoints as append blobs, while \AzureTableJournalStorageProvider\ uses table entities with generation-based row management. Both providers include configurable options for container/table names, client initialization, compaction thresholds, and metadata conflict retries, and are registered via \AddAzureBlobJournalStorage\ or the \AzureBlobStorage\ provider builder.

src/Azure/Orleans.Journaling.AzureStorage · high confidence

Introduces the AzureBlobLeaseProvider, a new implementation of the ILeaseProvider interface that manages distributed leases using Azure Blob Storage. This provider allows Orleans silos to coordinate access to shared resources by acquiring, renewing, and releasing leases on specific blobs within a configured container, replacing previous mechanisms with a native Azure SDK implementation.

src/Azure/Orleans.Streaming.AzureStorage/Providers/Lease · high confidence

A new Basic Clustering sample has been added to the samples directory, demonstrating how to orchestrate a multi-silo Orleans cluster using .NET Aspire. The sample uses an Aspire AppHost to provision a local Redis container for cluster membership and gateway discovery, launching two silo replicas via \.WithReplicas(2)\. It includes a \ClusterMonitor\ background service that tracks silo membership changes and validates cluster readiness by invoking a grain, providing a modern, containerized alternative to in-memory clustering for local development.

samples · high confidence

The Blazor Server sample has been updated to demonstrate integration with Microsoft Orleans, moving beyond the standard template to showcase real-time synchronization between browser sessions. The application now leverages Orleans grains for data management and persistence, specifically using a Todo list demo that subscribes to Orleans Streams to mirror updates across multiple browser windows in real-time. It also includes a Weather Forecast demo that fetches read-only data from an Orleans grain. The sample targets .NET 10 and uses the modern WebApplicationBuilder for configuration.

samples/Blazor/BlazorServer · high confidence

The Orleans.Streaming package now exposes a new BroadcastChannel API, including attributes for implicit channel subscriptions, channel ID mapping, and namespace predicates, alongside hosting extensions for configuring broadcast channels. Additionally, the streaming subsystem introduces new configuration options for grain-backed stream checkpointer persistence intervals and initial subscription start positions, allowing users to control checkpointing behavior and stream replay points.

src/api/Orleans.Streaming · high confidence

This change introduces a new playground environment for testing DurableJobs journaling capabilities. It includes a full local development stack orchestrated via Aspire, featuring an Orleans cluster, Azure Storage (with configurable providers like Azurite or Premium Blob), Prometheus, and Grafana. The playground is equipped with comprehensive OpenTelemetry instrumentation, including a custom collector that forwards telemetry to both the Aspire Dashboard and Prometheus. Grafana dashboards are pre-configured to visualize Orleans runtime metrics, ASP.NET Core performance, and .NET runtime health, providing immediate visibility into workflow stages, latency, and storage operations.

playground/DurableJobsJournaling · high confidence

This change introduces a new \Microsoft.Orleans.Transactions.DynamoDB\ package that enables durable, distributed transactions for Orleans grain state using Amazon DynamoDB. It provides the \DynamoDBTransactionalStateStorage\ implementation, which manages transactional state via a dedicated DynamoDB table (defaulting to 'OrleansTransactionalState') with partition and row keys, ETags for optimistic concurrency, and sequence IDs for ordering. Users can register this provider via the new \AddDynamoDBTransactionalStateStorage\ and \AddDynamoDBTransactionalStateStorageAsDefault\ silo builder extensions, configuring options such as provisioned throughput, table creation, and serialization. The implementation handles snapshot loading, pending transaction recovery, and batched writes while respecting DynamoDB's 400 KB item and 4 MB transaction size limits.

src/AWS/Orleans.Transactions.DynamoDB · high confidence

This change introduces the \DynamoDBGatewayListProvider\ and \DynamoDBMembershipTable\ implementations within the \Orleans.Clustering.DynamoDB\ package, enabling Orleans silos to use Amazon DynamoDB for cluster membership coordination and gateway discovery. The new providers support configuration via \DynamoDBClusteringOptions\ and \DynamoDBGatewayOptions\, including optional table creation and updates, and allow connection details to be parsed from data connection strings via helper classes. This provides a persistent, scalable backend for Orleans clustering on AWS.

src/AWS/Orleans.Clustering.DynamoDB/Membership · high confidence

The Orleans.Streaming.EventHubs package is now available, enabling applications to use Azure Event Hubs as a scalable streaming backbone. The provider supports two checkpointing strategies: the traditional Azure Table Storage checkpointer for compatibility, and a new grain-backed checkpointer that stores offsets in durable grain storage (configurable via PubSubStore) to avoid external table dependencies. The package includes configuration examples for both modes and defines internal error codes for stream operations.

src/Azure/Orleans.Streaming.EventHubs · high confidence

The Orleans.Persistence.TestKit package is introduced, providing a standardized way to validate custom grain storage providers. It includes a \GrainStorageTestFixture\ base class for setting up test clusters and a \GrainStorageTestRunner\ that executes a comprehensive suite of conformance tests (such as write-read-clear cycles, ETag handling, and concurrent state access) against any implementation of \IGrainStorage\. A model-based runner is also provided to generate and run these tests using configurable options, ensuring storage providers meet the expected behavioral contracts.

src/api/Orleans.Persistence.TestKit · high confidence

Added a new playground example (playground/DashboardSeparateHost) that demonstrates hosting the Orleans Dashboard in a separate web application. The sample runs a standalone Orleans silo and a distinct dashboard web app that connects to the silo as an Orleans client, using the AddDashboard extension on both the silo and client builders and MapOrleansDashboard to expose the UI. It includes launch settings and documentation explaining the architecture, how to run the example, and how to customize the connection, route prefix, and authentication.

playground/DashboardSeparateHost · high confidence

The GPSTracker sample has been rewritten to demonstrate tracking GPS-equipped IoT devices on a map using near-real-time updates via SignalR. The service now uses the modern WebApplicationBuilder host model and includes a FakeDeviceGateway that simulates devices moving around San Francisco. The architecture features a DeviceGrain that calculates speed and forwards updates to a singleton PushNotifierGrain, which batches messages and broadcasts them to web clients through a LocationHub. The sample also includes a HubListGrain and HubListUpdater to manage service discovery of SignalR hubs across multiple silo instances, and integrates OpenTelemetry for metrics (Prometheus) and distributed tracing (Zipkin/Jaeger).

samples/GPSTracker · high confidence

Added a new sample demonstrating a gaming presence service architecture. The sample includes a solution with a PresenceService (Orleans silo), a LoadGenerator (simulating game server heartbeats), and a PlayerWatcher (client polling for presence). It features Orleans grains (PresenceGrain, GameGrain, PlayerGrain) that process binary heartbeat data to track player join/leave events and game scores, pushing updates to subscribed observers via the IGameObserver interface. The sample also includes build/run scripts and documentation.

samples/Presence · high confidence

Added a new sample demonstrating a text adventure game built with Orleans, featuring a server (\AdventureServer\) that initializes a game world from a JSON map and a console client (\AdventureClient\) that allows players to interact with grains (\IPlayerGrain\, \IRoomGrain\, \IMonsterGrain\) via commands like 'look', 'go', and 'kill'.

samples/Adventure · high confidence

Added a new demo application in the \playground/ActivationRepartitioning\ location that showcases the experimental \AddActivationRepartitioner\ and \AddActivationRebalancer\ features. The frontend service configures these experimental components with specific timing options (e.g., 5-15 second round periods) and exposes a \/data.json\ endpoint that returns a call graph of grain activations and silo host details via the \ClusterDiagnosticsService\. The AppHost project provisions a Redis cluster for Orleans clustering and launches five replicas of the frontend application.

playground/ActivationRepartitioning · high confidence

The Orleans.Analyzers package introduces several new diagnostic rules to improve code correctness and serialization safety. ORLEANS0014 warns when grain code uses ConfigureAwait(false) or ConfigureAwait without ContinueOnCapturedContext, helping prevent deadlocks in Orleans execution contexts. ORLEANS0005 suggests adding \[GenerateSerializer\] to types marked with \[Serializable\], while ORLEANS0004 enforces the presence of \[Id\] and \[NonSerialized\] attributes on serializable members. Additionally, ORLEANS0006 prevents abstract or static properties from being marked for serialization, and ORLEANS0011 detects duplicate or conflicting \[Alias\] attributes on grain interfaces and types. Code fixes are provided for these diagnostics to automatically correct common issues.

src/Orleans.Analyzers · high confidence

Developers can now scaffold new Orleans applications using the \dotnet new\ command with two new templates: \orleans\ and \orleans-web\. The \orleans\ template generates a multi-project solution (AppHost, Silo, Client, Contracts, Grains) orchestrated by .NET Aspire, using Azurite for local clustering and storage. The \orleans-web\ template creates a single ASP.NET Core project that co-hosts an Orleans silo with localhost clustering. Both templates target .NET 10 by default (with .NET 8 support via flags) and include GitHub Copilot instructions to guide development with current Orleans documentation and API references.

templates · high confidence

A new sample application has been added to the \samples/Deployment/AzureAppService\ directory, demonstrating a multi-instance Orleans shopping cart deployed to Azure App Service on Windows or Linux. The sample includes the full solution structure: Abstractions defining grain interfaces (such as \IProductGrain\, \IInventoryGrain\, and \IShoppingCartGrain\) and serializable models; Grain implementations using persistent state and reentrancy; and a cohosted ASP.NET Core Silo frontend with Blazor UI components. It specifically showcases Azure App Service integration features, including private silo endpoint discovery via \WEBSITE\_PRIVATE\_IP\, Microsoft Entra authentication via the \X-MS-CLIENT-PRINCIPAL\ header, and deployment workflows using GitHub Actions with OIDC.

samples/Deployment · high confidence

A new test kit library has been added to help developers verify that their custom Orleans clustering membership providers adhere to the expected conformance standards. The \Orleans.Clustering.TestKit\ package exposes a suite of pre-built conformance tests (such as \MembershipTableTestRunner\ and \MembershipTableModelBasedTestRunner\) that validate behaviors like concurrent updates, cluster isolation, and lifecycle management. It also provides helper classes like \MembershipTableTestFixture\ and configuration options (\MembershipTableModelBasedConformanceOptions\) to simplify the setup and execution of these validation tests against custom implementations.

src/api/Orleans.Clustering.TestKit · high confidence

The Orleans.Persistence.TestKit package introduces a framework-neutral test infrastructure for validating custom IGrainStorage implementations. It provides the GrainStorageTestFixture base class to manage an in-process Orleans cluster and the GrainStorageTestRunner base class containing a comprehensive suite of direct storage tests (covering read/write/clear cycles, ETag consistency, concurrency, and error handling). Additionally, it includes the GrainStorageModelBasedTestRunner, which generates and executes behavioral model-based test sequences to verify provider conformance against complex operation states.

src/Orleans.Persistence.TestKit · high confidence

A new package, Microsoft.Orleans.Reminders.AzureStorage, is introduced to provide reminder persistence backed by Azure Table Storage. This change adds service collection and silo builder extension methods (UseAzureTableReminderService) that allow users to configure the reminder store via connection strings, TableServiceClient instances, or configuration sections, and registers the necessary validation and storage providers to ensure reminders survive silo restarts.

src/Azure/Orleans.Reminders.AzureStorage · high confidence

A new test kit has been added to validate Orleans \IReminderTable\ implementations and their integration with the reminder service. It includes a deterministic, in-memory reference implementation (\IdealizedReminderTable\) to serve as a known-correct oracle, along with conformance runners (\ReminderTableTestRunner\, \ReminderServiceTestRunner\, \ReminderServiceLifecycleTestRunner\) that verify table guarantees, grain-facing service behavior, and lifecycle scenarios like startup, ownership, and churn. The kit also provides a model-based test runner for generating and verifying operation sequences against the behavioral contract.

src/Orleans.Reminders.TestKit · high confidence

The Orleans.Serialization.TestKit package is now available to help developers test custom serialization codecs and deep copiers. It provides abstract base classes like FieldCodecTester, CopierTester, and ValueTypeFieldCodecTester that handle service provider setup, session pooling, and reference tracking, allowing you to focus on verifying that your custom types serialize, deserialize, and copy correctly.

src/Orleans.Serialization.TestKit · high confidence

This release introduces two new packages, \Microsoft.Orleans.Clustering.Redis\ and \Microsoft.Orleans.GrainDirectory.Redis\, allowing Orleans applications to use Redis as the backing store for cluster membership and grain location resolution. The diff adds hosting extensions (\UseRedisClustering\, \UseRedisGrainDirectoryAsDefault\) and provider builders that support configuration via \Microsoft.Extensions.Configuration\ (including \appsettings.json\ and .NET Aspire keyed services). Key implementation details include the \RedisMembershipTable\ for silo coordination, the \RedisGrainDirectory\ for grain lookup using Lua scripts for atomic registration, and the \RedisGatewayListProvider\ for client-side gateway discovery, all featuring configurable connection multiplexers and entry expiry options.

src/Redis · high confidence

The Orleans security layer now includes a new TLS connection middleware that allows clients to skip remote TLS authentication by setting RemoteCertificateMode to NoCertificate or AllowCertificate. The middleware enforces ALPN by advertising the 'Orleans1' application protocol and exposes detailed handshake information, including the negotiated cipher suite, TLS protocol version, and Server Name Indication (SNI) hostname, via new feature interfaces.

src/Orleans.Connections.Security/Security · high confidence

The test kit now includes a new consistency testing subsystem (ConsistencyTestGrain, ConsistencyTestHarness, and related options) that executes randomized transactional read/write sequences and validates their observed histories for serial consistency. Additionally, a comprehensive fault-injection framework has been added, featuring a FaultInjectionControl mechanism to target specific transaction phases (e.g., BeforePrepare, AfterCommitReadOnly) and types (e.g., Deactivation, ExceptionBeforeStore), along with specialized storage wrappers for Azure Table and DynamoDB providers that inject faults around store operations.

src/Orleans.Transactions.TestKit.Base · high confidence

Orleans Event Sourcing now includes a new CustomStorage log consistency provider, allowing grains to use their own custom storage interface (ICustomStorageInterface) for reading state and applying deltas instead of relying on standard grain storage. This change introduces a new base class (JournaledGrain) for log-consistent grains, a generic PrimaryBasedLogViewAdaptor template for building consistency protocols, and new hosting extensions (AddCustomStorageBasedLogConsistencyProvider) to wire the provider into the silo. It also adds core infrastructure for handling connection issues (ConnectionIssue, RecordedConnectionIssue, IConnectionIssueListener) and notification messages (VersionNotificationMessage, BatchedNotificationMessage) to support multi-cluster replication and retry logic.

src/Orleans.EventSourcing · high confidence

The serialization engine introduces a new set of low-level components to improve performance and flexibility. It adds the \PooledBuffer\ and \ArcBuffer\ types, which are specialized \IBufferWriter\ implementations designed to efficiently create \ReadOnlySequence\ instances from pooled arrays. A suite of buffer adaptors (e.g., \ArrayStreamBufferWriter\, \MemoryStreamBufferWriter\, \SpanBufferWriter\) is added to bridge these new buffers with standard .NET streams and memory types. Additionally, a new \IActivator\ interface and its default implementations are introduced to handle object instantiation, providing a fallback to \RuntimeHelpers.GetUninitializedObject\ when default constructors are unavailable.

src/Orleans.Serialization · high confidence

This change introduces new extension methods in the \Orleans.Hosting\ namespace to simplify TLS configuration. For clients, \IClientBuilder.UseTls\ allows configuring TLS via certificate store parameters, direct \X509Certificate2\ objects, or a configuration action, automatically applying the settings to client connections. For silos, \ISiloBuilder.UseTls\ provides similar overloads and configures TLS for both inbound (silo and gateway) and outbound connections. The underlying \TlsConnectionBuilderExtensions\ now exposes \UseServerTls\ and \UseClientTls\ middleware registration methods, enabling developers to easily secure Orleans communication with TLS.

src/Orleans.Connections.Security/Hosting · high confidence

Orleans.Core introduces a suite of internal utility classes to manage asynchronous concurrency and execution patterns. This includes AdmissionGate for controlling concurrent operation entry and draining, AsyncLock for async-compatible mutual exclusion, AsyncSerialExecutor for non-interleaved serial execution of async functions, BatchWorker for efficient queued work processing, and MultiTaskCompletionSource for coordinating multiple completion signals. These components provide the foundational primitives for improved concurrency control and resource management within the runtime.

src/Orleans.Core · high confidence

The Orleans.Clustering.TestKit package now includes a comprehensive suite for validating membership provider implementations against the Orleans clustering contract. It provides a \MembershipTableTestFixture\ to manage isolated cluster scopes and provider instances, a \MembershipTableTestRunner\ with explicit tests for guarantees like versioning, compaction, and token handling, and a \MembershipTableModelBasedTestRunner\ that uses the Accordant framework to generate and execute bounded state-transition sequences. This kit allows developers to verify that their custom or third-party membership providers correctly handle insertion, updates, heartbeats, cleanup, and concurrent access.

src/Orleans.Clustering.TestKit · high confidence

Added two new demonstration applications to the playground. The \ActivationRebalancing\ example showcases the activation rebalancer feature, configuring a multi-silo Orleans cluster with Redis, a background load driver, and a frontend dashboard that visualizes silo activation statistics using D3.js. The \DashboardCohosted\ example demonstrates how to host the Orleans Dashboard within the same process as the Orleans silo using minimal APIs and the \AddDashboard\ extension.

playground/ActivationRebalancing · high confidence

A new sample application has been added to showcase durable grain state journaling using Azure Blob Storage with a JSON event format. The sample includes an Aspire AppHost for local development with an Azure Storage emulator, and a main application that configures Orleans to use \AddAzureBlobJournalStorage\ and \UseJsonJournalFormat\. It exercises various durable state types (dictionaries, lists, queues, sets, values, task completion sources, and persistent state) and verifies recovery after grain deactivation and reactivation, providing a concrete reference for implementing JSON-based journaling in Azure environments.

samples/JournalingAzureBlobJson · high confidence

The Orleans Dashboard frontend has been completely rewritten in React, replacing the previous implementation. This change introduces a new component-based architecture (including components for grains, silos, charts, and preferences) and updates the visual styling via a new custom CSS file, providing a modernized user interface for monitoring Orleans clusters.

src/Dashboard/Orleans.Dashboard.App/src · high confidence

The Orleans Dashboard has been reorganized into a new modular architecture, introducing the \Microsoft.Orleans.Dashboard.Abstractions\ package for core data models and the \Orleans.Dashboard.Core\ namespace for internal client and grain interfaces. This change integrates OpenTelemetry metrics collection via \DashboardTelemetryExporter\ and \DashboardHost\, replacing previous mechanisms. It also adds a \NoProfilingAttribute\ to allow users to exclude specific grains or methods from performance tracking, and introduces \DashboardOptions\ and \GrainProfilerOptions\ for configuring counter intervals, history length, and profiler deactivation behavior.

src/Dashboard/Orleans.Dashboard · high confidence

The Orleans Redis grain storage and reminder table providers now expose a \CreateMultiplexer\ configuration option in \RedisStorageOptions\ and \RedisReminderTableOptions\. This allows users to provide a custom factory function to create the \StackExchange.Redis.IConnectionMultiplexer\ instance, rather than relying solely on the default connection string-based creation. This change enables more flexible connection management, such as connection pooling or shared multiplexer usage, for both persistent grain state and reminder subscriptions.

src/api/Redis/Orleans.Persistence.Redis · high confidence

The reminder service implementation has been split out from the core Orleans runtime into a new, dedicated Orleans.Reminders package. This change introduces a new public API surface for reminder management, including extension methods on Grain and IGrainBase for registering, unregistering, and querying reminders, as well as new configuration options (ReminderOptions) for tuning behavior such as minimum period and loading windows. The package also provides a new in-memory reminder service for development and testing, along with comprehensive diagnostic events and error codes specific to the reminder subsystem.

src/Orleans.Reminders · high confidence

The Amazon SQS stream provider in Orleans now supports FIFO (First-In-First-Out) queues, enabling strict message ordering per stream. This is achieved by introducing a new \SQSFIFOSequenceToken\ to track SQS-specific sequence numbers and event indices, and updating the \SQSAdapter\ to generate Message Group IDs and Deduplication IDs when the \FifoQueue\ option is enabled. The \SQSBatchContainer\ and \SQSDataAdapter\ have been updated to serialize and deserialize these FIFO tokens, ensuring that consumers receive events in the exact order they were produced within a stream.

src/AWS/Orleans.Streaming.SQS/Streams · high confidence

The Orleans SQS streaming provider has been updated to support Amazon SQS FIFO (First-In-First-Out) queues, enabling ordered message delivery and exactly-once processing semantics. This change introduces a new \SqsOptions.FifoQueue\ configuration flag and a dedicated \SQSFIFOSequenceToken\ type to manage sequence ordering for FIFO streams. Additionally, the provider now exposes a \UseDataAdapter\ method on both client and silo stream configurators, allowing users to inject custom implementations of the \ISQSDataAdapter\ interface to handle serialization and message transformation logic.

src/api/AWS/Orleans.Streaming.SQS · high confidence

The API reference files for the Orleans DynamoDB clustering, persistence, and reminder storage providers have been updated to mark AWS access keys, secret keys, and session tokens with the \[Redact\] attribute. This ensures that when configuration options are logged or displayed in generated documentation, these sensitive credential values are automatically masked, preventing accidental exposure of secrets in logs or public API docs.

src/api/AWS/Orleans.Clustering.DynamoDB, src/api/AWS/Orleans.Persistence.DynamoDB, src/api/AWS/Orleans.Reminders.DynamoDB · high confidence

The Orleans.AzureStorage package family (Clustering, GrainDirectory, Reminders, and Transactions) now includes auto-generated API reference stub files (.cs) that expose the public surface area of each provider. These files define the configuration options (e.g., AzureStorageOperationOptions, AzureStoragePolicyOptions), validators, and silo/ client builder extensions (e.g., UseAzureStorageClustering, AddAzureTableGrainDirectory, UseAzureTableReminderService, AddAzureTableTransactionalStateStorage) for Azure Table-based clustering, grain directory, reminders, and transactional state. This improves discoverability and IntelliSense support for configuring Azure Storage backends in Orleans applications.

(repo-wide) · high confidence

This change introduces the generated API reference file (Orleans.Streaming.AzureStorage.cs) for the Azure Storage streaming provider. It exposes the public surface area for configuring Azure Queue streams, including options classes (AzureQueueOptions, AzureBlobLeaseProviderOptions), validators, and configurator extensions for both standard and JSON-based streaming (AddAzureQueueJsonStreams). The JSON streaming APIs are marked as experimental, indicating they are available for testing but may change.

src/api/Azure/Orleans.Streaming.AzureStorage · high confidence

The Orleans.Journaling package now exposes a public API surface for durable state management, introducing the \DurableGrain\ base class and the \IDurableStateManager\ interface. Users can now access durable collections (dictionaries, lists, queues, sets) and persistent state via extension methods on the state manager, such as \GetOrAddDictionary\, \GetOrAddList\, and \GetOrAddPersistentState\. The update also defines the underlying data structures for durable task completion sources, including the \DurableTaskCompletionSourceState\ struct and \DurableTaskCompletionSourceStatus\ enum, along with the command codecs and handlers required to serialize and apply journal operations for these types.

src/api/Orleans.Journaling · high confidence

The public API for the Azure storage persistence providers has been updated to reflect the current implementation. Configuration options for both Azure Blob and Table storage now expose direct properties for service clients (e.g., \BlobServiceClient\, \TableServiceClient\) and their associated options, while the legacy \Configure...Client\ methods are marked as obsolete. The API also includes updated validators for storage options and extension methods for registering these storage providers via DI and silo builders.

src/api/Azure/Orleans.Persistence.AzureStorage · high confidence

The public API surface for the Orleans Event Hubs streaming provider has been updated to expose new configuration options and validators. This includes the \AzureTableStreamCheckpointerOptions\ class with properties for checkpoint persistence intervals, table names, and partition key prefixes, alongside its validator. New options such as \EventHubReceiverOptions\ (exposing \StartFromNow\ and \PrefetchCount\) and \EventHubStreamCachePressureOptions\ allow finer control over receiver behavior and cache pressure monitoring. The entry also reflects updated extension methods in \SiloBuilderExtensions\ and \ClientBuilderExtensions\ for configuring Event Hub streams, including support for custom checkpointer factories and data adapters, ensuring the API contract matches the underlying implementation changes.

src/api/Azure/Orleans.Streaming.EventHubs · high confidence

The Orleans.Reminders API surface has been updated to include cancellation support for reminder operations. Extension methods for GetReminder, GetReminders, RegisterOrUpdateReminder, and UnregisterReminder now accept a System.Threading.CancellationToken parameter, allowing users to cancel these operations. The IRemindable.ReceiveReminder method also supports cancellation tokens. Additionally, the IReminderService interface exposes cancellation-aware versions of its methods, and the ReminderTable interface includes cancellation support for ReadRow, ReadRows, RemoveRow, and UpsertRow operations. The ReminderOptions class defines configuration properties for initialization timeout, minimum period, refresh period, and loading window.

src/api/Orleans.Reminders · high confidence

The repository has been restructured to modernize the developer experience and build pipeline. A new \.editorconfig\ enforces consistent C\# code style and naming conventions across the codebase. The solution is now managed via the new \Orleans.slnx\ format, which organizes source, test, and playground projects into a unified structure. Build and packaging are standardized through \Directory.Build.props\ and \Directory.Build.targets\, which centralize properties such as versioning (set to 10.0.0), nullable reference types, and analyzer settings. Additionally, new documentation files (\CONTRIBUTING.md\, \SUPPORT.md\, \AGENTS.md\) and configuration files (\.gitattributes\, \NuGet.Config\) have been added to guide contributors and streamline local and CI builds.

(repo-wide) · high confidence

The ADO.NET clustering configuration options for both silo and client sides now include a \DataSource\ property of type \DbDataSource\, allowing users to provide a pre-configured data source instead of (or alongside) a connection string. The configuration validators have been updated to enforce that exactly one of \ConnectionString\ or \DataSource\ is provided, ensuring proper setup for database connectivity during clustering operations.

src/AdoNet/Orleans.Clustering.AdoNet/Options · high confidence

The ADO.NET clustering provider has been updated to integrate with the modern Microsoft.Extensions.Hosting model, replacing the legacy SiloHostBuilder with ISiloBuilder and IClientBuilder extension methods (UseAdoNetClustering). This change allows configuration via standard IConfiguration, including support for resolving connection strings by name using the new ConnectionName option. The provider also ships with updated SQL scripts for SQL Server, MySQL, PostgreSQL, and Oracle that include improved conditional-write rollback logic and optional cleanup queries to enhance membership consistency.

src/AdoNet/Orleans.Clustering.AdoNet · high confidence

The AdoNet grain storage provider has been refactored to use a new options-based configuration model. A key behavioral change is that the \HashPicker\ property is now mandatory; the configuration validator will throw an error if no hash picker is explicitly provided. While a default configurator sets a standard hasher when none is configured, users relying on implicit defaults or previous internal wiring must ensure a \HashPicker\ is assigned. Additionally, the options class now supports configuring either a \ConnectionString\ or a \DbDataSource\ (but not both), and introduces a \DeleteStateOnClear\ property to control whether database records are removed when grain state is cleared.

src/AdoNet/Orleans.Persistence.AdoNet/Options · high confidence

The AWS utility layer now resolves the AWS region using the explicit system name (e.g., 'us-west-2') rather than relying on the previous resolution method. This change ensures that region selection is deterministic and aligns with the AWS SDK's standard naming conventions, preventing potential ambiguity in region configuration.

src/AWS/Shared · high confidence

The Azure storage provider for durable jobs now supports the journaled storage catalog. Users can configure Azure Blob and Azure Table storage for durable jobs using the new \UseAzureBlobDurableJobs\ and \UseAzureTableDurableJobs\ extension methods, which accept configuration for \Journaling.AzureBlobJournalStorageOptions\ and \Journaling.AzureTableJournalStorageOptions\ respectively.

src/api/Azure/Orleans.DurableJobs.AzureStorage · high confidence

The SQS streaming provider now supports the standard Microsoft.Extensions.Hosting model, allowing users to configure Amazon SQS-backed persistent streams on both Orleans silos and clients using the new \ISiloBuilder\ and \IClientBuilder\ extension methods (\AddSqsStreams\). This change replaces the legacy silo-hosting pattern, enabling consistent configuration of SQS stream options via \SqsOptions\ or dedicated configurators for both server and client sides.

src/AWS/Orleans.Streaming.SQS/Hosting · high confidence

This change introduces new configuration classes, \AzureStorageClusteringOptions\ and \AzureStorageGatewayOptions\, along with their corresponding validators, to the Orleans Azure Storage clustering provider. These options allow users to explicitly configure the Azure Table Storage table names used for cluster membership (defaulting to \OrleansSiloInstances\) and client gateway discovery, ensuring that required settings are validated before use.

src/Azure/Orleans.Clustering.AzureStorage/Options · high confidence

This change introduces configuration files for 1ES Pipeline Templates, including auto-baselining settings, branch control rules (restricting pipelines 1152 and 1397 to main and 3.x branches), and Guardian security baselines for binskim findings. It also adds TSA options for test asset tracking in the DevDiv ASP.NET Core Orleans area.

.config · high confidence

This update introduces a new 'CleanupDefunctSiloEntriesKey' SQL query for MySQL, Oracle, PostgreSQL, and SQL Server clustering providers, which automatically removes stale silo entries from the OrleansMembershipTable based on deployment ID and heartbeat status. Additionally, a new PostgreSQL 3.6.0 migration script is provided that upgrades timestamp columns to TIMESTAMPTZ(3) and recreates core stored procedures (update\_i\_am\_alive\_time, insert\_membership, update\_membership) to improve reliability and consistency for existing deployments.

src/AdoNet/Orleans.Clustering.AdoNet/Migrations · high confidence

The Orleans.CodeGenerator project now includes internal shim classes (\IsExternalInit\ and \NullableAttributes\) to support nullable reference types and external init capabilities, particularly for older target frameworks like NETSTANDARD2\_0. Additionally, a \launchSettings.json\ file has been added to facilitate debugging the Roslyn source generator component directly against the Orleans.Serialization.UnitTests project.

src/Orleans.CodeGenerator/Properties · high confidence

The Azure Queue stream provider in the Orleans hosting layer has been updated to integrate with the standard Microsoft.Extensions.Hosting model. Users can now configure the provider via \IConfiguration\ sections (reading \QueueNames\, \MessageVisibilityTimeout\, and connection details) using the new \AzureQueueStreamProviderBuilder\, which implements \IProviderBuilder\ for both silos and clients. Additionally, extension methods \AddAzureQueueJsonStreams\ are now available for both \ISiloBuilder\ and \IClientBuilder\, enabling persistent streams with compact JSON serialization (marked as experimental). The silo builder also exposes \UseAzureBlobLeaseProvider\ to configure the underlying lease management.

src/Azure/Orleans.Streaming.AzureStorage/Hosting · high confidence

The Azure Storage hosting extensions have been updated to configure durable jobs using the new journaled storage catalog. Instead of registering legacy storage providers directly, the \UseAzureBlobDurableJobs\ and \UseAzureTableDurableJobs\ extension methods now add the corresponding Azure Blob or Table journal storage and then call \UseJournaledDurableJobs\. This change aligns the Azure storage integration with the broader journaled storage architecture, ensuring that durable jobs leverage the new journaling infrastructure for storage operations.

src/Azure/Orleans.DurableJobs.AzureStorage/Hosting · high confidence

The Azure Blob and Azure Table grain storage providers have been updated to support the modern Microsoft.Extensions.Hosting pattern. Users can now configure these storage providers using standard \IServiceCollection\ extension methods (e.g., \AddAzureBlobGrainStorage\) or via the new \IProviderBuilder\ interface, which allows configuration directly from \IConfiguration\ sections (supporting \ContainerName\, \TableName\, \ConnectionString\, \ConnectionName\, \ServiceKey\, and \SerializerKey\). This replaces or supplements previous registration mechanisms, enabling tighter integration with standard .NET configuration and dependency injection lifecycles.

src/Azure/Orleans.Persistence.AzureStorage/Hosting · high confidence

The Orleans clustering provider for Azure Table Storage has been migrated from the legacy WindowsAzure.Storage library to the modern Azure.Data.Tables SDK. This change updates the underlying storage client used by the membership table and gateway list provider, which may affect how connection strings or TableServiceClient instances are configured and could introduce breaking changes for existing deployments relying on the previous storage stack.

src/Azure/Orleans.Clustering.AzureStorage · high confidence

The Azure Table Storage grain directory can now be registered using the standard Orleans provider configuration model (IProviderBuilder). This allows users to configure the directory via configuration sections by specifying a TableName, a ServiceKey for a keyed TableServiceClient, or a ConnectionName/ConnectionString. The previous extension methods for adding the grain directory remain available, but this new builder enables consistent configuration alignment with other Orleans providers.

src/Azure/Orleans.GrainDirectory.AzureStorage/Hosting · high confidence

The Orleans reminder service for Azure Table Storage has been updated to use the modern Azure.Data.Tables SDK. This change introduces new configuration options via AzureTableReminderStorageOptions, allowing users to specify the reminder table name (defaulting to OrleansReminders). The underlying storage logic now uses the new SDK for table operations, which may affect how reminder entries are stored and retrieved, particularly regarding partition and row key construction and sanitization.

src/Azure/Orleans.Reminders.AzureStorage/Storage · high confidence

The Azure Blob and Table storage providers have been refactored to use the modern options pattern and silo lifecycle integration. Configuration is now handled via \AzureBlobStorageOptions\ and \AzureTableStorageOptions\ classes, which include settings such as \ContainerName\, \TableName\, \DeleteStateOnClear\, and the \GrainStorageSerializer\. The providers implement \ILifecycleParticipant\<ISiloLifecycle\>\ to manage initialization stages, and the blob provider introduces an \IBlobContainerFactory\ to allow customization of container client creation. This change replaces previous configuration methods (now marked obsolete) and aligns the Azure providers with the rest of the Orleans architecture.

src/Azure/Orleans.Persistence.AzureStorage/Providers · high confidence

The Blazor WebAssembly sample has been upgraded to .NET 6, introducing a modernized user interface powered by Bootstrap 5.3.3. This update replaces the previous styling framework and includes new client-side components such as a Todo list application, a weather forecast data-fetching page, and a counter page, all utilizing the new Bootstrap classes and layout structures.

samples/Blazor/BlazorWasm · high confidence

The ChaoticCluster playground has been restructured to use .NET Aspire for orchestration, introducing an AppHost project that manages the silo via distributed application primitives and a ServiceDefaults library that configures OpenTelemetry, health checks, and service discovery. The silo implementation now utilizes the experimental \AddDistributedGrainDirectory\ API to enable strong consistency for the in-memory grain directory, and the host program integrates this with chaos engineering tasks that dynamically scale silo count while applying load.

playground/ChaoticCluster · high confidence

The Orleans code generator's internal model layer has been restructured to support incremental source generation and improved build-time metadata handling. This change introduces a new set of model classes in the \Orleans.CodeGenerator.Model\ namespace, including \FieldDescription\, \PropertyDescription\, \MemberModel\, and \MetadataAggregateModel\, which replace or supplement previous symbol-heavy approaches with value-type representations suitable for pipeline caching. It also adds \GenerateFieldIds\ to control automatic field ID assignment for serialization, and refactors proxy and invokable generation models (\GeneratedInvokableDescription\, \GeneratedProxyDescription\, \InvokableMethodDescription\) to better support stable naming, hot reload, and cancellation-aware RPC contracts. These changes improve build performance and reliability by enabling the generator to detect changes more precisely and avoid unnecessary regeneration.

src/Orleans.CodeGenerator/Model · high confidence

The DynamoDB storage providers now use a new \DynamoDBClientOptions\ class to configure credentials, service location, and AWS profile settings. This change centralizes the configuration of access keys, secret keys, session tokens, and profile names, ensuring that sensitive credential data is marked for redaction in logs. Users benefit from a more structured and secure way to configure DynamoDB connectivity across clustering, persistence, reminders, and transaction storage providers.

src/AWS/Shared/Storage · high confidence

The Orleans DynamoDB clustering provider has been updated to support the modern Microsoft.Extensions.Hosting model. Users can now configure DynamoDB clustering using the standard \UseDynamoDBClustering\ extension methods on \ISiloBuilder\ and \IClientBuilder\, which accept configuration delegates for \DynamoDBClusteringOptions\ and \DynamoDBGatewayOptions\. Additionally, a new \DynamoDBClusteringProviderBuilder\ enables configuration via \IConfigurationSection\, allowing settings like \AccessKey\, \SecretKey\, \Service\ (region/endpoint), \Token\, \ProfileName\, and table throughput options to be read directly from configuration sources. This replaces older patterns and aligns the AWS clustering implementation with the broader Orleans hosting infrastructure.

src/AWS/Orleans.Clustering.DynamoDB · high confidence

The DynamoDB grain storage hosting layer has been refactored to support configuring the storage serializer via a keyed service. Users can now specify a \SerializerKey\ in the configuration section, which allows the provider to resolve a specific \IGrainStorageSerializer\ implementation from the dependency injection container using keyed services, rather than relying on a single default serializer. This change also introduces new extension methods (\AddDynamoDBGrainStorage\ and \AddDynamoDBGrainStorageAsDefault\) for both \IServiceCollection\ and \ISiloBuilder\ that accept an \OptionsBuilder\<DynamoDBStorageOptions\>\ action, providing a more flexible way to configure storage options during silo or service collection setup.

src/AWS/Orleans.Persistence.DynamoDB/Hosting · high confidence

The Event Hubs streaming provider now uses a generalized, configurable Azure Table Storage checkpointer for persistent stream queues. Users can configure checkpoint persistence via the new \UseAzureTableCheckpointer\ extension, which exposes \AzureTableStreamCheckpointerOptions\ to control the \PersistInterval\ (defaulting to 1 minute) and \PartitionKeyPrefix\. The implementation introduces \AzureTableStreamQueueCheckpointer\ and \AzureTableStreamQueueCheckpointerFactory\ to manage checkpoint lifecycle, including throttled saves and offset comparison, replacing the previous hardcoded or less flexible checkpointing mechanism.

src/Azure/Orleans.Streaming.EventHubs/Providers/Streams/EventHub · high confidence

The Azure Table Storage provider now includes specific exception handling for update condition failures, introducing a new \TableStorageUpdateConditionNotSatisfiedException\ that provides detailed context such as grain type, grain ID, table name, and ETag values to help diagnose inconsistent states. Additionally, a new \StorageExceptionExtensions\ class adds helper methods to easily identify specific Azure Blob Storage error conditions, including container not found, blob not found, precondition failures, and conflicts, enabling more precise error management for users.

src/Azure/Orleans.Persistence.AzureStorage/Storage · high confidence

The code generator now produces stable, hash-based names for generated private fields, which prevents .NET Hot Reload from incorrectly treating field additions as renames or type changes. Additionally, new utility classes for F\# serialization have been added to correctly identify and handle F\# discriminated unions and records, while helper utilities for identifier sanitization and syntax generation have been introduced to ensure generated code is valid and robust.

src/Orleans.CodeGenerator/SyntaxGeneration · high confidence

The signing workflow now utilizes a new, isolated build structure within the \sign/\ directory. This includes a \NuGet.Config\ that restricts package sources to internal .NET feeds (dotnet-eng, dotnet-public) with specific mappings, a \Sign.proj\ MSBuild project that imports the Microsoft.DotNet.SignTool (version 6.0.0-beta.20630.2) and defines the signing target, and a \Sign.props\ file that configures default signing behaviors, certificate mappings (e.g., Microsoft400, NuGet), and file extension rules. This change centralizes the signing configuration and dependencies, separating them from the main repository build logic.

sign · high confidence

A new \ErrorCode\ enum has been added to the shared utilities to define specific error codes for Azure Table operations. This enum is conditionally compiled into various namespaces (such as clustering, persistence, reminders, and streaming) based on preprocessor directives, allowing different Orleans components to report distinct Azure Table-related errors without namespace collisions.

src/Azure/Shared/Utilities · high confidence

The Orleans Azure storage utilities now define dedicated internal enumerations for error codes: \TableStorageErrorCode\ for clustering operations and \AzureReminderErrorCode\ for reminder operations. These enums map specific Azure Table Storage HTTP status codes (such as 20, 21, 22, 32, 38, 40, etc.) to distinct internal error identifiers, enabling more precise error handling and reporting for these specific storage interactions.

src/Azure/Orleans.Clustering.AzureStorage/Utilities, src/Azure/Orleans.Reminders.AzureStorage/Utilities · high confidence

The public API for the in-memory grain storage provider has been updated to include cancellation token support in state operations (ReadStateAsync, WriteStateAsync, ClearStateAsync) and to expose configuration validation via MemoryGrainStorageOptionsValidator. The API also clarifies the IDisposable contract for storage implementations and exposes factory methods for creating storage instances.

src/api/Orleans.Persistence.Memory · high confidence

The memory grain storage provider has been refactored to use a new builder-based configuration model (MemoryGrainStorageProviderBuilder) and extension methods, allowing configuration via Microsoft.Extensions.Configuration and keyed services for custom IGrainStorageSerializer implementations. The underlying storage implementation now supports cancellation tokens for read, write, and clear operations, and includes stricter validation for options such as NumStorageGrains and InitStage. A new latency-mocking variant (MemoryGrainStorageWithLatency) is also available for testing scenarios.

src/Orleans.Persistence.Memory · high confidence

The Azure Table Storage implementation has been updated to use the modern Azure.Data.Tables SDK, replacing the legacy WindowsAzure.Storage and Microsoft.Azure.Cosmos.Table libraries. This change introduces new configuration classes (AzureStorageOperationOptions, AzureStoragePolicyOptions) that allow users to explicitly control retry behavior (max retries, delays) and timeouts for table operations, moving away from the previous hardcoded defaults. Additionally, validation logic for container and table names has been centralized, and the API for configuring the TableServiceClient has been simplified to prefer direct property assignment over obsolete configuration methods.

src/Azure/Shared/Storage · high confidence

The Orleans Transactions TestKit has been migrated from the previous test framework to xUnit v3. This change updates the test runner implementations (such as GoldenPath, Consistency, and FaultInjection runners) to use xUnit v3 attributes and APIs, ensuring compatibility with the latest xUnit version and leveraging its improved test execution model.

src/Orleans.Transactions.TestKit.xUnit · high confidence

The Azure Storage streaming provider now includes a dedicated \AzureBlobLeaseProviderOptions\ class and a corresponding validator. This allows users to configure the Azure Blob Service client used for managing lease blobs directly via the \BlobServiceClient\ property or by providing a client creation callback, replacing the previous pattern of configuring client options separately. The validator ensures that a client is properly configured and that the specified blob container name is valid before the provider starts.

src/Azure/Orleans.Streaming.AzureStorage/Options · high confidence

The Azure queue streaming provider now uses the modern Azure SDK (Azure.Storage.Queues) instead of the legacy WindowsAzure.Storage library. This change introduces a new \AzureQueueDataManager\ class that handles queue operations, including a fix to ignore 404 errors when clearing queues and logic to sanitize queue names. It also adds specific error codes in \AzureQueueErrorCode\ to better identify and report storage-related issues.

src/Azure/Orleans.Streaming.AzureStorage/Storage · high confidence

The DynamoDB clustering provider now exposes dedicated configuration classes—DynamoDBClusteringOptions, DynamoDBClusteringSiloOptions, and DynamoDBGatewayOptions—to manage silo membership and gateway discovery settings. Users can now explicitly configure DynamoDB table properties such as ReadCapacityUnits, WriteCapacityUnits, and the UseProvisionedThroughput flag, as well as control table lifecycle with CreateIfNotExists and UpdateIfExists. The silo-specific options allow setting a ConnectionString for the DynamoDB storage, while gateway options mirror the clustering settings to configure the table used for gateway discovery.

src/AWS/Orleans.Clustering.DynamoDB/Options · high confidence

The DynamoDB grain storage provider now exposes a dedicated \DynamoDBStorageOptions\ class that consolidates configuration settings such as table name, provisioned throughput limits, TTL, and serializer selection. This change introduces explicit validation logic that enforces non-zero read and write capacity units when provisioned throughput is enabled, ensuring that misconfigurations are caught early during silo initialization rather than at runtime.

src/AWS/Orleans.Persistence.DynamoDB/Options · high confidence

The Orleans Event Hubs streaming provider now exposes new extension methods on ISiloBuilder and IClientBuilder (AddEventHubStreams) to configure stream providers using the standard Microsoft.Extensions.Hosting model. This replaces previous configuration patterns, allowing users to register the provider via builder extensions that accept configuration delegates, while the underlying EventHubsStreamProviderBuilder handles the actual wiring from configuration sections.

src/Azure/Orleans.Streaming.EventHubs/Hosting · high confidence

The Orleans source generator now includes a comprehensive set of new diagnostics (ORLEANS0101–ORLEANS0113) to catch usage errors early, such as invalid RPC return types, properties in RPC interfaces, and incorrect CancellationToken placement. It also adds support for stable field naming and hot reload, allowing generated serializers and copiers to support adding members during .NET Hot Reload sessions without breaking compatibility.

src/Orleans.CodeGenerator · high confidence

The Orleans Dashboard frontend application has been rebuilt using Vite and React 18, replacing the previous Browserify and React 15 stack. This migration improves build performance and development experience with Hot Module Replacement, updates Chart.js to v4, and switches the module system to ESM. The new setup includes a Vite configuration for bundling, TypeScript support, ESLint flat configuration, and an HTML entry point that injects the bundled assets into the dashboard UI.

src/Dashboard/Orleans.Dashboard.App · high confidence

The Orleans.Runtime API surface has been updated to reflect recent internal changes. This includes new host builder extension methods (UseOrleans) for IHostApplicationBuilder and IHostBuilder, allowing for more flexible silo configuration in modern .NET hosting models. Configuration options for activation rebalancing and repartitioning are now explicitly exposed, including settings for entropy deviation, cycle periods, and edge counts. Additionally, the ClusterManifestOptions now expose EnableContentAddressedRetrieval, and GrainDirectoryOptions include deprecated TTL-related properties marked for removal, signaling a shift in cache management strategies.

src/api/Orleans.Runtime · high confidence

The Orleans.Transactions public API surface has been updated to reflect the current state of the library's interfaces, attributes, and configuration options. This includes the definition of the ITransactionClient interface for running transactions, the TransactionAttribute and UseExclusiveLockAttribute for marking grain methods, and the TransactionRequest/TransactionResponse classes for handling transactional RPC calls. Additionally, the TransactionalStateOptions class exposes configuration settings such as lock timeouts, retry limits, and ping frequencies, while the ClientBuilderExtensions provides the UseTransactions method to enable transaction support in client applications.

src/api/Orleans.Core, src/api/Orleans.Transactions · high confidence

A new SQL migration script (PostgreSQL-Persistence-3.6.0.sql) is provided to upgrade existing PostgreSQL storage tables and routines for deployments created before version 3.6.0. This migration alters the \OrleansStorage\ table to change the \modifiedon\ column type to \TIMESTAMPTZ\ (converting existing data to UTC) and recreates the \writetostorage\ function to handle grain state updates and inserts with proper versioning and locking logic.

src/AdoNet/Orleans.Persistence.AdoNet/Migrations · high confidence

A new migration script is provided for PostgreSQL deployments upgrading to version 3.6.0. This migration alters the \OrleansRemindersTable\ to change the \StartTime\ column type to \TIMESTAMPTZ(3)\ with UTC conversion, and recreates the \upsert\_reminder\_row\ function to support the updated schema and conflict resolution logic.

src/AdoNet/Orleans.Reminders.AdoNet/Migrations · high confidence

The public API surface for Orleans.Serialization.Abstractions has been updated to reflect recent changes in the serialization library. This includes new attributes and interfaces such as GenerateFieldIds, GenerateMethodSerializersAttribute, and InvokableCustomInitializerAttribute, alongside updates to existing attributes like GenerateSerializerAttribute and InvokableBaseTypeAttribute. The OrleansConstructorAttribute is now marked as obsolete in favor of GeneratedActivatorConstructorAttribute. These changes affect how types are serialized, how field IDs are generated, and how custom initializers and converters are registered within the Orleans serialization framework.

src/api/Orleans.Core.Abstractions, src/api/Orleans.Serialization.Abstractions, src/api/Orleans.Transactions.TestKit.xUnit · high confidence

The Orleans.TestingHost public API has been updated to include new fault injection storage capabilities, allowing users to configure memory storage with simulated latency and failures via \AddFaultInjectionMemoryStorage\ and \FaultInjectionGrainStorageOptions\. The \InProcessTestCluster\ and \InProcessSiloHandle\ classes now expose additional lifecycle management methods such as \MigrateAsync\, \RestartStoppedSecondarySiloAsync\, and \WaitForClusterManifestToStabilizeAsync\, enhancing control over test silo behavior and cluster stability verification during integration tests.

src/api/Orleans.TestingHost · high confidence

The Orleans Redis clustering and grain directory packages have updated their public API definitions to reflect changes in how Redis connection multiplexers are managed. The \RedisClusteringOptions\ and \RedisGrainDirectoryOptions\ classes now expose a \CreateMultiplexer\ function signature that returns a tuple containing the \IConnectionMultiplexer\ and a boolean \IsShared\ flag, allowing users to explicitly control whether the created connection is shared across components. This aligns with the underlying fix for multiplexer ownership, ensuring that lifecycle management of the Redis connection is handled correctly within the silo or client context.

src/api/Redis/Orleans.Clustering.Redis, src/api/Redis/Orleans.GrainDirectory.Redis · medium confidence

The public API for the Redis streaming provider has been updated to expose new configuration options. Users can now configure \CheckpointPersistInterval\, \EntryExpiry\, and \MaxStreamLength\ via \RedisStreamingOptions\, and customize receiver behavior with \FieldName\ and \ReadCount\ in \RedisStreamReceiverOptions\. The extension methods for \IClientBuilder\ and \SiloBuilder\ now expose \RedisStreamingOptions\ builders and specific configurators for partitioning, caching, and receiver settings, allowing finer control over Redis stream persistence and performance.

src/api/Redis/Orleans.Streaming.Redis · high confidence

The Voting sample application has been rewritten to use ASP.NET Core Blazor Server for the UI, replacing the previous Angular-based MVC implementation. The backend now leverages Orleans grains (PollGrain, VoteGrain, UserAgentGrain) for state management and real-time updates via the IPollWatcher observer pattern. A new UserAgentGrain enforces misuse prevention by throttling request rates and blocking double-voting, while the PollService handles client-side polling subscriptions and the DemoService allows simulating concurrent voters.

samples/Voting · high confidence

The configuration classes for ZooKeeper clustering, specifically ZooKeeperClusteringSiloOptions and ZooKeeperGatewayListProviderOptions, have been relocated to the Orleans.Configuration namespace. This change aligns the ZooKeeper membership provider with the broader Orleans configuration structure, ensuring that silo and gateway connection string settings are consistently organized within the central configuration namespace.

src/Orleans.Clustering.ZooKeeper/Options · high confidence

The Orleans.Clustering.ZooKeeper package has been completely rewritten to support Microsoft.Extensions.Hosting and typed options (ZooKeeperClusteringSiloOptions, ZooKeeperGatewayListProviderOptions). Membership reads are now sequential and resilient, using Polly to retry transient ZooKeeper connection losses and fencing version checks to preserve consistency. The provider now uses Newtonsoft.Json with custom converters for serializing membership data, and includes a new gateway list provider for client-side discovery.

src/Orleans.Clustering.ZooKeeper · high confidence

Added a new \Benchmarks.AdoNet\ project that measures the performance of the ADO.NET streaming provider, specifically focusing on message queueing and dequeueing under varying concurrency levels (1, 4, 8 queues) and larger payload sizes (up to 100KB).

test · high confidence

The project now uses a centralized package version management file (Directory.Packages.props) to define versions for all NuGet packages, including major updates to the .NET ecosystem (targeting net10.0) and Azure SDKs. Additionally, the documentation site dependencies have been updated, with Astro upgraded to 7.2.10, Mermaid to 11.16.1, and Sharp to 0.35.4, ensuring the documentation build environment is current.

(dependencies) · high confidence

Daily generation of API reference files; Generated API reference files for Kubernetes hosting and serialization codecs; Orleans API surface area updated for new release.

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

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

• Code Health 65 → 69 (+3.4)
• Architecture 78 → 79 (+0.3)
• Maturity 76 → 70 (-5.9)
• Readiness 54 → 66 (+12.3)
• Security 46 → 55 (+9.2)
• Accessibility 45 → 45 (+0.2)
• Performance 65 → 64 (-1.2)

• ActivationCollector.ScanAll (cognitive 19) (src/Orleans.Runtime/Catalog/ActivationCollector.cs)
• ArrayCodec.ReadValue (cognitive 17) (src/Orleans.Serialization/Codecs/ArrayCodec.cs)
• ArraySegmentCodec.ReadValue (cognitive 16) (src/Orleans.Serialization/Codecs/ArrayCodec.cs)
• AzureTableTransactionalStateStorage.Store (cognitive 28) (src/Azure/Orleans.Transactions.AzureStorage/TransactionalState/AzureTableTransactionalStateStorage.cs)
• AzureTableTransactionalStateStorage.Store (cyclomatic 19) (src/Azure/Orleans.Transactions.AzureStorage/TransactionalState/AzureTableTransactionalStateStorage.cs)
• Banned license: MySql.Data
• BarePragmaDisable (test/Extensions/Orleans.Azure.Tests/Streaming/DelayedQueueRebalancingTests.cs)
• BarePragmaDisable (test/Orleans.Core.Tests/DurableJobs/LocalDurableJobManagerTests.cs)
• BarePragmaDisable (test/Orleans.GrainDirectory.Tests/GrainDirectory/GrainDirectoryOptionsTests.cs)
• BarePragmaDisable (test/Orleans.GrainDirectory.Tests/GrainDirectory/GrainDirectoryRollingUpgradeTests.cs)
• BarePragmaDisable (test/Orleans.GrainDirectory.Tests/GrainDirectory/GrainDirectoryRollingUpgradeTests.cs)
• BarePragmaDisable (test/Orleans.GrainDirectory.Tests/GrainDirectory/GrainDirectoryShutdownMigrationTests.cs)
• BarePragmaDisable (test/Orleans.Serialization.UnitTests/ISerializableTests.cs)
• BarePragmaDisable (test/Orleans.Serialization.UnitTests/ISerializableTests.cs)
• BareSuppressMessage (src/Orleans.Core/Async/AsyncLock.cs)
• BareSuppressMessage repeated 15 times in 7 files (src/AdoNet/Orleans.GrainDirectory.AdoNet/GlobalSuppressions.cs)
• Boundary-crossing change coupling: ISerializableTypeDescription.cs ↔ Annotations.cs (src/Orleans.CodeGenerator/Model/ISerializableTypeDescription.cs)
• Bounded contexts not declared
• Build status unknown
• Change coupling: ClusterMembershipService.cs ↔ MembershipTableManager.cs (src/Orleans.Runtime/MembershipService/ClusterMembershipService.cs)
• …and 195 more

• ActivationCollector.DeactivateInDueTimeOrder (cognitive 18) (src/Orleans.Runtime/Catalog/ActivationCollector.cs)
• ActivationCollector.TryRescheduleCollection (cognitive 16) (src/Orleans.Runtime/Catalog/ActivationCollector.cs)
• AzureBlobJournalStorageProvider.ListAsync (cognitive 22) (src/Azure/Orleans.Journaling.AzureStorage/AzureBlobJournalStorageProvider.cs)
• AzureQueueJsonDataAdapter.RemoveUnreferencedIds (cognitive 29) (src/Azure/Orleans.Streaming.AzureStorage/Providers/Streams/AzureQueue/IAzureQueueDataAdapter.cs)
• AzureQueueJsonDataAdapter.RemoveUnreferencedIds (cyclomatic 16) (src/Azure/Orleans.Streaming.AzureStorage/Providers/Streams/AzureQueue/IAzureQueueDataAdapter.cs)
• AzureTableJournalStorageProvider.GetCatalogFilter (cognitive 23) (src/Azure/Orleans.Journaling.AzureStorage/AzureTableJournalStorageProvider.cs)
• AzureTableJournalStorageProvider.ListAsync (cognitive 17) (src/Azure/Orleans.Journaling.AzureStorage/AzureTableJournalStorageProvider.cs)
• AzureTableTransactionalStateStorage.StoreCore (cognitive 27) (src/Azure/Orleans.Transactions.AzureStorage/TransactionalState/AzureTableTransactionalStateStorage.cs)
• AzureTableTransactionalStateStorage.StoreCore (cyclomatic 18) (src/Azure/Orleans.Transactions.AzureStorage/TransactionalState/AzureTableTransactionalStateStorage.cs)
• BarePragmaDisable (test/Orleans.Connections.Security.Tests/CertificateCreator.cs)
• BarePragmaDisable (test/Orleans.Runtime.Internal.Tests/DependencyInjection/GenericRegistrationTests.cs)
• BarePragmaDisable (test/Orleans.Runtime.Internal.Tests/DependencyInjection/GenericRegistrationTests.cs)
• BarePragmaDisable repeated 13 times in 8 files (src/Orleans.TestingHost/InProcTestCluster.cs)
• BareSuppressMessage repeated 13 times in 6 files (src/Azure/Orleans.Clustering.AzureStorage/Utilities/TableStorageErrorCode.cs)
• BatchOperation.Flush (cyclomatic 23) (src/Azure/Orleans.Transactions.AzureStorage/TransactionalState/AzureTableTransactionalStateStorage.cs)
• CassandraClusteringTable.ReadConsistentAsync (cognitive 16) (src/Cassandra/Orleans.Clustering.Cassandra/CassandraClusteringTable.cs)
• Catalog.GetOrCreateActivation (cognitive 18) (src/Orleans.Runtime/Catalog/Catalog.cs)
• Change coupling: ConsistentRingProvider.cs ↔ VirtualBucketsRingProvider.cs (src/Orleans.Runtime/ConsistentRing/ConsistentRingProvider.cs)
• Change coupling: MembershipAgent.cs ↔ MembershipTableManager.cs (src/Orleans.Runtime/MembershipService/MembershipAgent.cs)
• Change coupling: MembershipSystemTarget.cs ↔ SiloHealthMonitor.cs (src/Orleans.Runtime/MembershipService/MembershipSystemTarget.cs)
• …and 1359 more

• 300 commits — 146 feature/other, 154 fixes

• docs/site — 28 commits
• test/Extensions — 21 commits
• src/Azure — 19 commits
• src/Orleans.Streaming — 17 commits
• src/Orleans.Runtime — 15 commits
• (root) — 14 commits
• src/Orleans.Core — 12 commits
• .github/scripts — 9 commits
• .github/actions — 8 commits
• .github/workflows — 8 commits
• src/AWS — 8 commits
• src/Orleans.TestingHost — 8 commits
• src/Orleans.Serialization — 7 commits
• test/Orleans.Reminders.TestKit.Tests — 7 commits
• test/Orleans.Reminders.Tests — 7 commits
• src/Dashboard — 6 commits
• test/Orleans.Analyzers.Tests — 6 commits
• test/Orleans.Core.Tests — 6 commits
• src/Orleans.DurableJobs — 5 commits
• src/Orleans.Reminders.TestKit — 5 commits

• fix: ci: fix invalid cfs-npm Dependabot registry configuration (#11079)
• fix: fix(adonet): add missing CleanupDefunctSiloEntriesKey to Oracle clustering (#11246)
• fix: fix(adonet): align PostgreSQL persistence script with its migration (#11247)
• fix: fix(adonet): normalize integer reads (#11283)
• fix: fix(adonet): preserve membership consistency (#11317)
• fix: fix(adonet): return scalar SQLite persistence versions (#11322)
• fix: fix(analyzers): clarify Orleans contract identities (#10910)
• fix: fix(analyzers): create missing Orleans contract manifests (#10915)
• fix: fix(analyzers): enforce CA1062 for Cosmos and S3 (#11171)
• fix: fix(analyzers): enforce disposable field ownership (#11167)
• fix: fix(analyzers): enforce ordinal string comparisons (#11150)
• fix: fix(analyzers): expand CA1062 library coverage (#11160)
• fix: fix(analyzers): expand CA1062 provider coverage (#11157)
• fix: fix(analyzers): validate transaction test kit inputs (#11161)
• fix: fix(aws): bind DynamoDB token and profile options (#11290)
• fix: fix(aws): honor DynamoDB endpoint credentials (#11292)
• fix: fix(aws): preserve DynamoDB membership consistency (#11310)
• fix: fix(aws): redact DynamoDB tokens (#11288)
• fix: fix(aws): use invariant DynamoDB clustering text (#11051)
• fix: fix(aws): use invariant DynamoDB state serialization (#11056)
• …and 280 more

• 4 added · 1 removed (a removed endpoint is potentially breaking)

• GET /health/live
• GET /health/ready
• GET /health/startup
• GET /hello/{name}

• GET /health

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

dotnet/orleans 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.