BEagle1984/silverback

Silverback is a .NET messaging integration library that facilitates communication with Apache Kafka and MQTT brokers. It provides a structured framework for publishing and consuming messages, supporting patterns like CQRS, domain events, and reactive streams. The system ensures reliable delivery through transactional outbox storage, distributed locking, and configurable error handling, while offering extensive testing utilities and observability features.

104 changes.

This period established the foundational architecture for Silverback 5.5.3 on .NET 10, introducing a composable behavior pipeline, domain event publishing, and Reactive Extensions support. It significantly expanded integration capabilities by adding MQTT support, Kafka Schema Registry serialization, and robust batch and chunking mechanisms for message sequences. The work also prioritized observability and reliability through OpenTelemetry tracing, health checks, and comprehensive end-to-end testing infrastructure.

63 changes.

This period focused on restructuring the core configuration API using a fluent builder pattern and immutable records for both Kafka and MQTT integrations. It introduced significant new capabilities including a transactional outbox pattern, distributed locking abstractions, and client-side offset stores to ensure reliable message delivery. The work was heavily supported by comprehensive testing infrastructure, including in-memory mocks for brokers and storage, alongside extensive unit and end-to-end test coverage for the new logging and validation systems.

52 changes.

This period focused on expanding Silverback's storage capabilities by introducing PostgreSQL and Entity Framework providers for Kafka offsets, outbox, and distributed locks, alongside a generic relational data access layer. Significant enhancements were made to transactional messaging, including Kafka transaction support with per-partition isolation and a structured application publisher for commands, queries, and events. The work was supported by extensive integration testing, benchmarking infrastructure, and a rewritten WPF test bench for validation.

Users can now register the enhanced IApplicationPublisher service via the SilverbackBuilder configuration. This extension method adds transient dependencies for IApplicationPublisher and ApplicationPublisher, enabling the publishing of ICommand, ICommand\<TResult\>, IQuery\<TResult\>, and IEvent messages through the configured builder.

src/Silverback.Core.Model/Configuration · high confidence

Users can now apply the new ConsumerNameFilterAttribute to subscribed methods to filter incoming messages based on the consumer group name. This allows applications with multiple consumers subscribed to the same topic to selectively process messages only from specific consumer groups, improving control over message handling in distributed scenarios.

src/Silverback.Integration/Messaging/Subscribers · high confidence

The Kafka integration now exposes detailed broker statistics via a new set of data models in the \Silverback.Messaging.Broker.Callbacks.Statistics\ namespace. This includes \KafkaStatistics\ as the root event, along with supporting types for \BrokerStatistics\, \ConsumerGroupStatistics\, \ExactlyOnceSemanticsStatistics\, \PartitionStatistics\, \TopicStatistics\, \TopicPartitions\, and \WindowStatistics\. A \KafkaStatisticsDeserializer\ is provided to parse raw JSON statistics from the underlying librdkafka client into these strongly-typed objects, enabling users to access granular metrics such as throughput, latency percentiles, and consumer group state.

src/Silverback.Integration.Kafka/Messaging/Broker/Callbacks/Statistics · high confidence

Users can now apply the new KafkaGroupIdFilterAttribute to subscribed methods to filter incoming messages based on the Kafka consumer group ID that consumed them. This enables scenarios where multiple consumer groups for the same topic run within the same process, allowing selective processing of messages from specific groups.

src/Silverback.Integration.Kafka/Messaging/Subscribers · high confidence

Added new sample applications in the MQTT samples directory to demonstrate Silverback's MQTT integration. The 'Basic' samples include producer and consumer projects for both MQTT v3 (V310) and v5, showing how to configure broker clients, publish messages, and handle subscriptions with last will messages. Additionally, 'BinaryFileStreaming' samples demonstrate how to stream binary files over MQTT using chunked transfers, including a custom binary message type with headers and a controller-based producer.

samples/MQTT · high confidence

Users can now integrate MQTT as a message broker by calling the new \AddMqtt\ extension on \BrokerOptionsBuilder\ to register the necessary MQTT client services, and using \AddMqttClients\ on \BrokerClientsConfigurationBuilder\ to explicitly configure MQTT connection endpoints and their associated inbound/outbound message handling.

src/Silverback.Integration.MQTT/Messaging/Configuration · high confidence

A new MqttClientIdFilterAttribute is now available for MQTT subscribers, allowing methods to filter incoming messages based on the specific client ID that consumed them. This enables scenarios where multiple clients subscribe to the same topic within the same process, letting developers selectively process messages only from designated clients.

src/Silverback.Integration.MQTT/Messaging/Subscribers · high confidence

The SQLite storage provider now includes a dedicated \SqliteDataAccess\ class that manages SQLite connections, transactions, and parameters. This implementation allows the outbox and message storage mechanisms to interact directly with SQLite databases using the \Microsoft.Data.Sqlite\ library, enabling users to persist message broker data in SQLite.

src/Silverback.Storage.Sqlite/Storage/DataAccess · high confidence

An internal UnboundedSequence class has been introduced to manage message streams that do not belong to a specific sequence. This component allows the messaging broker to correctly process and handle messages that are pushed without being part of a bounded or chunked sequence structure.

src/Silverback.Integration/Messaging/Sequences/Unbounded · high confidence

Introduces a new batch sequence mechanism that groups incoming messages into configurable batches for processing. Users can now enable this feature by configuring the Batch settings on an endpoint, specifying the batch Size (number of messages to group) and MaxWaitTime (maximum duration to wait for the batch to fill). The implementation includes BatchSequence, BatchSequenceReader, and BatchSettings classes to handle sequence creation, timeout completion, and validation, allowing for more efficient processing of unrelated messages in groups.

src/Silverback.Integration/Messaging/Sequences/Batch · high confidence

The library now includes a validation pipeline that checks messages against Data Annotations attributes before they are produced or after they are consumed. Users can configure the validation mode per endpoint to either log a warning for invalid messages or throw a MessageValidationException, with support for recursively validating nested objects and collections.

src/Silverback.Integration/Messaging/Validation · high confidence

The MQTT testing module now exposes a configuration option to introduce a delay before establishing a connection in mocked scenarios. This is implemented via new \IMockedMqttOptions\ and \IMockedMqttOptionsBuilder\ interfaces, along with their internal implementations (\MockedMqttOptions\ and \MockedMqttOptionsBuilder\). Users can now use the \DelayConnection\ method on the mocked MQTT options builder to specify a \TimeSpan\ delay, which defaults to 10 milliseconds if not set, allowing for more realistic testing of connection timing behaviors.

src/Silverback.Integration.MQTT.Testing/Messaging/Configuration/Mqtt · high confidence

New health check services have been added to monitor the status of message consumers and the transactional outbox. The ConsumersHealthCheckService identifies disconnected consumers based on a minimum status threshold and a configurable grace period, while the OutboxHealthCheckService validates that outbox messages are being processed within acceptable age and queue length limits.

src/Silverback.Integration/Messaging/HealthChecks · high confidence

Introduces the DbOutboxMessage class to represent messages stored in the relational outbox, including fields for the database record ID, message content, headers, and endpoint name.

src/Silverback.Storage.Relational/Messaging/Producing · high confidence

This change introduces new health check capabilities for the Silverback integration layer. The \ConsumersHealthCheck\ verifies that all message consumers are connected, allowing configuration of a minimum healthy status and a grace period to observe after status changes before marking a consumer as unhealthy. The \OutboxHealthCheck\ monitors the outbox to ensure messages are being processed, failing if messages exceed a configured maximum age or if the queue length exceeds a specified limit. These checks are registered via extension methods on \IHealthChecksBuilder\ (\AddConsumersCheck\ and \AddOutboxCheck\), making them easily integrable into standard .NET health check infrastructure.

src/Silverback.Integration.HealthChecks · high confidence

Users can now store Kafka consumer offsets in memory rather than relying on persistent storage. This change introduces the InMemoryKafkaOffsetStore and its associated settings, allowing for stateless offset management suitable for development or scenarios where offset persistence is not required.

src/Silverback.Storage.Memory/Messaging/Consuming · high confidence

The Silverback.Storage.Memory package now exposes fluent configuration builders for in-memory Kafka offset stores and transactional outboxes. Users can configure these via the new \UseMemory()\ extension methods on \KafkaOffsetStoreSettingsBuilder\ and \OutboxSettingsBuilder\, or directly on the \BrokerOptionsBuilder\ using \UseInMemoryKafkaOffsetStore()\ and \UseInMemoryOutbox()\. These methods register in-memory implementations suitable for testing, allowing developers to replace persistent storage backends with lightweight, in-memory alternatives without changing their broker connection setup.

src/Silverback.Storage.Memory/Messaging/Configuration · high confidence

The Silverback.Storage.Memory package now includes an in-memory implementation of the distributed lock abstraction. This allows applications to use the same locking API during development and testing without requiring an external database or distributed system, providing a lightweight, non-persistent lock backed by a SemaphoreSlim.

src/Silverback.Storage.Memory/Lock · high confidence

The \BrokerOptionsBuilderKafkaTestingExtensions\ class now provides \AddMockedKafka\ and \AddMockedConfluentSchemaRegistry\ extension methods. These allow developers to replace real Apache Kafka and Confluent Schema Registry connectivity with mocked, in-memory implementations during testing, enabling integration tests to run without external infrastructure dependencies.

src/Silverback.Integration.Kafka.Testing/Messaging/Configuration · high confidence

This location introduces the configuration builders and extension methods that enable Silverback to serialize and deserialize Kafka messages using the Confluent Schema Registry. Users can now configure consumer and producer endpoints to use Avro, JSON, or Protobuf formats via new fluent methods (e.g., DeserializeAvro, SerializeAsJsonUsingSchemaRegistry), with dedicated builders for each format that allow fine-grained configuration of deserializer/serializer settings and schema registry client options.

src/Silverback.Integration.Kafka.SchemaRegistry/Messaging/Configuration · high confidence

A new extension method, AddMockedMqtt, is now available on BrokerOptionsBuilder to facilitate testing. When invoked, it registers the standard MQTT broker but replaces the actual network connectivity with a mocked, in-memory message broker that replicates MQTT behavior, allowing developers to test MQTT integration without a live broker.

src/Silverback.Integration.MQTT.Testing/Messaging/Configuration · high confidence

A new internal ComparisonHelper utility has been added to the Silverback.Util namespace, providing a JsonEquals method that determines object equality by comparing their serialized JSON representations using System.Text.Json with a configured maximum depth of 1000.

src/Silverback.Integration/Util · high confidence

Developers testing Kafka integrations can now use new extension methods on InboundEnvelopeBuilder to configure message metadata directly. The new InboundEnvelopeBuilderExtensions class provides WithKafkaOffset, WithKafkaKey, WithKafkaTimestamp, and WithKafkaTopic methods, allowing test setups to specify the Kafka topic, partition, offset, message key, and timestamp without manually manipulating headers or endpoints.

src/Silverback.Integration.Kafka.Testing/Messaging/Messages · high confidence

New outbound header enrichers have been added to support MQTT 5 request-response patterns. The CorrelationDataOutboundHeadersEnricher now sets the correlation data header on outgoing messages, and the ResponseTopicOutboundHeadersEnricher sets the response topic header, enabling proper request-response communication flows.

src/Silverback.Integration.MQTT/Messaging/Producing/Enrichers · high confidence

Developers testing MQTT integrations can now use new extension methods on InboundEnvelopeBuilder to configure MQTT-specific metadata. The WithMqttTopic method allows setting the source topic of a consumed message, while WithMqttCorrelationData enables attaching correlation data headers, simplifying the setup of realistic inbound message scenarios in tests.

src/Silverback.Integration.MQTT.Testing/Messaging/Messages · high confidence

Developers can now replace the real MQTT broker with a mocked in-memory implementation by calling the new UseMockedMqtt extension method on the SilverbackBuilder. This method swaps the underlying MQTT client factory and registers an in-memory broker and testing helper, allowing applications to be tested without requiring an external MQTT server.

src/Silverback.Integration.MQTT.Testing/Configuration · high confidence

A new benchmark project (V462Benchmark) has been added to measure the performance of Silverback's messaging infrastructure. This suite includes benchmarks for the mediator pattern (testing publish operations with single and multiple sync/async subscribers) and Kafka producer throughput (publishing 1,000 events). The benchmarks utilize BenchmarkDotNet and configure a hosted environment with Silverback's DI integration to provide realistic performance data for message publishing and handling.

benchmarks/V462Benchmark · high confidence

A new utility class, ObservableTypeParameterExtensions, has been added to the Silverback.Core.Rx library. This addition provides an extension method that allows filtering an IObservable sequence by a specific Type object at runtime, rather than requiring a generic type parameter. This enables dynamic type checking and filtering for observable streams where the target type is determined during execution.

src/Silverback.Core.Rx/Util · high confidence

The Silverback.Storage.Memory package now exposes extension methods on the SilverbackBuilder to configure an in-memory distributed lock implementation. Users can call UseInMemoryLock to replace all distributed locks with an in-memory version suitable for testing, or AddInMemoryLock to register the in-memory lock factory without overriding existing configurations.

src/Silverback.Storage.Memory/Configuration · high confidence

The testing configuration now includes extension methods to replace real Kafka connectivity and Confluent Schema Registry with in-memory mocks. Users can call \UseMockedKafka\ to swap out the Confluent.Kafka client implementations (producer, consumer, admin client) with mocked versions that replicate Kafka behavior, and \UseMockedConfluentSchemaRegistry\ to mock the schema registry client. This allows tests to run without requiring a live Kafka cluster or schema registry service.

src/Silverback.Integration.Kafka.Testing/Configuration · high confidence

The Silverback builder now supports an \AddIntegrationSpy\ extension method, allowing users to inject an \IIntegrationSpy\ service for monitoring inbound and outbound messages during integration tests. This method registers specific broker behaviors (\OutboundSpyBrokerBehavior\, \RawOutboundSpyBrokerBehavior\, and either \InboundSpyBrokerBehavior\ or \InboundSpySubscriber\ based on configuration) to capture message traffic, facilitating easier verification of message flow in test scenarios.

src/Silverback.Integration.Testing/Configuration · high confidence

A new Adobe Illustrator document (Logo.ai) has been added to the graphics directory, providing a high-resolution vector source for the product logo.

graphics · high confidence

The testing library now includes a mock implementation of the Confluent Schema Registry client (MockedConfluentSchemaRegistryClient) and its factory, allowing tests to simulate schema registration and lookup without a real registry. Additionally, a SchemaNormalizer utility has been added to standardize Avro and JSON schemas by parsing and re-serializing them, ensuring consistent schema representations during tests.

src/Silverback.Integration.Kafka.Testing/Messaging/Serialization · high confidence

A new producer behavior, KafkaMessageKeyInitializerProducerBehavior, has been added to automatically set the Kafka message key for outgoing messages. When a message is decorated with the KafkaKeyMemberAttribute, the system now extracts the specified property value and applies it as the Kafka key in the message envelope, ensuring correct partitioning and ordering without manual configuration.

src/Silverback.Integration.Kafka/Messaging/Producing · high confidence

The messaging pipeline now automatically detects and handles messages implementing the IBinaryMessage interface. When producing such messages, the system transparently switches to the BinaryMessageSerializer to pass raw binary content as-is, and on the consumer side, the BinaryMessageHandlerConsumerBehavior ensures the incoming byte stream is correctly wrapped into the target model type without requiring explicit serializer configuration.

src/Silverback.Integration/Messaging/BinaryMessages · high confidence

The Kafka Schema Registry integration now includes dedicated serializers and deserializers for Avro, JSON, and Protobuf message formats. This change introduces \AvroMessageSerializer\/\Deserializer\, \JsonSchemaRegistryMessageSerializer\/\Deserializer\, and \ProtobufMessageSerializer\/\Deserializer\, along with base classes \SchemaRegistryMessageSerializer\ and \SchemaRegistryMessageDeserializer\ that handle the underlying Confluent client interactions. A new \ConfluentSchemaRegistryClientFactory\ is provided to manage schema registry client instances based on configuration. Users can now leverage schema-validated serialization for these three formats within the Silverback Kafka integration.

src/Silverback.Integration.Kafka.SchemaRegistry/Messaging/Serialization · high confidence

Consumers can now store Kafka offsets locally rather than relying solely on Kafka's internal group management. This change introduces a configurable client-side offset store (via \ClientSideOffsetStore\ settings) that persists processed offsets and restores them on restart, ensuring exactly-once processing semantics. The implementation includes a new \IKafkaOffsetStore\ interface, a factory for store instances, and a consumer behavior that manages the offset storage scope within the Silverback context.

src/Silverback.Integration.Kafka/Messaging/Consuming · high confidence

Users can now explicitly configure the Newtonsoft.Json serializer and deserializer for Silverback message endpoints via new fluent API methods. The \SerializeAsJsonUsingNewtonsoft\ extension allows producers to customize \JsonSerializerSettings\, control message encoding, and toggle the inclusion of message type headers. Similarly, \DeserializeJsonUsingNewtonsoft\ enables consumers to specify the target message model, configure JSON settings, and define how message type headers are handled (mandatory, optional, or ignored). This provides finer control over JSON message formatting and type resolution compared to previous defaults.

src/Silverback.Integration.Newtonsoft/Messaging/Configuration · high confidence

The in-memory Kafka testing infrastructure now exposes a builder API (IMockedKafkaOptionsBuilder) that allows tests to explicitly configure the mock broker's behavior. Users can specify the default number of partitions per topic, define partition counts for specific topics, override the auto-commit interval to speed up test execution, and introduce a delay before partition assignment occurs to better simulate real-world timing.

src/Silverback.Integration.Kafka.Testing/Messaging/Configuration/Kafka · high confidence

The MQTT producer now supports resolving the target topic dynamically per message rather than using a single static configuration. This is achieved through the new \IMqttProducerEndpointResolver\<TMessage\>\ interface and its implementations: \MqttDynamicProducerEndpointResolver\ allows topics to be determined via a function or format string based on the message content or envelope, while \MqttStaticProducerEndpointResolver\ retains the previous behavior of sending all messages to a fixed topic. This change enables more flexible routing where the destination topic can vary based on message properties.

src/Silverback.Integration.MQTT/Messaging/Producing/EndpointResolvers · high confidence

The Silverback builder now supports an \AsObservable\ extension method that registers the necessary services to allow message subscribers to receive \IObservable\<T\>\ or \IMessageStreamObservable\<TMessage\>\ parameters. This enables users to integrate reactive programming patterns into their message handling logic by resolving observable streams directly within their subscriber methods.

src/Silverback.Core.Rx/Configuration · high confidence

Producers can now automatically encrypt outbound messages and consumers can decrypt inbound messages using symmetric algorithms (defaulting to AES). This is configured via \SymmetricEncryptionSettings\ and \SymmetricDecryptionSettings\, which allow specifying the algorithm, key, initialization vector, and cipher mode. The producer behavior prepends a random IV to the encrypted payload if one is not fixed, and includes a key identifier in the message headers to help the consumer select the correct decryption key.

src/Silverback.Integration/Messaging/Encryption · high confidence

This change introduces the Silverback.Storage.EntityFramework package, providing Entity Framework Core-based implementations for core Silverback capabilities. Users can now store Kafka consumer offsets in a database via EntityFrameworkKafkaOffsetStore, manage transactional outbox messages using EntityFrameworkOutboxReader and EntityFrameworkOutboxWriter, and handle distributed locking with EntityFrameworkLock. The package also includes EntityFrameworkDomainEventsPublisher to automatically publish domain events from DbContext changes. Configuration is streamlined through fluent extension methods on SilverbackBuilder and BrokerOptionsBuilder, allowing developers to wire these components using their existing DbContext types.

src/Silverback.Storage.EntityFramework · high confidence

Users can now explicitly configure Kafka producer and consumer clients by calling the new AddKafkaClients extension method on the SilverbackBuilder. This method accepts an action that receives a KafkaClientsConfigurationBuilder, allowing for direct setup of client-specific settings before the broker integration is fully initialized.

src/Silverback.Integration.Kafka/Configuration · high confidence

Users can now explicitly configure MQTT clients using the new AddMqttClients extension method on SilverbackBuilder. This method accepts an action that configures an MqttClientsConfigurationBuilder, allowing for direct setup of client options rather than relying on implicit or broker-level defaults. This change introduces a dedicated entry point in the configuration API for managing MQTT client connections.

src/Silverback.Integration.MQTT/Configuration · high confidence

This change introduces the core \MqttConsumer\ and \MqttProducer\ classes within the Silverback MQTT integration library. The \MqttConsumer\ handles incoming MQTT messages by mapping MQTT user properties to message headers, managing message processing states via a \ConsumerChannelsManager\, and supporting commit/rollback operations for reliable consumption. The \MqttProducer\ enables sending messages over MQTT, supporting both synchronous and asynchronous production with callback-based success/error handling. A new \MqttMessageIdentifier\ record is added to uniquely identify messages client-side, as MQTT does not provide native message IDs.

src/Silverback.Integration.MQTT/Messaging/Broker · high confidence

The repository is initialized with the solution structure for Silverback version 5.5.3, targeting the .NET 10.0 framework. This includes the core messaging library, integration packages for Kafka and MQTT, storage providers (Memory, SQLite, PostgreSQL, Entity Framework), and testing utilities. The build system is configured via Azure Pipelines to use the .NET SDK 10.0.x, and code analysis is enforced using Microsoft.CodeAnalysis.NetAnalyzers, Microsoft.VisualStudio.Threading.Analyzers, and StyleCop.Analyzers through a centralized Directory.Build.props file.

(repo-wide) · high confidence

Added a new abstract base class, TableBasedDistributedLock, and its corresponding settings record, TableBasedDistributedLockSettings, to the relational storage lock module. This change provides a reusable foundation for database-backed distributed locks, introducing configurable parameters for lock acquisition intervals, heartbeat frequencies, and lock timeouts, along with built-in validation to ensure logical consistency between these timing settings.

src/Silverback.Storage.Relational/Lock · high confidence

A new PowerShell script (Update.ps1) has been added to the nuget directory to automate the build and packaging process for Silverback libraries. The script discovers source projects, temporarily replaces internal project references with package references to ensure isolation, builds the projects, and generates NuGet packages, supporting configuration options for build settings and warning-as-error behavior.

nuget · high confidence

This change adds foundational types to the Silverback.Core library, including the SilverbackException base class and its SilverbackConfigurationException subclass for error handling, an AsyncEvent\<TArg\> class for managing asynchronous event handlers, and an ExecutionFlow enum to distinguish between synchronous and asynchronous execution paths. It also introduces the ISorted interface with a SortIndex property for ordering objects, and implements the ISilverbackContext interface along with its SilverbackContext class to provide a scope-bound storage mechanism for sharing objects (such as storage transactions) within a dependency injection scope.

src/Silverback.Core · high confidence

Added a new generic \DataAccess\ base class and \DbDataReaderExtensions\ within the Silverback relational storage library. This component provides a unified API for executing SQL queries, scalars, and non-query commands against relational databases, featuring support for both synchronous and asynchronous execution. A key behavioral addition is the propagation of cancellation tokens through async database operations, allowing users to interrupt long-running queries or batch writes. The implementation also ensures proper disposal of database resources and handles transaction commits and rollbacks automatically for non-query operations.

src/Silverback.Storage.Relational/Storage/DataAccess · high confidence

The testing package now includes a fully in-memory MQTT broker implementation (\InMemoryMqttBroker\) and associated mock client (\MockedMqttClient\) to enable integration testing without a real broker. This change adds the core infrastructure for mocking MQTT interactions, including session management, topic subscription matching, message publishing, and waiting for message consumption, allowing developers to verify message flow and consumer behavior in a controlled, deterministic environment.

src/Silverback.Integration.MQTT.Testing/Messaging/Broker · high confidence

This change adds a new in-memory implementation of the transactional outbox pattern, consisting of the InMemoryOutbox storage, InMemoryOutboxWriter for persisting messages, InMemoryOutboxReader for retrieving and acknowledging them, and InMemoryOutboxSettings for configuration. Users can now utilize this lightweight, non-persistent outbox for scenarios where durability across restarts is not required, while the writer explicitly logs a warning if a database transaction context is detected, as the in-memory store does not participate in such transactions.

src/Silverback.Storage.Memory/Messaging/Producing · high confidence

Added a new chunking sequence system that automatically splits large outbound messages into smaller chunks based on configurable size limits, and reassembles them on the consumer side. This includes new components such as ChunkSequence, ChunkSequenceReader, and ChunkSequenceWriter, along with settings to control chunk size and header behavior, enabling reliable transmission of messages that exceed broker size constraints.

src/Silverback.Integration/Messaging/Sequences/Chunking · high confidence

Added a new \ValueReadOnlyCollection\<T\>\ type and its corresponding \IValueReadOnlyCollection\<T\>\ interface, which provide read-only collection semantics with value-based equality. This allows collections to be compared and hashed based on their element contents rather than reference identity, and includes extension methods to easily wrap existing enumerables into this value-aware type.

src/Silverback.Core/Collections · high confidence

Adds a new extensible factory and interface system for tracking message identifiers (such as offsets) during production and consumption. The \BrokerMessageIdentifiersTrackerFactory\ creates specific tracker instances based on endpoint configuration, defaulting to a \SimpleMessageIdentifiersTracker\ that manages a set of identifiers for commit and rollback operations. This provides a structured way to handle identifier tracking logic across different message brokers.

src/Silverback.Integration/Messaging/Broker/BrokerMessageIdentifiersTracking · high confidence

The Silverback.Core diagnostics layer now uses a dedicated, non-generic logging infrastructure that supports structured logging via \LogEvent\ definitions and high-performance \LoggerMessage\ delegates. This change introduces the ability to customize log levels for specific events through a \LogLevelConfigurator\, allowing users to override default severity settings. Additionally, it adds distributed tracing support by creating an \ActivitySource\ for subscriber invocations, enabling better observability of message processing flows.

src/Silverback.Core/Diagnostics · high confidence

Adds a new transaction management layer for message consumption, centered on the \ConsumerTransactionManager\ and \TransactionHandlerConsumerBehavior\. This change ensures that consumer offsets are committed only once per transaction scope and introduces explicit support for processing message sequences (batches/chunks), where commits are deferred until the entire sequence is successfully processed. It also adds extension methods to retrieve the \ConsumerPipelineContext\ from the Silverback context, enabling better integration with the new transactional flow.

src/Silverback.Integration/Messaging/Consuming/Transaction · high confidence

The messaging model now includes dedicated interfaces for Command, Event, Query, and Integration message types (ICommand, IEvent, IQuery, IIntegrationCommand, IIntegrationEvent, IIntegrationMessage). This allows users to explicitly distinguish between actions that trigger side effects (Commands), notifications of state changes (Events), and requests for data retrieval (Queries), while also providing specific markers for messages sent over a message broker (Integration variants).

src/Silverback.Core.Model/Messaging/Messages · high confidence

The \src/Silverback.Core/Lock\ directory now contains the core abstractions for distributed locking, including the \IDistributedLock\ interface, a base \DistributedLock\ class, and a \DistributedLockFactory\ for creating lock instances based on settings. This change introduces the foundational types (\DistributedLockHandle\, \DistributedLockSettings\) and a \NullLock\ implementation, establishing the API surface for lock acquisition and management within the Silverback framework.

src/Silverback.Core/Lock · high confidence

The domain layer now includes a structured model for domain events, featuring a base \DomainEntity\ class that tracks unpublished events and implements \IMessagesSource\, alongside \IDomainEvent\ interfaces and a generic \DomainEvent\ base class. A new \DomainEventsPublisher\ component has been added to scan entities for these events and publish them via the message bus, supporting both synchronous and asynchronous execution flows while handling recursive event firing.

src/Silverback.Core.Model/Domain · high confidence

The Kafka integration now exposes a comprehensive set of new callback interfaces for both consumers and producers, allowing users to hook into low-level events. Consumer callbacks include handling partition assignments and revocations, tracking offset commit results, detecting end-of-partition (EOF) events, and receiving error, log, and statistics notifications. Producer callbacks provide similar visibility through error, log, and statistics handlers. These are wired up via the new \KafkaEventsBinder\ which configures the underlying Confluent.Kafka builders to invoke these user-defined handlers.

src/Silverback.Integration.Kafka/Messaging/Broker/Callbacks · high confidence

Added two new enrichers in the producing pipeline: KafkaKeyOutboundHeadersEnricher, which allows setting the Kafka message key header via a configurable value provider, and KafkaMovePolicyMessageEnricher, which enriches outbound envelopes with source topic, consumer group ID, partition, offset, and failure reason metadata when messages are moved due to errors.

src/Silverback.Integration.Kafka/Messaging/Producing/Enrichers · high confidence

This change introduces a new set of helper classes and extension methods within the Silverback Kafka integration to manage message metadata more effectively. It adds \KafkaEnvelopeExtensions\ to provide convenient methods for getting and setting Kafka-specific headers such as the message key, timestamp, destination topic, and partition on inbound and outbound envelopes. Additionally, it includes \KafkaKeyHelper\ and \KafkaKeyMemberAttribute\ to automatically generate Kafka message keys from object properties, \KafkaHeadersMappingExtensions\ for converting between Silverback and Confluent Kafka header formats, and a \KafkaMessageHeaders\ class to centralize header constant definitions. These utilities enhance the developer experience by simplifying the handling of Kafka-specific message attributes.

src/Silverback.Integration.Kafka/Messaging/Messages · high confidence

Added four new sample applications to the Kafka samples directory to demonstrate key messaging patterns. The Avro samples show how to produce and consume messages using the Confluent Schema Registry with Avro serialization. The Basic samples provide a simple producer-consumer setup with error retry policies. The Batch samples demonstrate consuming messages in configurable batches (size and time-based) and handling tombstone messages within those batches. Finally, the Binary File Streaming samples illustrate how to stream large binary files by splitting them into chunks and using custom headers for metadata.

samples/Kafka · high confidence

Added two new distributed locking strategies for PostgreSQL: an advisory lock implementation (PostgreSqlAdvisoryLock) that leverages the Medallion.Threading.Postgres library for lightweight, database-level locking, and a table-based lock implementation (PostgreSqlTableLock) that manages lock state in a configurable table (defaulting to 'SilverbackLocks') with support for heartbeats, timeouts, and custom table names via the UseTable builder method.

src/Silverback.Storage.PostgreSql/Lock · high confidence

A new PublisherConsumerBehavior has been added to the consuming pipeline to manage how consumed messages are published via the message bus. This behavior distinguishes between raw sequences and other sequence types, routing them to specific publishing logic. For unbounded sequences, it implements logic to add envelopes to a shared sequence store and manages the lifecycle of stream providers, including handling subscriber completion and aborting pending streams when errors occur. This change introduces the core mechanism for streaming message consumption within the Silverback messaging framework.

src/Silverback.Integration/Messaging/Consuming · high confidence

A new consumer application has been added to the test bench to validate Silverback's message processing capabilities. It connects to Kafka and MQTT brokers, consuming single, batch, and unbounded (streaming) messages, and publishes responses back to the respective brokers. The consumer includes logic to simulate processing delays and failures for testing error policies and sequence synchronization, and is containerized with .NET 10 diagnostic tools for debugging.

testbench/Silverback.TestBench.Consumer · high confidence

The tools directory now includes a new set of C\# source generators and documentation utilities. The \Silverback.Tools.Generators.KafkaConfigProxies\ project introduces generators that automatically create builder classes and proxy records for Confluent.Kafka configurations (Client, Consumer, Producer, and Schema Registry), simplifying the fluent configuration of Kafka clients. Additionally, new documentation generators (\Silverback.Tools.Generators.Docs.Headers\ and \Silverback.Tools.Generators.Docs.LogEvents\) have been added to automatically produce markdown tables for message headers and log events, while a shared \ReflectionHelper\ utility supports these code-generation tasks.

tools · high confidence

The \src/Silverback.Core/Background\ area introduces two new abstract base classes: \DistributedBackgroundService\ and \RecurringDistributedBackgroundService\. \DistributedBackgroundService\ extends \BackgroundService\ to wrap execution in a distributed lock, ensuring that background tasks do not run concurrently across multiple instances. \RecurringDistributedBackgroundService\ builds on this by executing the locked task at regular intervals and adds \Pause()\ and \Resume()\ methods to control execution without stopping the service. These classes provide a robust foundation for long-running, distributed background operations with built-in concurrency control and lifecycle management.

src/Silverback.Core/Background · high confidence

Added \InboundEnvelopeBuilder\<TMessage\>\ and \OutboundEnvelopeBuilder\<TMessage\>\ classes in the \src/Silverback.Integration.Testing/Messaging/Messages\ directory to simplify the creation of test message envelopes. These builders provide a fluent API for configuring message content, headers, endpoints, and producers/consumers, allowing developers to easily construct realistic \IInboundEnvelope\ and \IOutboundEnvelope\ instances for unit and integration tests without manually assembling complex broker objects.

src/Silverback.Integration.Testing/Messaging · high confidence

Added \ExtensibleFactory\<TService, TSettingsBase\>\ and \TypeBasedExtensibleFactory\<TService, TDiscriminatorBase\>\ base classes, along with their corresponding internal marker interfaces (\IExtensibleFactory\, \ITypeBasedExtensibleFactory\). These classes provide a structured way to register and resolve service implementations based on either specific settings records or discriminator types, supporting optional caching and factory overrides to allow extension packages to inject custom service implementations.

src/Silverback.Core/ExtensibleFactories · high confidence

The SilverbackBuilder now exposes a comprehensive set of extension methods to configure broker behaviors, client callbacks, sequence readers/writers, and storage initialization. Users can explicitly register transient or singleton broker behaviors (e.g., for enrichment, filtering, validation, serialization, encryption, and sequencing) and client callbacks via the new \AddTransientBrokerBehavior\, \AddSingletonBrokerClientCallback\, and similar methods. The \WithConnectionToMessageBroker\ method has been updated to wire up these components, including the new \IIntegrationPublisher\ and \BrokerClientsConnector\, while \EnableStorage\ allows optional storage initialization. Additionally, \WithCustomHeaderName\ provides a way to map default header names to custom ones.

src/Silverback.Integration/Configuration · high confidence

The Silverback.Integration.Testing package now includes the IIntegrationSpy interface and its implementation, allowing tests to monitor and collect all inbound and outbound messages (including raw envelopes) for verification. Additionally, the ITestingHelper interface and its abstract TestingHelper implementation provide utility methods to retrieve specific producers and consumers by endpoint name, and to wait for consumers to connect or for all messages to be consumed and processed, simplifying the setup and assertion phases of integration tests.

src/Silverback.Integration.Testing/Testing · high confidence

The messaging layer introduces a new envelope hierarchy (IInboundEnvelope, IOutboundEnvelope, IBrokerEnvelope) and a dedicated MessageHeaderCollection to manage message metadata. This change provides a unified way to handle message headers, including support for binary content via BinaryMessage and tombstone markers, while standardizing distributed tracing headers according to the W3C Trace Context proposal.

src/Silverback.Integration/Messaging/Messages · high confidence

The producing pipeline now supports enriching outbound messages before they are sent. This change introduces a new \MessageEnricherProducerBehavior\ that iterates through configured \IOutboundMessageEnricher\ instances for each endpoint, allowing developers to attach custom headers or modify message metadata. The diff adds the core interfaces (\IOutboundMessageEnricher\, \IMovePolicyMessageEnricher\), a factory for broker-specific enrichers, and concrete implementations like \GenericOutboundHeadersEnricher\ and \StaticOutboundHeadersEnricher\ to facilitate header injection based on static values or dynamic providers.

src/Silverback.Integration/Messaging/Producing/Enrichers · high confidence

The consumer pipeline now supports logical sequences (such as batches or chunks) to group related messages. This introduces a new \ISequence\ interface and a \SequenceStore\ to manage sequence state, along with \ISequenceReader\ and \ISequenceWriter\ behaviors to match incoming messages to their sequences and set appropriate headers. The \SequenceBase\ class provides the core implementation for handling timeouts, aborts, and processing synchronization, allowing subscribers to process grouped messages as a single unit.

src/Silverback.Integration/Messaging/Sequences · high confidence

This change introduces a new storage transaction infrastructure within Silverback. It adds the \IStorageTransaction\ interface, defining a standard contract for committing and rolling back storage operations both synchronously and asynchronously. To integrate this with the existing runtime, \SilverbackContextStorageExtensions\ provides extension methods (\EnlistTransaction\, \GetStorageTransaction\, \TryGetStorageTransaction\, \ClearStorageTransaction\) that allow the \ISilverbackContext\ to manage and retrieve the current storage transaction instance. Additionally, \SilverbackStorageInitializer\ is added to expose configuration points for enabling these optional storage features via the service collection.

src/Silverback.Integration/Storage · high confidence

The Silverback.Core.Util namespace now includes a comprehensive set of internal helper classes and extension methods to support core messaging operations. This adds a centralized validation helper (Check) for parameter validation, along with extensions for enumerables (including async iteration, parallel processing, and disposal), tasks (awaiting all, fire-and-forget, and safe waiting), streams, dictionaries, and service collections. It also introduces utility types such as DisposableAsyncEnumerable, DynamicCountdownEvent, and IncrementalDelayHelper to manage asynchronous workflows and resource cleanup more effectively.

src/Silverback.Core/Util · high confidence

Users can now prevent specific messages from being sent to the broker by configuring an outbound message filter on the endpoint. This is implemented via the new IOutboundMessageFilter interface and the FilterProducerBehavior, which checks the filter before sending; if the filter returns false, the message is skipped and logged. A generic implementation, GenericOutboundMessageFilter\<TMessage\>, is also provided to allow filtering based on message content or envelope properties.

src/Silverback.Integration/Messaging/Producing/Filter · high confidence

The Silverback configuration API now includes extension methods to enable PostgreSQL-based distributed locking. Users can register the lock providers via \AddPostgreSqlAdvisoryLock\ and \AddPostgreSqlTableLock\ on the \SilverbackBuilder\, and configure specific lock instances using \UsePostgreSqlAdvisoryLock\ and \UsePostgreSqlTable\ on the \DistributedLockSettingsBuilder\, passing the required lock name and connection string.

src/Silverback.Storage.PostgreSql/Configuration · high confidence

This change introduces the \Silverback.Storage.PostgreSql\ package, enabling users to store Kafka consumer offsets, transactional outbox messages, and distributed lock state in a PostgreSQL database. The \SilverbackStorageInitializer\ now includes extension methods (\CreatePostgreSqlKafkaOffsetStoreAsync\, \CreatePostgreSqlOutboxAsync\, and \CreatePostgreSqlLocksTableAsync\) that automatically create the necessary tables (\KafkaOffsetStore\, \Outbox\, and \Locks\) with specific schemas (e.g., composite primary keys for offsets, serial IDs for outbox entries) when provided with a connection string and optional table names.

src/Silverback.Storage.PostgreSql/Storage · high confidence

This release adds a new PostgreSQL storage provider for Silverback messaging infrastructure. Consumers can now store Kafka consumer group offsets in a PostgreSQL table (configurable via \PostgreSqlKafkaOffsetStoreSettings\), enabling durable offset management backed by Postgres. Producers can use the transactional outbox pattern with a PostgreSQL-backed writer (\PostgreSqlOutboxWriter\) and reader (\PostgreSqlOutboxReader\), allowing messages to be persisted to a configurable outbox table (\SilverbackOutbox\ by default) and later streamed for delivery. Both components support configurable connection strings, table names, and command timeouts, and the outbox reader supports acknowledging (deleting) processed messages.

src/Silverback.Storage.PostgreSql/Messaging/Producing, src/Silverback.Storage.Sqlite/Messaging/Producing · high confidence

The Kafka integration now uses a new, explicit configuration API to set up producers and consumers. This change introduces dedicated builder classes (KafkaClientsConfigurationBuilder, KafkaConsumerConfigurationBuilder, and KafkaProducerConfigurationBuilder) that replace previous configuration methods. Users can now explicitly add and configure multiple producers and consumers by name using AddProducer and AddConsumer, and apply shared default settings to all instances via AddDefaultProducerConfiguration and AddDefaultConsumerConfiguration. The configuration model is now based on immutable records (KafkaClientConfiguration, KafkaConsumerConfiguration) that wrap Confluent.Kafka settings, providing a more structured and type-safe way to define topics, partitions, offset strategies, and authentication details.

src/Silverback.Integration.Kafka/Messaging/Configuration/Kafka · high confidence

This change introduces the infrastructure for managing database transactions within the relational storage layer. It adds a new \DbTransactionWrapper\ to wrap ADO.NET transactions, ensuring they are properly enlisted with the Silverback context and disposed of correctly based on ownership settings. Additionally, it provides extension methods on \IPublisher\ and \ISilverbackContext\ to allow applications to explicitly enlist existing \DbTransaction\ instances for storage operations, and includes utilities to retrieve the currently active database transaction from the context.

src/Silverback.Storage.Relational/Storage · high confidence

Users can now explicitly enlist database transactions when managing Kafka offset storage. A new extension class, KafkaOffsetStoreScopeRelationalExtensions, adds EnlistTransaction methods to KafkaOffsetStoreScope, allowing developers to pass either an IStorageTransaction or a standard DbTransaction to ensure offset operations participate in the correct database transaction context.

src/Silverback.Storage.Relational/Messaging/Consuming · high confidence

The \src/Silverback.Storage.Sqlite/Messaging/Configuration\ area now provides the fluent API extensions that allow users to configure SQLite-backed storage for Kafka offsets and the transactional outbox. New extension methods on \BrokerOptionsBuilder\ (\UseSqliteKafkaOffsetStore\, \AddSqliteKafkaOffsetStore\, \UseSqliteOutbox\, \AddSqliteOutbox\) enable replacing the default offset and outbox implementations with SQLite versions, which are noted as better suited for testing. Additionally, dedicated settings builders (\SqliteKafkaOffsetStoreSettingsBuilder\, \SqliteOutboxSettingsBuilder\) and their corresponding builder extensions (\UseSqlite\) are introduced, allowing users to specify connection strings, table names, and timeouts (command and create-table) via a chained configuration API.

src/Silverback.Storage.PostgreSql/Messaging/Configuration, src/Silverback.Storage.Sqlite/Messaging/Configuration · high confidence

The SQLite storage provider now includes initialization extensions to create the necessary database tables for Kafka consumer offset tracking and the transactional outbox. Users can now use \CreateSqliteKafkaOffsetStoreAsync\ and \CreateSqliteOutboxAsync\ on the \SilverbackStorageInitializer\ to set up the required schema for reliable message consumption and production within SQLite.

src/Silverback.Storage.Sqlite/Storage · high confidence

The messaging pipeline now integrates OpenTelemetry-style distributed tracing. Consumer and producer behaviors automatically start and manage Activity scopes for message processing, propagating trace context (TraceId, TraceState, and Baggage) via message headers to link end-to-end requests. The system includes a new extensible activity enrichment framework (IActivityEnricherFactory and IBrokerActivityEnricher) allowing brokers to add specific tags (e.g., message ID, destination, sequence ID) to the trace. Additionally, a fatal exception logger behavior ensures that unhandled errors in the consumer pipeline are logged with full context before being rethrown, improving observability for critical failures.

src/Silverback.Integration/Messaging/Diagnostics · high confidence

The Kafka integration now supports transactional messaging, allowing producers to commit or abort messages atomically alongside storage operations. This change introduces the IKafkaTransaction interface and associated implementation, enabling users to initialize transactions via the Publisher or SilverbackContext. A key behavioral improvement is the support for independent partition processing: when ProcessPartitionsIndependently is enabled, the system automatically generates distinct transactional IDs per topic-partition to prevent cross-partition blocking. Additionally, committed transactions now automatically send consumed Kafka offsets to the transaction, ensuring exactly-once semantics where configured.

src/Silverback.Integration.Kafka/Messaging/Transactions · high confidence

The MQTT integration now exposes MQTT 5-specific features through envelope headers, enabling request-response patterns and dynamic topic routing. New extension methods allow setting and retrieving the response topic, correlation data, and destination topic on outbound envelopes, while internal mappings convert these headers to and from MQTT 5 user properties. This allows applications to leverage MQTT 5 capabilities for correlated messaging and flexible destination selection without hardcoding topics.

src/Silverback.Integration.MQTT/Messaging/Messages · high confidence

The messaging subsystem now supports Reactive Extensions (Rx) patterns for handling message streams. Subscribers can accept parameters of type \IMessageStreamObservable\<T\>\ or \IObservable\<T\>\, allowing them to consume messages as a continuous stream rather than individual events. Additionally, subscriber methods can now return \IObservable\<T\>\ values, which are automatically republished by the message bus, enabling reactive pipelines where one subscriber's output becomes another's input.

src/Silverback.Core.Rx/Messaging · high confidence

Users can now customize the names of standard message headers (such as correlation IDs or timestamps) via the new \ICustomHeadersMappings\ interface and \WithCustomHeaderName\ configuration, which automatically renames headers on the producer side and reverts them on the consumer side. Additionally, a new \HeaderAttribute\ allows developers to decorate message properties to automatically map them to and from message headers, simplifying the inclusion of metadata in distributed messages without manual header handling code.

src/Silverback.Integration/Messaging/Headers · high confidence

The Kafka producer endpoint resolver now supports dynamic routing, allowing messages to be sent to different topics and partitions based on runtime logic. This is achieved through the new IKafkaProducerEndpointResolver interface and the KafkaDynamicProducerEndpointResolver implementation, which accept functions to determine the target topic and partition for each outbound message envelope. A corresponding KafkaStaticProducerEndpointResolver remains for fixed routing scenarios. This change enables more flexible message distribution strategies without requiring multiple static producer configurations.

src/Silverback.Integration.Kafka/Messaging/Producing/EndpointResolvers · high confidence

Subscribers that return an IAsyncEnumerable of messages are now automatically republished to the message bus. This new capability is implemented via the AsyncEnumerableMessagesReturnValueHandler, which iterates through the async sequence and publishes each item, ensuring that streaming return values are treated consistently with synchronous IEnumerable and single-message returns.

src/Silverback.Core/Messaging/Subscribers/ReturnValueHandlers · high confidence

Subscribers can now explicitly handle tombstone messages (null or deletion markers) by declaring parameters of type ITombstone or Tombstone\<T\>. A new TombstoneMessageArgumentResolver resolves these parameters, allowing consumers to react to message deletions or cleanup events without processing the actual payload.

src/Silverback.Integration/Messaging/Subscribers/ArgumentResolvers · high confidence

The IIntegrationPublisher interface and its implementation now expose synchronous WrapAndPublish and WrapAndPublishBatch methods, allowing messages to be published without awaiting asynchronous tasks. These new methods mirror the existing async variants, supporting optional envelope configuration actions and arguments, and internally delegate to the underlying publisher to handle the synchronous execution.

src/Silverback.Integration/Messaging/Publishing · high confidence

The Silverback Test Bench application has been rewritten as a WPF desktop app, replacing its previous interface. This new version introduces a ContainersOrchestrator that manages Docker-based consumer instances (scaling in/out, setting instance counts) and a ContainersRandomScaler for automated random scaling. It features a comprehensive logging and tracing system using Serilog with Activity/TraceId enrichment, a MessagesTracker to monitor produced/consumed/lost messages, and UI components (ViewModels, Converters, Windows) to visualize container status, partition assignments, and message statistics. The producer now supports dynamic topic routing for Kafka and MQTT, and the setup includes automatic Kafka topic creation/deletion and PostgreSQL outbox initialization.

testbench/Silverback.TestBench · high confidence

The library now includes a transactional outbox pattern to ensure reliable message delivery. Messages are stored in a local database table within the same transaction as the business logic, and a background worker service asynchronously publishes them to the message broker. This location provides the core interfaces and implementations for this capability, including \IOutboxReader\ and \IOutboxWriter\ for database interaction, \OutboxProduceStrategy\ for capturing messages, and \OutboxWorker\ with configurable retry and batching settings for reliable delivery.

src/Silverback.Integration/Messaging/Producing/TransactionalOutbox · high confidence

The Kafka integration layer has been restructured to replace direct client instantiation with explicit builder and wrapper classes. This change introduces dedicated factories and builders for the Confluent Admin, Consumer, and Producer clients (e.g., \ConfluentAdminClientFactory\, \ConfluentConsumerBuilder\, \ConfluentProducerBuilder\), along with wrapper implementations (\ConfluentConsumerWrapper\, \ConfluentProducerWrapper\) that manage the underlying client lifecycles. This refactoring centralizes client configuration and event handling, providing a more modular foundation for features like transaction support and offset management.

src/Silverback.Integration.Kafka/Messaging/Broker/Kafka · high confidence

The benchmarks directory has been reorganized to support comparing the latest version of the library against older releases. A new solution structure includes a 'LatestVersionBenchmarks' project and a 'V462Benchmark' project targeting version 4.6.2, linked by a PowerShell script that automates the creation of these older-version benchmark projects. Additionally, a new .editorconfig file enforces consistent code formatting and analyzer rules across the benchmark projects.

benchmarks · high confidence

The endpoint classes in the messaging layer (ConsumerEndpoint, ProducerEndpoint, and their base Endpoint) have been refactored from classes to immutable records. This change introduces a standardized DisplayName property for human-readable output (logs, health checks), which is automatically formatted as "{FriendlyName} ({RawName})" when a friendly name is configured, or falls back to the RawName otherwise.

src/Silverback.Integration/Messaging · high confidence

The subscriber infrastructure now uses a dedicated \ArgumentsResolversRepository\ and a set of interfaces (\IArgumentResolver\, \IMessageArgumentResolver\, \IAdditionalArgumentResolver\) to resolve method parameters. This change adds built-in support for injecting \CancellationToken\ into subscriber methods via \CancellationTokenArgumentResolver\ and allows resolving other parameters from the service container via \DefaultAdditionalArgumentResolver\. It also introduces a lazy evaluation model for message streams (\ILazyArgumentValue\, \IStreamEnumerableMessageArgumentResolver\) to prevent blocking the publishing thread while subscribers process \IMessageStreamEnumerable\ inputs.

src/Silverback.Core/Messaging/Subscribers/ArgumentResolvers · high confidence

The messaging layer now supports asynchronous message streams via new \IMessageStreamEnumerable\ and \IMessageStreamProvider\ interfaces, allowing publishers to push messages to subscribers in a streaming fashion rather than as discrete items. A new \IEnvelope\ interface replaces the previous inbound/outbound message interfaces to wrap messages during broker transfer, and a \LazyMessageStreamEnumerable\ implementation enables deferred stream creation until the first message arrives. Additionally, \IMessagesSource\ and \MessagesSource\<T\>\ provide a standardized way for domain entities to collect and publish internal events upon database persistence.

src/Silverback.Core/Messaging/Messages · high confidence

The outbound message routing pipeline has been restructured with new components in the \Producing/Routing\ namespace. A new \IMessageWrapper\ interface and its \MessageWrapper\ implementation now handle wrapping messages into \IOutboundEnvelope\ instances and producing them to configured producers, supporting both single messages and batches (including \IEnumerable\ and \IAsyncEnumerable\). The \OutboundRouterBehavior\ acts as the integration point, detecting message types (including collections) and delegating to the wrapper. A new \OutboundEnvelopeFactory\ simplifies envelope creation, and a dedicated \RoutingException\ is introduced for routing failures. This change centralizes the logic for envelope enrichment, producer selection, and batch handling within this specific routing layer.

src/Silverback.Integration/Messaging/Producing/Routing · high confidence

The broker callback system now uses a dedicated invoker to manage lifecycle events (OnBrokerClientsConfiguredAsync, OnBrokerClientsConnectedAsync) via a marker interface. This change ensures that exceptions thrown by client callbacks are wrapped in a specific BrokerClientCallbackInvocationException, providing clearer error context, and prevents ObjectDisposedException errors during application shutdown by respecting the application lifetime state.

src/Silverback.Integration/Messaging/Broker/Callbacks · high confidence

The Kafka broker layer has been restructured to introduce explicit interfaces and specialized producer types. A new \IKafkaConsumer\ interface exposes partition control methods (Pause, Resume, Seek, GetOffsetsForTimestamps) and configuration details, implemented by the refactored \KafkaConsumer\ class which now handles partition assignment, revocation, and local timeout monitoring via \KafkaConsumerLocalTimeoutMonitor\. For producers, a new \KafkaTransactionalProducer\ and \IKafkaTransactionalProducerCollection\ have been added to support Kafka transactions, allowing messages to be produced within a transactional context managed by \KafkaTransactionalProducerCollection\. The standard \KafkaProducer\ now includes logic to check and report persistence status (PossiblyPersisted, NotPersisted) based on configuration. Additionally, \KafkaOffset\ is introduced as a specific broker message identifier for Kafka partitions.

src/Silverback.Integration.Kafka/Messaging/Broker · high confidence

The MQTT broker implementation has been refactored to improve connection stability and observability. The new \MqttClientWrapper\ introduces automatic reconnection logic that monitors connection status and attempts to reconnect if the link to the broker is lost, while also ensuring subscriptions are re-established after a reconnect. Lifecycle events are now exposed via dedicated callback interfaces (\IMqttClientConnectedCallback\, \IMqttClientDisconnectingCallback\), allowing applications to react to connection state changes. Additionally, internal logging from the MQTTnet library is now routed through the application's standard logging infrastructure for better traceability.

src/Silverback.Integration.MQTT/Messaging/Broker/Mqtt · high confidence

The mocked Kafka broker in the testing library now implements a more realistic partition assignment strategy. In addition to the existing simple round-robin approach, a new cooperative sticky rebalance strategy has been added, which attempts to retain existing partition assignments where possible before redistributing them. This change affects how partition assignments and revocations are simulated during consumer group rebalances in tests, providing a closer approximation of real Kafka behavior.

src/Silverback.Integration.Kafka.Testing/Messaging/Broker/Kafka/Mocks/Rebalance · high confidence

The Newtonsoft integration now provides dedicated \NewtonsoftJsonMessageSerializer\ and \NewtonsoftJsonMessageDeserializer\ classes that replace the previous legacy serializer. Users can now configure how the deserializer handles message type headers via the \JsonMessageDeserializerTypeHeaderBehavior\ setting (supporting Mandatory, Optional, or Ignore modes), allowing for more flexible deserialization of polymorphic message types. The serializer includes a \MustSetTypeHeader\ option to control whether the message type assembly name is automatically added to headers, and the deserializer ensures backward compatibility by resetting the stream position after reading.

src/Silverback.Integration.Newtonsoft/Messaging/Serialization · high confidence

The MQTT client configuration has been refactored to use a new set of immutable record types and fluent builders. Users can now explicitly configure multiple MQTT clients via \MqttClientsConfigurationBuilder\, specifying TCP or WebSocket transport channels (\MqttClientTcpConfiguration\, \MqttClientWebSocketConfiguration\) and detailed TLS settings (\MqttClientTlsConfiguration\) with support for proxy authentication, ALPN, and certificate validation. This change introduces a structured, type-safe way to define client connections, endpoints, and security policies, replacing the previous configuration approach.

src/Silverback.Integration.MQTT/Messaging/Configuration/Mqtt · high confidence

The configuration API for Silverback has been refactored to use dedicated builder classes, providing a more explicit and chainable way to set up messaging. Users can now configure broker client connection modes (Startup, AfterStartup, Manual) and retry behavior via BrokerOptionsBuilder. Endpoint configuration is handled by ConsumerEndpointConfigurationBuilder and ProducerEndpointConfigurationBuilder, which allow setting deserializers (JSON, Binary, String, Raw), enabling batch processing, configuring error policies, and setting up message decryption. Additionally, ErrorPolicyBuilder allows fine-grained control over which exceptions trigger specific error handling actions.

src/Silverback.Integration/Messaging/Configuration · high confidence

The message producing pipeline has been refactored to use a strategy pattern, introducing IProduceStrategy and IProduceStrategyImplementation to decouple the production logic from the broker client. This change adds support for cancellation tokens throughout the produce operations, allowing users to cancel message production requests. The default strategy (DefaultProduceStrategy) now handles both single and batch message production (IEnumerable and IAsyncEnumerable) with proper cancellation handling. Additionally, a new DelegatedProducer mechanism allows custom production delegates to be registered, enabling flexible message production workflows.

src/Silverback.Integration/Messaging/Producing · high confidence

The messaging subsystem introduces a new subscription model that allows configuring subscribers via delegates or types. Users can now use the \DelegateSubscriber\ factory to create subscriptions from \Action\, \Func\, \Task\, and \ValueTask\ handlers, supporting up to four message parameters. Additionally, \TypeSubscription\ enables subscribing to all public methods of a type or specific methods marked with \\[Subscribe\]\, with options to control exclusivity and apply message filters. This replaces the previous \BusConfigurator\ and \ISubscriber\ approach, providing a more flexible and type-safe way to define message handling logic.

src/Silverback.Core/Messaging/Subscribers/Subscriptions · high confidence

The message publishing mechanism in Silverback.Core has been redesigned to use a composable pipeline of behaviors. The new \IPublisher\ interface and \Publisher\ implementation now resolve a stack of \IBehavior\ instances via \IBehaviorsProvider\, allowing custom logic to intercept and transform messages before they reach subscribers. This change introduces \ValueTask\-based asynchronous handling for behaviors, supports \CancellationToken\ propagation for graceful cancellation, and adds a \throwIfUnhandled\ option to explicitly throw \UnhandledMessageException\ when no subscribers are found. The \StreamPublisher\ now delegates to the main publisher, and behavior ordering is determined by \SortBySortIndex\.

src/Silverback.Core/Messaging/Publishing · high confidence

The producer endpoint resolution logic has been refactored to support both static and dynamic destination resolution. A new \DynamicProducerEndpointResolver\ allows the target endpoint (such as a topic or partition) to be determined per-message, including via envelope headers, while the existing \StaticProducerEndpointResolver\ continues to provide cached, configuration-based resolution. This change enables more flexible routing strategies for outbound messages.

src/Silverback.Integration/Messaging/Producing/EndpointResolvers · high confidence

The Kafka consumer and producer endpoints have been refactored from classes to immutable C\# records, introducing explicit \TopicPartition\ properties that allow messages to be produced to or consumed from specific partitions rather than relying on default assignment. This change also includes a new \KafkaChunkEnricher\ that attaches Kafka-specific offset headers to chunked messages, ensuring precise tracking of chunk boundaries within the Kafka topic.

src/Silverback.Integration.Kafka/Messaging · high confidence

The Kafka integration's configuration API has been restructured to support explicit client configuration. A new \AddKafkaClients\ extension method allows users to define producer and consumer settings via a dedicated \KafkaClientsConfigurationBuilder\, which are then merged into global configuration actions. The \AddKafka\ extension now registers the necessary services, including the new \KafkaClientsConfigurationActions\, client builders, and specific behaviors like \KafkaOffsetStoreConsumerBehavior\ and \KafkaMessageKeyInitializerProducerBehavior\. Additionally, a new \KafkaOffsetStoreSettingsBuilder\ and its interface \IKafkaOffsetStoreSettingsImplementationBuilder\ have been introduced to manage offset store settings, and the \KafkaBrokerClientsConfigurator\ now uses the new client configuration pattern.

src/Silverback.Integration.Kafka/Messaging/Configuration · high confidence

The broker integration layer has been restructured to improve reliability and clarity of connection states. A new \BrokerClient\ abstraction now explicitly manages the client lifecycle through distinct \ClientStatus\ states (Disconnected, Initializing, Initialized, Disconnecting), replacing previous implicit connection handling. The \BrokerClientsConnector\ and \BrokerClientsConnectorService\ coordinate the initialization and connection of all broker clients, ensuring idempotent startup and graceful shutdown via \IHostedLifecycleService\. Consumer management has been refined with a \ConsumerStatusInfo\ that tracks detailed status changes (Stopped, Started, Connected, Consuming) and message consumption statistics in a thread-safe manner. Additionally, the \ConsumerChannel\ implementation now uses an overflow channel strategy to prevent message loss when the main processing channel is full, and the \ConsumerChannelsManager\ handles channel reading loops with better error handling for \ChannelClosedException\ and fatal pipeline errors.

src/Silverback.Integration/Messaging/Broker · high confidence

The message processing pipeline has been restructured into a modular behavior system for both producers and consumers. This change introduces explicit sort indexes (defined in BrokerBehaviorsSortIndexes) to control the execution order of pipeline steps, such as encryption, validation, serialization, and header handling. Users benefit from a more predictable and customizable processing flow, where the sequence of operations like message enrichment, filtering, and transaction management is now strictly ordered and extensible via the new IBrokerBehavior interfaces.

src/Silverback.Integration/Messaging/Broker/Behaviors · high confidence

The configuration entry point has been restructured around a new \SilverbackBuilder\ class, which exposes a fluent API for registering subscribers, behaviors, and extensible factories. This change introduces dedicated builder classes for distributed lock settings and implements a validation interface (\IValidatableSettings\) to ensure configuration integrity. Additionally, the underlying endpoint configuration has been refactored to use immutable records, and service registrations have been updated to register \IPublisher\ and \StreamPublisher\ as transient services to prevent duplicate factory registrations.

src/Silverback.Core/Configuration · high confidence

The error handling logic in the consuming pipeline has been refactored to support chaining multiple error policies. A key behavioral change is that when multiple policies are chained, their maximum failed attempts are now correctly stacked (cumulative) rather than applied independently, ensuring the total retry count respects the sum of all policy limits. The system now includes specific policies for retrying with configurable delays (including exponential backoff), moving failed messages to a different endpoint, skipping messages, or stopping the consumer entirely. These policies allow for fine-grained control over exception types, custom apply rules, and post-error message publishing.

src/Silverback.Integration/Messaging/Consuming/ErrorHandling · high confidence

The in-memory Kafka testing infrastructure has been refactored to replace direct instantiation with explicit builder classes for the AdminClient, Consumer, and Producer. This change introduces \MockedConfluentAdminClientFactory\, \MockedConfluentConsumerBuilder\, and \MockedConfluentProducerBuilder\, which allow configuration of settings (such as error handlers, statistics handlers, and partition assignment strategies) before the mocked clients are built. This provides a more structured and testable approach to configuring the mocked Kafka broker behavior.

src/Silverback.Integration.Kafka.Testing/Messaging/Broker/Kafka · high confidence

The internal implementation of the mocked Kafka broker has been restructured to use a new set of interfaces for in-memory data management. The diff introduces \IInMemoryPartition\, \IInMemoryTopic\, \IInMemoryTopicCollection\, \IInMemoryTransactionManager\, and \IInternalMockedConsumerGroup\ to explicitly define how messages, partitions, and transactions are stored and coordinated in memory. This change separates the storage logic (handled by \InMemoryPartition\ and \InMemoryTopic\) from the consumer group coordination (handled by \MockedConsumerGroup\ and \IInMemoryTransactionManager\), providing a cleaner architecture for the in-memory test broker while maintaining the same external \IMockedConfluentConsumer\ and \IMockedConfluentProducer\ contracts.

src/Silverback.Integration.Kafka.Testing/Messaging/Broker/Kafka/Mocks · high confidence

The JSON message serializer and deserializer have been reimplemented to use System.Text.Json instead of the previous Newtonsoft.Json implementation. This change improves performance and reduces memory allocations, as the new serializers are built on the modern, high-performance System.Text.Json API. Users will benefit from faster message processing and lower resource usage when sending or receiving JSON-formatted messages through the messaging pipeline.

src/Silverback.Integration/Messaging/Serialization · high confidence

The samples directory has been reorganized into a single Visual Studio solution (Silverback.Samples.sln) that groups Kafka and MQTT examples, including new samples for JSON schema registry, batch processing with tombstones, and MQTT v3. To ensure consistent code quality and formatting across all samples, a centralized .editorconfig and StyleCop configuration have been added, enforcing specific coding styles and analyzer rules.

samples · high confidence

The MQTT integration now uses a new structured logging system defined in MqttLogEvents and MqttLoggerExtensions. This replaces previous logging approaches with strongly-typed, high-performance log events for key operations such as consuming messages, connection lifecycle events (connect, reconnect, lost), and errors. Users will see more consistent, filterable log messages with specific event IDs and parameters like BrokerMessageId, Topic, and ClientName, improving observability and debugging of MQTT interactions.

src/Silverback.Integration.Kafka/Diagnostics, src/Silverback.Integration.MQTT/Diagnostics · high confidence

The integration package now uses a centralized, structured logging system for all integration-related events. This change introduces specific log events for message processing, sequence handling (start, completion, errors), broker client lifecycle, and outbox operations, providing users with more consistent and detailed diagnostic information.

src/Silverback.Integration/Diagnostics · high confidence

The publishing API in the core model now distinguishes between commands, queries, and events through the new IApplicationPublisher interface and its implementation, ApplicationPublisher. This change introduces dedicated ExecuteCommand and ExecuteQuery methods (with synchronous and asynchronous variants) alongside PublishEvent, allowing callers to explicitly define the intent of a message. The underlying IPublisher interface is extended via extension methods to support these typed operations, ensuring that commands and queries can return results while events are handled as fire-and-forget or awaitable notifications.

src/Silverback.Core.Model/Messaging/Publishing · high confidence

The subscriber execution pipeline has been restructured to introduce explicit message filtering and standardized return-value processing. Subscribed methods can now be decorated with the new MessageFilterAttribute (implementing IMessageFilter) to conditionally prevent invocation based on message content. The invocation flow now returns a MethodInvocationResult that distinguishes between methods that were not invoked, invoked without a return value, and invoked with a return value. Return values are now explicitly handled by a ReturnValueHandlerService, which manages republishing or other side effects, replacing the previous implicit behavior. Additionally, the system now supports ValueTask return types and includes a background service to preload subscriber metadata for improved startup performance.

src/Silverback.Core/Messaging/Subscribers · high confidence

The Silverback Testbench has been rebuilt as a WPF application and upgraded to target .NET 10. This change introduces a new graphical interface for running and managing tests, replacing the previous implementation. The project also includes updated configuration files (.editorconfig, .sln.DotSettings) and a README documenting command-line usage for clearing logs, rebuilding Docker images, and managing topics.

testbench · high confidence

The in-memory outbox implementation now emits a warning when an ambient transaction is detected but cannot be supported. This ensures users are informed that messages will be stored independently of the transaction context, preventing silent data consistency issues.

src/Silverback.Storage.Memory/Diagnostics · high confidence

Added Kafka producer and consumer pipeline benchmarks; Added MQTT testing helper for mocked broker interactions; Added TestException helper class for test scenarios; Added benchmark subscriber implementations for message handling performance testing; Added broker performance benchmarks and strategy comparison tests; Added common test utilities and helpers; Added comprehensive unit tests for the message publishing pipeline; Added end-to-end tests for Kafka batch processing and producing; Added end-to-end tests for MQTT integration scenarios; Added integration tests for Consumer and Outbox health checks; Added integration tests for PostgreSQL storage; Added integration tests for Silverback error handling policies; Added integration tests for Silverback messaging broker components; Added integration tests for batch publishing with Enumerable and AsyncEnumerable inputs; Added integration tests for message producing and routing; Added integration tests for message serialization components; Added integration tests for message validation behaviors; Added integration tests for messaging configuration builders; Added integration tests for symmetric encryption and decryption streams; Added mediator publish performance benchmarks; Added performance benchmarks for core messaging components; Added test coverage for error policy application; Added test domain types for message validation and headers; Added test fixtures for domain aggregate roots and events; Added test fixtures for performance testing; Added test helper utilities for integration testing; Added test infrastructure for EF Core 3.0 integration testing; Added test infrastructure for database-backed integration tests; Added test infrastructure types for Silverback integration testing; Added test message interfaces; Added test message types for Avro, Protobuf, and Kafka-specific features; Added test message types for Kafka key member scenarios; Added test message types for Silverback.Core.Rx; Added test model classes for EF Core 3.0 integration tests; Added test utilities for fake and substitute logging; Added test utilities for message headers and Kafka offset tracking; Added test utility extensions for message serialization and content inspection; Added tests for ApplicationPublisher configuration; Added tests for DbContextEventsPublisher; Added tests for InboundEnvelopeBuilder Kafka extensions; Added tests for Kafka diagnostic logging and activity enrichment; Added tests for Kafka statistics deserialization; Added tests for KafkaGroupIdFilterAttribute; Added tests for MQTT client configuration and envelope builder extensions; Added tests for MQTT diagnostic logging extensions; Added tests for MessageEncoding extension methods; Added tests for MessageStreamEnumerable and MessageStreamProvider; Added tests for MessageStreamObservable behavior; Added tests for MqttClientIdFilterAttribute; Added tests for PostgreSQL Kafka offset store configuration and operations; Added tests for PostgreSQL advisory and table-based distributed locks; Added tests for PostgreSQL outbox reader and writer; Added tests for StreamPublisher message stream handling; Added tests for custom header mappings and attribute-based header helpers; Added tests for distributed background service locking and lifecycle; Added tests for integration logging extensions; Added tests for mocked Kafka consumer rebalance and partition assignment logic; Added tests for mocked Kafka rebalance strategies; Added tests for subscription collection extension methods; Added unit and integration tests for Silverback configuration and Kafka transactions; Added unit tests for ApplicationPublisher and publisher extension methods; Added unit tests for EF Core 3.0 database abstraction; Added unit tests for Entity Framework storage components; Added unit tests for Kafka broker internals and in-memory storage components; Added unit tests for Kafka endpoint RawName property; Added unit tests for Kafka message envelope and key helper extensions; Added unit tests for KafkaOffset comparison and equality logic; Added unit tests for MQTT client configuration builders and validation; Added unit tests for MQTT endpoint and resolver classes; Added unit tests for Newtonsoft JSON message serialization; Added unit tests for Newtonsoft JSON serialization configuration; Added unit tests for Schema Registry serialization builders and Protobuf support; Added unit tests for Silverback diagnostics and logging; Added unit tests for Silverback utility extensions; Added unit tests for TombstoneMessageArgumentResolver and ConsumerNameFilterAttribute; Added unit tests for ValueReadOnlyCollection and its extension methods; Added unit tests for binary message serialization and consumer/producer behaviors; Added unit tests for chunking sequence components; Added unit tests for consumer and outbox health checks; Added unit tests for core locking, context, and integration testing utilities; Added unit tests for domain entity event handling and domain events publishing; Added unit tests for messaging diagnostics components; Added unit tests for messaging message types and headers; Added unit tests for subscriber method return types and subscribed methods cache; New Kafka testing helper interface and implementation; New end-to-end test infrastructure for Silverback.

The project has migrated its target framework to .NET 10, updating core dependencies such as Microsoft.Extensions.\* (v10.0.10), Npgsql (v10.0.3), and Microsoft.Data.Sqlite (v10.0.10) to their .NET 10-compatible versions. Integration libraries for Kafka (Confluent.Kafka v2.15.0) and MQTT (MQTTnet v5.2.0.1603) have also been upgraded. To streamline dependency management, the solution now uses central package versioning via Directory.Packages.props, ensuring consistent versions across all source, sample, and benchmark projects.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 70.

• Code Health 71
• Architecture 71
• Maturity 75
• Readiness 65
• Security 94
• Domain Modelling 83
• Event-Driven 100
• Performance 79

• 300 commits — 212 feature/other, 88 fixes

• (root) — 53 commits
• src/Silverback.Integration — 47 commits
• src/Silverback.Integration.Kafka — 26 commits
• tests/Silverback.Integration.Tests.E2E — 23 commits
• src/Silverback.Core — 22 commits
• src/Silverback.Integration.MQTT — 15 commits
• docs/guides — 12 commits
• testbench/Silverback.TestBench — 10 commits
• tests/Silverback.Integration.Tests — 10 commits
• tests/Silverback.Core.Tests — 8 commits
• docs/changelog — 7 commits
• src/Silverback.Integration.Kafka.Testing — 5 commits
• benchmarks/LatestVersionBenchmarks — 4 commits
• docs/_templates — 4 commits
• src/Silverback.Storage.Relational — 4 commits
• testbench/SilverbackTestBench — 4 commits
• tests/Silverback.Tests.Performance — 4 commits
• samples/Kafka — 3 commits
• testbench/Silverback.TestBench.Consumer — 3 commits
• docs/publish.ps1 — 2 commits

• fix: chore: fix Update.ps1
• fix: chore: fix image in README.md
• fix: chore: fix nuget package build warnings/errors reported by nuget package explorer
• fix: chore: fix sonar findings
• fix: chore: fix sonar warning
• fix: chore: fix test bench build
• fix: chore: fix warning
• fix: chore: fix warnings
• fix: chore: fix warnings
• fix: chore: fix warnings
• fix: chore: fix warnings
• fix: chore: fix warnings
• fix: chore: fix warnings
• fix: fix: Handle exceptions in OutboxQueueHealthCheck
• fix: fix: add missing argument default value
• fix: fix: add try..finally to prevent application stopping handler to hang indefinitely
• fix: fix: avoid empty mqtt subscriptions
• fix: fix: better handling of SilverbackContext and storage transaction
• fix: fix: bind Kafka producer error handler
• fix: fix: correctly handle mqtt consumer channels handling
• …and 280 more

• 2 HTTP endpoints (baseline)

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

BEagle1984/silverback 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.