tinglesoftware/eventbus

This system is a .NET event bus library that provides a unified interface for publishing and consuming events across diverse message transport backends. It supports a wide range of transports, including Azure (Event Hubs, Service Bus, Queue Storage, IoT Hub), AWS (SQS, SNS, Kinesis), RabbitMQ, Kafka, and in-memory testing. The library enables developers to configure multiple transports, handle retries, and manage event serialization (JSON, XML) within a single application, with built-in support for AOT compatibility and structured diagnostics.

16 changes.

The project underwent a major architectural shift to support multiple transport backends, introducing a modular transport layer with implementations for AWS, Azure, RabbitMQ, Kafka, and in-memory testing. This was accompanied by a comprehensive refactor of the core EventBus API, dependency injection, and serialization to improve configurability and AOT compatibility. The entire codebase was also upgraded to .NET 10 with centralized package management.

19 changes.

This period focused on expanding the EventBus library's capabilities with new Azure transport support for IoT Hub and Service Bus, alongside the introduction of XML and Newtonsoft.Json serialization. The work also included significant internal refactoring of the in-memory transport, the addition of retry mechanisms, and the creation of multiple sample applications to demonstrate these new features.

8 changes.

This period focused on enabling Ahead-of-Time (AOT) compatibility through internal refactoring, thread-safety improvements, and trimming helpers. Concurrently, the project expanded its sample applications to demonstrate multi-transport architectures, Azure and Amazon cloud integrations, and secure authentication patterns.

A new sample application named AotSupport has been added to demonstrate AOT (Ahead-of-Time) compatibility. The sample includes a console-based producer and consumer setup using the SlimEventBus with in-memory transport, along with the necessary configuration files (launchSettings.json, appsettings.json) to run the application.

samples/AotSupport · high confidence

Added a new transport implementation for Amazon Kinesis, enabling users to publish events to Kinesis streams. The transport supports publishing events and batching multiple events, but does not yet support consuming events or canceling published events. Configuration is handled via \AmazonKinesisTransportOptions\, which allows setting the region, partition key resolver, and Kinesis client configuration. The implementation enforces Kinesis-specific constraints, such as limiting stream and consumer names to 128 characters.

src/Tingle.EventBus.Transports.Amazon.Kinesis · high confidence

A new sample application demonstrating integration with Amazon SQS and SNS has been added. The project includes a DoorOpened event model, a consumer that logs received events, a background publisher service that simulates door-open events, and configuration files for the Amazon SQS transport and development environment.

samples/AmazonSqsAndSns · high confidence

The CustomEventSerializer sample now includes a complete example for handling Azure DevOps git.push events. This includes the event model classes (e.g., AzureDevOpsCodePushed, AzureDevOpsEventResource), a custom serializer (AzureDevOpsEventSerializer) that maps the raw JSON payload to these models, and a consumer (AzureDevOpsEventsConsumer) that processes the deserialized events. The sample demonstrates how to configure the event bus to use this custom serializer and consumer.

samples/CustomEventSerializer · high confidence

A new sample application for Azure IoT Hub has been added to the samples/AzureIotHub directory. This includes a consumer implementation (AzureIotEventsConsumer) that processes telemetry and lifecycle events, a custom event model (MyIotHubEvent) with an extras dictionary for extension data, and the necessary configuration files (appsettings, launch settings) to run the sample.

samples/AzureIotHub · high confidence

A new sample project, AzureManagedIdentity, has been added to demonstrate how to configure an event bus with Azure Managed Identity authentication. The sample includes a consumer (VehicleTelemetryEventsConsumer) that processes vehicle telemetry events and publishes door status updates, utilizing DefaultAzureCredential for secure, token-based authentication with Azure Service Bus.

samples/AzureManagedIdentity · high confidence

A new sample application, ConfigSample, has been added to demonstrate configuring the event bus with multiple transports. The sample includes event models (ImageUploaded, VideoUploaded, VehicleDoorOpenedEvent, VehicleTelemetryEvent), consumers (VehicleTelemetryEventsConsumer, VisualsUploadedConsumer), and a background service (VisualsProducerService) that simulates publishing events. The configuration in appsettings.json maps specific events to in-memory transports (in-memory-images, in-memory-videos) and an Azure Service Bus transport, illustrating how to wire up different transport types and consumer behaviors within a single application.

samples/ConfigSample · high confidence

Added a new Kafka transport implementation for the event bus, including configuration options, logging extensions, and builder extensions. The transport supports publishing and consuming events via Kafka, with specific limitations noted: scheduled publishing, event expiration, and batching are not supported. Additionally, the implementation enforces single consumer per event, validates entity and consumer name lengths, and handles checkpointing.

src/Tingle.EventBus.Transports.Kafka · high confidence

A new sample project, MultipleConsumers, has been added to demonstrate how to configure and run multiple event consumers within a single application. The sample includes a publisher service that periodically publishes 'DoorOpened' events, alongside two distinct consumers (FirstEventConsumer and SecondEventConsumer) that process these events. The configuration showcases transport-agnostic settings, such as naming scopes and full type name usage, as well as transport-specific settings for an in-memory broadcast transport, providing a practical example of setting up a multi-consumer architecture.

samples/MultiEventsConsumer, samples/MultipleConsumers · high confidence

Users can now use the Newtonsoft.Json library to serialize and deserialize event bus messages. This adds a new serializer implementation that supports configuration via JsonSerializerSettings, including options for formatting and property naming. A warning is included regarding native AOT compatibility, as the serializer relies on dynamic code analysis.

src/Tingle.EventBus.Serializers.NewtonsoftJson · high confidence

A new sample application named SimplePublisher has been added to the samples directory. This sample demonstrates how to publish events using the library's event bus, specifically showing a hosted service that periodically publishes a DoorOpened event. The sample includes configuration for Azure Queue Storage transport, logging, and development environment settings.

samples/SimplePublisher · high confidence

The event bus now supports serializing and deserializing events using the XML format. This change introduces a new \XmlEventSerializer\ and associated configuration options, allowing users to register XML serialization via the \AddXmlSerializer\ extension method on the \EventBusBuilder\. This enables handling of \application/xml\ and \text/xml\ content types within the event bus pipeline.

src/Tingle.EventBus/Serialization/Xml · high confidence

A new sample project, CustomEventConfigurator, demonstrates how to implement a custom IEventBusConfigurator to apply transport-agnostic and transport-specific configurations. The sample includes two sample events and consumers, showing how to register a custom configurator that modifies entity kind and ID formats for specific event types, alongside standard bus setup for Azure Queue Storage.

samples/CustomEventConfigurator · high confidence

Added two new sample applications, MultipleDifferentTransports and MultipleSimilarTransports, to demonstrate how to configure and use multiple message transports within a single application. The MultipleDifferentTransports sample shows how to route specific events to different transport backends (Azure Service Bus and Azure Event Hubs) with distinct configurations, while the MultipleSimilarTransports sample demonstrates routing events to multiple in-memory transports. These samples provide practical examples for users looking to implement multi-transport architectures.

samples/MultipleDifferentTransports · high confidence

Added new classes and extension methods to support Azure IoT Hub messages, including \IotHubEvent\ and \IotHubOperationalEvent\ models, along with helper methods to extract IoT Hub-specific properties (e.g., device ID, message source, and connection auth) from event data.

src/Tingle.EventBus.Transports.Azure.EventHubs/IotHub · high confidence

The library now includes new models for Azure IoT Hub, allowing users to process telemetry, twin change, lifecycle, and connection state events. The \IotHubEvent\ record provides properties to identify the event source and deserialize telemetry data into strongly-typed objects, while \IotHubOperationalEvent\ captures operational metadata such as hub name, device ID, and event type.

Tingle.EventBus.Transports.Azure.EventHubs · high confidence

A new sample application named SimpleConsumer has been added to the samples directory. It demonstrates a basic event-driven architecture using a hosted service that registers an EventCounter for tracking, configures an event bus with Azure Queue Storage transport, and processes SampleEvent messages via a dedicated consumer. The sample includes standard .NET project files, configuration settings for development and general environments, and logging setup.

samples/HealthCheck, samples/SimpleConsumer · high confidence

The Azure Event Hubs transport implementation has been restructured to use new configuration classes (AzureEventHubsTransportOptions, AzureEventHubsConfigureOptions) and credential types (AzureEventHubsTransportCredentials, AzureBlobStorageCredentials) for improved configurability. The change introduces extension methods on EventContext to access raw transport data, including the ConsumerGroup, PartitionContext, and EventData, allowing consumers to interact with the underlying Azure SDK types directly.

src/Tingle.EventBus.Transports.Azure.EventHubs · high confidence

Added the Azure Queue Storage transport for the event bus, including the main transport class, configuration options, credential handling, and extension methods. This enables publishing, consuming, and cancelling events via Azure Queue Storage, with support for scheduled messages, message cancellation, and structured logging for queue operations.

src/Tingle.EventBus.Transports.Azure.QueueStorage · high confidence

The Azure Service Bus transport is now fully implemented, providing a complete integration with Azure Service Bus for event publishing and consumption. Users can configure the transport via \AddAzureServiceBusTransport\ and set options such as \TransportType\, \DefaultLockDuration\, and \DefaultMessageTimeToLive\ through \AzureServiceBusTransportOptions\. The transport supports both Queues and Topics, handles duplicate detection, and exposes the raw \ServiceBusReceivedMessage\ via \EventContext\ extensions for advanced scenarios.

src/Tingle.EventBus.Transports.Azure.ServiceBus · high confidence

The Azure transport layer now allows authentication via Azure's TokenCredential in addition to connection strings. This is enabled by new abstractions (AzureTransportCredentials, AzureTransportOptions) and a validation options class that enforces that either a connection string or a valid credential is provided, improving security by supporting managed identities and other token-based auth methods.

src/Tingle.EventBus.Transports.Azure.Abstractions · high confidence

The In-Memory transport for the EventBus is now available for use in unit tests and local development. This change adds the \InMemoryTransport\ implementation, which stores published, consumed, and failed events in memory, and provides an \InMemoryTestHarness\ to inspect these events during testing. The transport supports tracking cancelled events and exposes configuration via \InMemoryTransportOptions\ and \InMemoryTestHarnessOptions\. A dedicated logger extension (\ILoggerExtensions\) is also included to provide structured logging for the in-memory operations.

src/Tingle.EventBus.Transports.InMemory · high confidence

The EventBus now supports retryable events via the new \IRetryableEvent\ interface and \AbstractRetryableEvent\ base class, allowing events to carry their own retry schedule. Users can configure retry behavior using extension methods that apply exponential, linear, constant, or decorrelated jitter backoff strategies, and can track individual attempt timestamps to monitor retry progress.

src/Tingle.EventBus/Retries · high confidence

The EventBus library introduces a new \IEventPublisher\ interface that defines the contract for publishing events, including methods for creating event contexts, publishing single or batched events with optional scheduling or delay, and canceling scheduled events. The \EventPublisher\ class implements this interface, delegating to the underlying \EventBus\ instance, while \WrappedEventPublisher\ provides a wrapper implementation. Extension methods on \IEventPublisher\ add convenience overloads for delayed publishing and automatic retry scheduling for \IRetryableEvent\ types. This change shifts the internal implementation to use transports and supports AOT compatibility.

src/Tingle.EventBus/Publisher · medium confidence

The EventBus configuration now supports explicit control over naming and error handling through new attributes and enums. Users can use \\[ConsumerName\]\, \\[EventName\]\, \\[EventTransportName\]\, \\[EntityKind\]\, and \\[EventSerializer\]\ attributes to override default naming and serialization behavior. A new \UnhandledConsumerErrorBehaviour\ enum allows configuring whether unhandled consumer errors should move events to a dead-letter queue or be discarded. Additionally, \ConsumerNameSource\ and \NamingConvention\ enums provide structured options for how consumer and event names are generated, supporting prefixes, type names, and various casing conventions.

src/Tingle.EventBus/Configuration · high confidence

The serialization layer has been refactored to support multiple content types and improve compatibility with Ahead-of-Time (AOT) compilation. The new \AbstractEventSerializer\ base class and \IEventSerializer\ interface now handle serialization and deserialization using \BinaryData\ and \ContentType\ metadata, enabling the system to serialize and deserialize events with different content types. Additionally, the implementation uses \System.Text.Json\ with \DynamicallyAccessedMembers\ attributes to ensure trimming and AOT compatibility, while also exposing \HostInfo\ for better observability of the host environment.

src/Tingle.EventBus/Serialization · medium confidence

The RabbitMQ transport is now fully implemented, providing the ability to publish and consume events via RabbitMQ. This includes the core transport logic, configuration options (hostname, credentials, retry policies), and extension methods to register the transport. The implementation enforces RabbitMQ-specific constraints, such as requiring full type names for event naming and limiting exchange/queue names to 255 characters. It also introduces a warning when batch publishing is attempted, as RabbitMQ does not support batching in this context.

src/Tingle.EventBus.Transports.Amazon.Sqs, src/Tingle.EventBus.Transports.RabbitMQ · medium confidence

The EventBus now exposes a set of static constants that standardize tracing, logging, and header naming. Activity names for Consume, Publish, and Cancel operations are defined in ActivityNames, while ActivityTagNames provides semantic conventions for messaging and event-bus telemetry (e.g., event type, serializer type, consumer type, and event count). HeaderNames defines the X-Event-Type and X-Activity-Id headers added to each event, and LogCategoryNames centralizes logging categories (EventBus, Transports, Serializers) under the 'Tingle.EventBus' prefix. These changes make observability more consistent and easier to configure across transports and serializers.

src/Tingle.EventBus/Diagnostics · high confidence

A new TrimmingHelper class was added to the shared code, defining metadata about which members need to be preserved during trimming. This supports Ahead-of-Time (AOT) compilation by ensuring that required constructors and interfaces are not stripped away, enabling the library to function correctly in trimmed, AOT-compiled applications.

shared · medium confidence

The EventBus logging has been refactored into a dedicated extension class, providing structured log messages for bus lifecycle events (starting/stopping), transport operations, and event processing. This change improves log clarity by including the transport name to disambiguate messages and adding specific log entries for deserialization issues and consumer errors, making it easier for users to monitor and debug the event bus behavior.

src/Tingle.EventBus/Extensions · high confidence

The Amazon transport implementations now share a common abstraction for configuration and validation. A new \AmazonTransportOptions\ class defines shared properties for AWS region, access keys, and credentials. A corresponding \AmazonTransportConfigureOptions\ class enforces that a region is always provided and automatically converts region names to endpoints, while also validating that access keys are present if no credentials object is supplied. Additionally, \AmazonSqsTransportException\ and \AmazonWebServiceResponseExtensions\ have been moved to this abstraction layer to support multiple similar transports.

src/Tingle.EventBus.Transports.Amazon.Abstractions · high confidence

The EventBus now uses transports internally, with the main implementation moved to src/Tingle.EventBus/EventBus.cs. This change introduces support for multiple similar transports, better support for multiple consumers per event, and cancellation of published messages. The EventContext now exposes IEventBusPublisher publicly, supports scheduled events with default values, and includes content type handling for serialization. The IEventConsumer interface is renamed from IEventBusConsumer, and the Id generator type is introduced to generate event IDs matching specified formats. Additionally, the code is nested under , namespaces are updated (e.g., Tingle.EventBus.Transports), and activity tags are namespaced to prevent collisions.

src/Tingle.EventBus · high confidence

The internal implementation of the EventBus has been refactored to improve thread-safety and execution flow. A new \EventBusConcurrentDictionary\ provides an asynchronous, thread-safe dictionary with a custom \GetOrAddAsync\ implementation that handles concurrent access and cancellation. A \DictionaryExtensions\ class adds a \ToEventBusWrapper\ method to wrap dictionaries for internal use. Additionally, an \EventBusHost\ background service was introduced to manage the EventBus lifecycle, waiting for application startup before starting and ensuring clean shutdown. The \ExecutionHelper\ was added to handle event deserialization and consumption, integrating with resilience pipelines. These changes support the broader goal of AOT compatibility and internal stability.

src/Tingle.EventBus/Internal · medium confidence

The project has been upgraded to target .NET 10, with the SDK version pinned to 10.0.203 via global.json. The solution has been migrated to the new .slnx format, and central package management has been enabled via Directory.Build.props, which also enforces nullable reference types, implicit usings, and AOT-related compiler warnings. The repository now includes a .codespellrc for spell-checking, an .editorconfig for C\# formatting, and a GitVersion.yml for versioning. The README has been updated to reflect the new structure and list all available packages and samples.

(repo-wide) · high confidence

The InMemory transport's client-side components have been rebuilt, introducing new classes such as InMemoryClient, InMemoryProcessor, InMemorySender, and InMemoryMessage. This change adds support for handling dead-letter entities in subscriptions and provides a cleaner, more robust internal implementation for processing and sending messages in memory.

src/Tingle.EventBus.Transports.InMemory/Client · high confidence

The event bus transport implementation has been reorganized into a new \Tingle.EventBus.Transports\ namespace. This includes the introduction of \EventBusTransport\<TOptions\>\ as the abstract base class for all transports, along with supporting types like \EventBusTransportRegistration\ and \EventBusTransportProvider\. The change also introduces \EventBusTransportOptions\ to centralize transport configuration, including settings for resilience pipelines, duplicate detection, and entity creation. Additionally, the \EventConsumeResult\ struct is added to represent consumption outcomes, and the \IEventBusTransport\ interface is updated to support the new provider-based instantiation model.

src/Tingle.EventBus/Transports · high confidence

The dependency injection setup for the EventBus has been restructured. The \EventBusBuilder\ now exposes \AddTransport\ and \AddConsumer\ methods to register transports and consumers, replacing previous registration patterns. Configuration is now handled via \EventBusOptions\ and \EventBusSerializationOptions\, which include settings for naming conventions, duplicate detection, resilience pipelines, and event ID formats. The \EventBusConfigureOptions\ class applies default configurations, validates options (ensuring unique event and consumer names), and initializes host information. A new \EventBusNamingOptions\ class centralizes naming logic, supporting KebabCase, SnakeCase, and DotCase conventions. The \EventBusServiceCollectionExtensions\ provide \AddEventBus\ and \AddSlimEventBus\ entry points. These changes improve modularity, validation, and configurability of the EventBus within the DI container.

src/Tingle.EventBus/DependencyInjection · high confidence

Add unit tests for Kafka transport checkpointing logic; Added tests for event ID generation, bus builder configuration, and naming conventions; Added tests for the InMemory transport and test harness; Added tests for the MandatoryEventBusConfigurator; Added unit tests for Azure transport and IoTHub serialization.

The project has moved to central package management via a new Directory.Packages.props file, which now defines the versions for all dependencies. This includes updates to the AWS SDK (v4), Azure SDK packages, Confluent.Kafka, RabbitMQ.Client, and various Microsoft.Extensions libraries, alongside test framework updates like xunit v3 and Microsoft.NET.Test.Sdk.

(dependencies) · high confidence

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

• CAI 61 → 63 (+2.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 96 → 95 (-0.6)
• Architecture 98 → 98 (-0.0)
• Maturity 55 → 55 (+0.2)
• Readiness 60 → 57 (-3.2)
• Security 55 → 72 (+16.7)

• Bounded contexts not declared
• CRAP 39: AzureEventHubsTransport.PublishCoreAsync (src/Tingle.EventBus.Transports.Azure.EventHubs/AzureEventHubsTransport.cs)
• CRAP 40: AzureEventHubsConfigureOptions.PostConfigure (src/Tingle.EventBus.Transports.Azure.EventHubs/AzureEventHubsConfigureOptions.cs)
• CRAP 42: AzureIotEventsConsumer.ConsumeAsync (samples/AzureIotHub/AzureIotEventsConsumer.cs)
• Duplicated block (12 lines × 2) (samples/ConfigSample/VisualsProducerService.cs)
• Duplicated block (13 lines × 2) (samples/AotSupport/Program.cs)
• Duplicated block (17 lines × 2) (samples/AotSupport/Program.cs)
• Duplicated block (18 lines × 3) (samples/AmazonSqsAndSns/PublisherService.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No exposed public API
• Off-boarding risk: anonymized user #1

• CRAP 124: AzureServiceBusTransport.OnMessageReceivedAsync (src/Tingle.EventBus.Transports.Azure.ServiceBus/AzureServiceBusTransport.cs)
• CRAP 182: KafkaConfigureOptions.PostConfigure (src/Tingle.EventBus.Transports.Kafka/KafkaConfigureOptions.cs)
• CRAP 53: AzureServiceBusTransport.PublishCoreAsync (src/Tingle.EventBus.Transports.Azure.ServiceBus/AzureServiceBusTransport.cs)
• CRAP 68: AzureServiceBusTransport.DecideAction (src/Tingle.EventBus.Transports.Azure.ServiceBus/AzureServiceBusTransport.cs)
• CRAP 68: AzureServiceBusTransport.PublishCoreAsync (src/Tingle.EventBus.Transports.Azure.ServiceBus/AzureServiceBusTransport.cs)
• CRAP 68: KafkaTransport.OnEventReceivedAsync (src/Tingle.EventBus.Transports.Kafka/KafkaTransport.cs)
• CRAP 72: AzureServiceBusConfigureOptions.PostConfigure (src/Tingle.EventBus.Transports.Azure.ServiceBus/AzureServiceBusConfigureOptions.cs)
• Change coupling: AbstractEventSerializer.cs ↔ EventBusTransport.cs (src/Tingle.EventBus/Serialization/AbstractEventSerializer.cs)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (11–12 lines × 2) (src/Tingle.EventBus.Transports.Azure.EventHubs/EventDataExtensions.cs)
• Duplicated block (12 lines × 2) (src/Tingle.EventBus.Transports.Azure.ServiceBus/AzureServiceBusTransport.cs)
• Duplicated block (12 lines × 3) (src/Tingle.EventBus.Transports.Azure.EventHubs/AzureEventHubsTransport.cs)
• Duplicated block (12 lines × 5) (src/Tingle.EventBus.Transports.Amazon.Sqs/AmazonSqsTransport.cs)
• Duplicated block (13 lines × 4) (samples/AzureManagedIdentity/VehicleTelemetryEventsConsumer.cs)
• Duplicated block (14 lines × 2) (src/Tingle.EventBus.Transports.Amazon.Sqs/AmazonSqsTransport.cs)
• Duplicated block (14 lines × 2) (src/Tingle.EventBus/EventBus.cs)
• Duplicated block (15 lines × 2) (src/Tingle.EventBus.Transports.Amazon.Sqs/AmazonSqsTransport.cs)
• Duplicated block (15–21 lines × 3) (src/Tingle.EventBus.Transports.Azure.EventHubs/AzureEventHubsTransport.cs)
• Duplicated block (16 lines × 2) (src/Tingle.EventBus.Transports.Amazon.Sqs/AmazonSqsTransport.cs)
• Duplicated block (16 lines × 3) (src/Tingle.EventBus/EventContext.cs)
• …and 51 more

• Unchanged — 1 containers · 1 contexts · 0 edges

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

tinglesoftware/eventbus 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.