litenova/LiteBus

LiteBus is a .NET messaging framework that provides a unified pipeline for handling commands, queries, and events, alongside durable inbox and outbox patterns for reliable message processing. It supports multiple transport backends including AMQP, AWS SQS, Azure Service Bus, and Kafka, while offering in-memory implementations for local development. The system includes comprehensive tooling such as Roslyn analyzers, OpenTelemetry diagnostics, and ASP.NET Core management endpoints for operational visibility.

Introduced new modules for AMQP and AWS SQS inbox ingress, enabling the ingestion of messages from these brokers into the LiteBus inbox. The AMQP module registers an \AmqpInboxIngressHandler\ that maps AMQP deliveries to the transport-neutral \TransportInboxIngressHandler\, while the AWS SQS module registers an \AwsSqsInboxIngressModule\ to handle SQS message polling. Both modules support background consumer services and configurable ingress options, allowing users to integrate durable messaging from these specific brokers into the inbox system.

src/LiteBus.Inbox.Ingress.Amqp · high confidence

Introduced new extension methods for registering startup tasks, background services, and diagnostic checks within both Autofac and Microsoft.Extensions.DependencyInjection containers. For Autofac, \AutofacBackgroundServiceHostingExtensions\ and \AutofacDiagnosticHostingExtensions\ handle the registration of these components. For Microsoft DI, \MicrosoftBackgroundServiceHostingExtensions\ and \MicrosoftDiagnosticHostingExtensions\ provide equivalent functionality, including a \BackgroundServiceHostedServiceIndex\ to map background services to hosted services. These changes enable the host to execute startup tasks and background services defined by modules, with corresponding \packages.lock.json\ files added to both projects.

src/LiteBus.Runtime.Extensions.Autofac.Hosting, src/LiteBus.Runtime.Extensions.Microsoft.Hosting · high confidence

Users can now register and resolve LiteBus services using the Autofac container. This change introduces the \LiteBus.Runtime.Extensions.Autofac\ package, which provides an \AddLiteBus\ extension method to integrate LiteBus with Autofac's \ContainerBuilder\. The implementation includes an \AutofacDependencyRegistryAdapter\ to bridge LiteBus's internal dependency registration with Autofac's container, handling single and collection registrations, lifetime scopes, and message dispatch scopes. The package depends on Autofac 9.1.0 and Autofac.Extensions.DependencyInjection 10.0.0.

src/LiteBus.Runtime.Extensions.Autofac · high confidence

Introduces a new Entity Framework Core-based inbox storage implementation for LiteBus. The update adds an EF Core module that registers an \EfCoreInboxStore\ and related interfaces, enabling reliable message tracking in the application's database. The implementation supports both immediate persistence and transactional staging via a \SaveChangesInterceptor\, allowing inbox rows to commit alongside application state within the same database transaction. Configuration is handled through \EfCoreInboxStorageModule\ and \EfCoreInboxStorageModuleBuilder\, which allow specifying the database context, schema, and table names. The package depends on Microsoft.EntityFrameworkCore 9.0.4.

src/LiteBus.Inbox.Storage.EntityFrameworkCore · high confidence

A new documentation site built with Fumadocs and Next.js is introduced under the \site/\ directory. The site serves Markdown content from \../docs\, with each page title derived from the first level-one heading. The search route compiles Markdown at runtime, and the build process enforces that all Markdown source files are present in the search trace. A custom script validates that rendered pages do not contain \.md\ source-file links. The site is configured for Vercel deployment with Next.js framework preset, Node.js 24, and specific security headers. Development uses Node.js 24, and the lockfile is managed for cross-platform compatibility.

site · high confidence

Users can now register and configure LiteBus runtime components using the standard Microsoft.Extensions.DependencyInjection API. This change introduces a new adapter layer that bridges LiteBus's internal dependency registry with the Microsoft DI container, allowing services to be registered via the \IServiceCollection\ interface. The implementation includes \MicrosoftDependencyRegistryAdapter\ to handle duplicate registrations and \MicrosoftMessageDispatchScopeFactory\ to manage dispatch scopes within the DI container's scope lifecycle. This enables seamless integration of LiteBus messaging and command handling into applications built on the Microsoft DI ecosystem.

src/LiteBus.Runtime.Extensions.Microsoft.DependencyInjection · high confidence

The PostgreSQL inbox storage module is introduced, providing a new \PostgreSqlInboxModule\ that registers the inbox store, work signal, and schema initializer. Users can configure the store via \InboxModuleBuilderPostgreSqlExtensions.UsePostgreSqlStorage\, which supports connection strings or existing \NpgsqlDataSource\ instances. The module includes automatic schema creation on startup (configurable via \EnsureSchemaCreationOnStartup\), schema validation, and optional ambient transactional inbox support (\ITransactionalInbox\) that participates in the current PostgreSQL transaction. A custom exception \InboxPostgreSqlStorageConfigurationException\ is added for configuration errors.

src/LiteBus.Inbox.Storage.PostgreSql · high confidence

The PostgreSQL saga storage module is now available, providing a new \PostgreSqlSagaStore\ for persisting saga state with optimistic concurrency control. The change introduces a full schema management system, including automatic schema initialization and validation during host startup, along with the ability to manually bootstrap or validate the \litebus\_saga\_instances\ table. Configuration is handled via \PostgreSqlSagaModule\ and \PostgreSqlSagaModuleBuilder\, allowing users to specify connection strings, data sources, and schema options. The implementation relies on the \Npgsql\ library (version 9.0.4) and includes embedded SQL scripts for creating the saga table and required indexes.

src/LiteBus.Saga.Storage.PostgreSql · high confidence

New extension methods are now available on \InboxModuleBuilder\ and \OutboxModuleBuilder\ to register dispatchers for AMQP, AWS SQS, Azure Service Bus, In-Memory, and Kafka transports. Each extension method configures and registers the corresponding transport module, enabling developers to easily integrate durable messaging patterns with these specific message brokers or in-memory storage.

(repo-wide) · high confidence

A new ASP.NET Core sample application has been added to the \samples\ directory, providing a complete, runnable example of the LiteBus framework. The sample implements a payment processing workflow using the command, query, and event patterns, including a \ProcessPaymentCommand\ and its handler, a \GetPaymentStatusQuery\, and a \PaymentProcessed\ event. It demonstrates the use of in-memory inbox and outbox storage with in-process dispatch, allowing users to see how to register modules, configure the message bus, and handle durable messaging without external dependencies. The sample includes all necessary project files, lock files, and documentation snippets to serve as a reference for integrating LiteBus into an application.

samples · high confidence

A new benchmark suite for the pipelined inbox processor has been added to the benchmarks directory. The suite measures throughput at realistic handler latencies, allowing users to evaluate the performance of the processor under varying concurrency and latency conditions.

benchmarks · high confidence

Users can now route inbox and outbox messages through the local in-process message mediators instead of external brokers. The \CommandInboxDispatcher\ deserializes and executes commands via \ICommandMediator\, while the \EventOutboxDispatcher\ publishes events via \IEventMediator\. Registration is simplified with new extension methods: \InboxModuleBuilder.UseInProcessDispatch()\ and \OutboxModuleBuilder.UseInProcessDispatch()\. These modules are registered via \CommandInboxDispatchModule\ and \EventOutboxDispatchModule\ respectively.

src/LiteBus.Inbox.Dispatch.InProcess · high confidence

The transport layer now includes a configurable circuit breaker that tracks consecutive failures per destination and rejects new operations when a failure threshold is reached, exposing state and failure counts via OpenTelemetry gauges and counters. Additionally, the library introduces a consumer handler invoker that automatically requeues messages on unhandled exceptions, and provides header mapping and tracing utilities for broker-agnostic telemetry.

src/LiteBus.Transport · high confidence

The Azure Service Bus transport adapter now includes a connectivity diagnostic check that verifies reachability of a configured queue or subscription by performing a non-destructive peek, reporting degraded status if no target is set and unhealthy if the entity is unavailable. The adapter also implements a new consumer with automatic processor recovery using exponential backoff for recoverable errors, a publisher with destination-scoped circuit breaker integration, and a message mapper that converts between LiteBus transport messages and Azure Service Bus broker messages. These changes are wired via the \AzureServiceBusTransportModule\ and registered through \AddAzureServiceBusTransport\ extension methods, with configuration options for connection strings, client IDs, and retry intervals.

src/LiteBus.Transport.AzureServiceBus · high confidence

Added three new internal classes to the Entity Framework Core storage layer: EfCoreBulkUpdateCapabilities, which detects support for relational bulk update APIs; EfCoreDurableStoreOperations, which implements shared bulk delete and update logic (falling back to tracked updates for providers like InMemory or SQLite); and EfCoreIdempotencyResolution, which handles tenant normalization, scope key creation, and in-batch duplicate resolution for durable messaging.

src/LiteBus.Storage.EntityFrameworkCore/Stores · high confidence

Developers can now register an in-memory implementation of the inbox storage layer via the new \InMemoryInboxStorageModule\. This provides a thread-safe, process-local store for unit tests and local development, supporting configurable capacity limits, lease durations, and time providers. The module registers all necessary inbox store interfaces (e.g., \IInboxStore\, \IInboxLeaseStore\, \IInboxStateWriter\) against the same underlying \InMemoryInboxStore\ instance, enabling rapid iteration without a database.

src/LiteBus.Inbox.Storage.InMemory · high confidence

The AMQP transport layer is now available, providing a shared connection manager that handles broker connectivity with circuit breaking, a message consumer that supports manual acknowledgement and configurable prefetch, and a publisher that routes messages to exchanges with configurable persistence and mandatory routing. The transport module registers these components via dependency injection, validates connection settings (including URI or discrete host/port/credentials), and exposes a diagnostic check to verify broker reachability. Users can now configure AMQP broker connections and use the transport for sending and receiving messages with full lifecycle and resilience controls.

src/LiteBus.Transport.Amqp · high confidence

Adds the AWS SQS transport implementation for LiteBus v6, including the \AwsSqsTransportModule\ for dependency registration, \SqsConsumer\ and \SqsPublisher\ for message handling, and \AwsSqsConnectivityDiagnosticCheck\ to verify SQS queue accessibility. The transport supports configurable long-poll wait times, visibility timeouts, and exponential backoff for requeue and poll failures. A new \packages.lock.json\ pins the \AWSSDK.SQS\ dependency.

src/LiteBus.Transport.AwsSqs · high confidence

A new IExecutionContext interface has been added to the messaging abstraction layer, providing a central hub for managing the state of a mediation operation. This interface introduces a CancellationToken for supporting operation cancellation, an Items dictionary for passing contextual data between handlers, and a Tags collection for filtering which handlers execute. It also exposes a MessageResult property and an Abort method, allowing pre-handlers or other pipeline components to terminate execution early and set a result. This change enables more flexible state sharing and control flow within the messaging pipeline.

src/LiteBus.Messaging.Abstractions/Contexts/Execution · high confidence

Added the \LiteBus.Inbox.Ingress.Kafka\ module, which registers a Kafka-based inbox ingress as a child module. This includes the \KafkaInboxIngressModule\ for dependency registration and background service hosting, along with configuration options (\KafkaInboxIngressOptions\) for topic destination, retry behavior, and safety settings. The module supports enabling or disabling the ingress consumer and configuring host options, effectively integrating Kafka transport into the inbox messaging pipeline.

src/LiteBus.Inbox.Ingress.Kafka · high confidence

The package now includes a comprehensive schema management system for PostgreSQL, featuring an extensible logging interface (IPostgreSqlSchemaLogger) with a default no-op implementation, a advisory lock mechanism to safely bootstrap schemas, and a schema inspector to validate table structures against expected versions. This adds new types for schema operations, including PostgreSqlSchemaManager, PostgreSqlSchemaInspector, and PostgreSqlAdvisoryLockScope, enabling applications to control schema creation, versioning, and logging behavior.

src/LiteBus.Storage.PostgreSql · high confidence

Added a suite of new PowerShell scripts in the \scripts\ directory to enforce build, documentation, and test coverage standards. \Test-Documentation\ and \Test-DocumentationSemantics\ validate markdown files for style, link integrity, and semantic correctness. \Test-Packages\ verifies that built NuGet packages contain required metadata, assets, and structure. \Test-CoverageThreshold\ and \run-coverage.ps1\ enforce minimum line and branch coverage thresholds. \Get-PackageInventory\ generates a reference table of package dependencies. These scripts collectively ensure that the repository's documentation, package outputs, and test coverage meet defined quality gates.

scripts · high confidence

Users can now configure and execute commands through a new \CommandMediator\ and \CommandModule\ in the \LiteBus.Commands\ package. The \CommandMediator\ orchestrates the command execution pipeline by delegating to a core \IMessageMediator\, supporting both void and typed command results. The \CommandModule\ handles the registration of command-specific services and discovered handlers, while the \CommandModuleBuilder\ provides a fluent API (\Register\, \RegisterFromAssembly\) to register command types and their associated pre/post/error handlers. This change adds the structural foundation for command handling within the LiteBus composition, relying on the \LiteBus.Messaging\ and \LiteBus.Runtime.Abstractions\ projects for underlying messaging and runtime abstractions.

src/LiteBus.Commands · high confidence

The library adds a new \CommandMediationSettings\ class that allows callers to pass contextual metadata and routing configuration (including tag-based filtering and handler predicates) when sending commands. This enables more granular control over which handlers participate in command processing. Alongside this, the diff introduces a suite of new interfaces to support this pipeline: \ICommandMediator\ for sending commands, \ICommandPreHandler\ and \ICommandPostHandler\ (with generic variants) for pre- and post-processing, \ICommandErrorHandler\ for exception handling, and \ICommandValidator\ for pre-processing validation. Additionally, \CommandMediatorExtensions\ are provided to simplify sending commands with optional tags. These changes represent a behavioral shift in how commands are routed and processed, moving towards a more configurable mediation pipeline.

src/LiteBus.Commands.Abstractions · high confidence

Added a new set of abstractions for durable messaging, including the \RetryBackoff\ enum for processor retry strategies, and several records for message envelope metadata: \Idempotency\ (with \None\ and \Keyed\ variants), \MessageIdentity\ (\Generated\ or \Supplied\), \MessageTrace\ (for correlation, causation, and distributed tracing), \MessageVisibility\ (immediate, at, or after delays), and \TenantScope\ (unscoped or isolated). Also added helper classes for idempotency scope keys, tenant ID normalization, and conflict handling (\IdempotencyConflictException\, \IdempotencyConflictMode\). These types define the contract for storing and querying durable messages, enabling features like deduplication, deferred processing, and multi-tenant isolation.

src/LiteBus.DurableMessaging.Abstractions/Durability, src/LiteBus.DurableMessaging.Abstractions/DurableMessaging · high confidence

Added new outbox processing capabilities to the LiteBus platform, including a background service for automatic outbox message cleanup based on retention policies, and comprehensive OpenTelemetry metrics and activity tracing for outbox operations. The update introduces extension methods to register the outbox module, configure storage and dispatchers, and enable the processor and cleanup loops. Users can now monitor outbox queue depth, processor state, and cleanup errors via standard observability tools.

src/LiteBus.Outbox · high confidence

Adds the core abstractions and implementations for durable saga management, including the \ISagaStore\ interface for optimistic concurrency control, the \ISagaContext\ for ambient state access, and the \SagaExecutionContext\ for managing dispatch scopes. The change introduces an in-memory \InMemorySagaStore\ for testing and local development, alongside a \SagaProcessorHook\ that loads and persists saga state around message dispatch. It also integrates with the inbox system via \InboxModuleBuilderSagaExtensions.EnableSaga\ and a \SagaInboxCommandScopePreHandler\ to ensure saga scope is active during in-process command handling.

src/LiteBus.Saga · high confidence

The \LiteBus.Events.Abstractions\ library now includes a full set of interfaces for the event mediator and its pipeline, including \IEventMediator\ for publishing events, \IEvent\ as the base event marker, and dedicated interfaces for pre-handlers (\IEventPreHandler\), post-handlers (\IEventPostHandler\), and error handling (\IEventErrorHandler\ and \IEventErrorHandler\<TEvent\>\). This allows developers to implement custom logic that runs before, after, or in case of failure during event processing.

src/LiteBus.Events.Abstractions · high confidence

Adds the \EventMediator\ implementation and the \EventModule\ configuration infrastructure to \src/LiteBus.Events\. This introduces a new module-based approach for registering and publishing events, including the \EventModuleBuilder\ for discovering and registering event types and handlers, and extension methods (\AddEvents\) to wire the event system into the LiteBus composition. The change also includes the \packages.lock.json\ file for the project.

src/LiteBus.Events · high confidence

Adds a new in-memory implementation of the outbox storage layer, providing a thread-safe, process-local store for unit tests and local development. The change introduces the \InMemoryOutboxStore\ class, which implements the full suite of outbox storage interfaces (e.g., \IOutboxStore\, \IOutboxProcessingStore\, \IOutboxOperationsStore\) and registers them via the \InMemoryOutboxStorageModule\. This allows developers to configure and use an in-memory outbox store through the \UseInMemoryStorage\ extension method, supporting options for capacity limits, lease durations, and time providers.

src/LiteBus.Outbox.Storage.InMemory, src/LiteBus.Transport.InMemory · high confidence

Added new modules that enable inbox ingress for Azure Service Bus and in-memory transports. Each module registers the necessary background services, handlers, and configuration options (such as destination, prefetch count, and safety settings) to process incoming messages into the inbox. The Azure Service Bus module includes specific options for subscription names, concurrent calls, and requeue behavior, while the in-memory module provides a simpler configuration for local queue processing.

src/LiteBus.Inbox.Ingress.AzureServiceBus, src/LiteBus.Inbox.Ingress.InMemory · high confidence

Added new abstractions for inbox message processing, including the IInboxDispatcher interface for executing leased envelopes, the IInboxProcessor interface for leasing and dispatching, and the IInboxProcessorControl interface for pausing, resuming, and draining the processor loop. Also added the ProcessorState enum to track background loop states (Running, Paused, Draining) and configuration options (InboxProcessorOptions, InboxProcessorHostOptions) to tune batch sizes and lease durations.

src/LiteBus.Inbox.Abstractions/Processing · high confidence

Added new abstractions for message contract management and serialization. The \IMessageContractRegistry\ interface, along with \IContractReader\ and \IContractWriter\, provides a unified way to register and resolve message types to stable contract names and versions. This allows the system to map CLR types to explicit, versioned contracts stored in envelopes, decoupling storage from CLR type names. Additionally, the \IMessageSerializer\ interface and \MessageSerializationException\ class were introduced to handle message serialization and associated errors.

src/LiteBus.Messaging.Abstractions/Contracts · high confidence

Added new internal classes ModuleConfiguration and ModuleRegistry to the LiteBus.Runtime.Modules namespace. ModuleConfiguration now manages the registration and ordering of startup tasks, background services, and diagnostic checks, while also handling shared context storage between modules. ModuleRegistry handles the registration of modules and computes their initialization order using topological sorting to ensure dependencies are respected. This change provides a structured way to configure and manage module lifecycles and dependencies within the runtime.

src/LiteBus.Runtime/Modules · high confidence

Adds a new query handling module to the LiteBus messaging framework, enabling in-process query mediation. The change introduces a \QueryMediator\ that routes queries through the core message mediator, supporting both single-result and streaming query execution. Registration is handled via \ModuleRegistryExtensions.AddQueries\ and \QueryModule\, which configure the \QueryModuleBuilder\ to discover and register query handlers and related contracts. This provides a structured way to manage query execution within the LiteBus composition pipeline.

src/LiteBus.Queries · high confidence

The LiteBus.Testing project now includes a new base class, LiteBusTestBase, which implements IAsyncDisposable to manage shared test infrastructure cleanup. Additionally, a ManualTimeProvider class has been added to allow tests to control the UTC clock for deterministic inbox, outbox, and storage tests. The project also includes a packages.lock.json file that records the resolved versions of dependencies such as Microsoft.SourceLink.GitHub and StyleCop.Analyzers.

src/LiteBus.Testing · high confidence

Added new files in the LiteBus.Inbox.Ingress project to implement the transport inbox ingress pipeline. This includes the TransportInboxIngressConsumer which manages the background service loop for consuming transport messages, and the TransportInboxIngressHandler which maps deliveries to inbox acceptance. The change also introduces the IngressAckPolicy to determine message requeue behavior on failure, along with supporting configuration options (TransportInboxIngressOptions, TransportInboxIngressHostOptions), telemetry definitions, and logging messages for ingress restarts and batch flush failures.

src/LiteBus.Inbox.Ingress · high confidence

Added new \TransportInboxDispatcher\ and \TransportOutboxDispatcher\ implementations that publish leased envelope payloads through a transport-agnostic message transport. These components map envelope metadata to transport headers, support optional payload protection and validation, and allow custom route resolution strategies. The change also introduces corresponding DI modules (\TransportInboxDispatchModule\, \TransportOutboxDispatchModule\) and configuration options (\TransportInboxDispatcherOptions\, \TransportOutboxDispatcherOptions\) to configure default destinations, content types, persistence, and mandatory routing behavior.

src/LiteBus.Inbox.Dispatch, src/LiteBus.Outbox.Dispatch · high confidence

Added new interfaces (IMessageErrorHandler, IAsyncMessageErrorHandler) and supporting types (MessageErrorContext, MessageErrorOutcome) to provide a strongly-typed, asynchronous error handling mechanism for message processing. This allows developers to implement custom error handlers that can inspect the original exception, the message, and the optional result, and control whether the pipeline suppresses or rethrows the exception.

src/LiteBus.Messaging.Abstractions/Handler/Error · high confidence

The \LiteBus.Messaging.Abstractions\ library now exposes new interfaces (\IMessagePostHandler\, \IMessagePostHandler\<TMessage, TMessageResult\>\, and their async counterparts) that allow developers to implement post-handling logic with strong typing. These interfaces enable post-processing steps to receive the original message and its initial result, supporting both synchronous and asynchronous execution contexts for more flexible message pipeline extensions.

src/LiteBus.Messaging.Abstractions/Handler/Post · high confidence

A new \PostgreSqlTableReference\ record is added to encapsulate the schema and table name pair used by LiteBus durable messaging. This value object replaces separate schema and table name parameters in logging, metadata lookups, and inspection calls, providing both a dot-qualified name and a quoted identifier for safer SQL generation and consistent error reporting.

LiteBus.Storage.PostgreSql · high confidence

The \LiteBus.Runtime.Abstractions\ package now provides a unified, framework-agnostic foundation for runtime behavior. It introduces \IBackgroundService\ for long-running host tasks, \ILiteBusBuilder\ for composition, and \IDependencyRegistry\ with \DependencyDescriptor\ to abstract dependency injection container interactions. Additionally, it adds a comprehensive diagnostics system including \IDiagnosticCheck\ for probes, \DiagnosticCheckRunner\ for execution, and \LiteBusHostManifest\ to aggregate startup tasks, background services, and diagnostic probes. This change isolates the runtime composition from specific messaging or transport implementations, allowing the core to remain independent of host adapters.

src/LiteBus.Runtime.Abstractions · high confidence

The \LiteBus.Runtime.Extensions.Hosting\ package now includes three new internal classes: \LiteBusHostOrchestrator\, which runs startup tasks sequentially before starting background service loops and stops the application if a background service faults; \BackgroundServiceHostWrapper\, which adapts \IBackgroundService\ to \IHostedService\ for manual test execution; and \HostingRegistrationHelpers\, which provides a utility to deduplicate types while preserving order. These changes are accompanied by a new \packages.lock.json\ file that pins the \Microsoft.Extensions.Hosting.Abstractions\ dependency to version 10.0.0 and its transitive dependencies.

src/LiteBus.Runtime.Extensions.Hosting · high confidence

Adds new abstractions and implementations for durable messaging, including \IInbox\ and \ITransactionalInbox\ interfaces for message acceptance, along with \InboxAcceptanceService\ and \Inbox\ classes that handle serialization, metadata mapping, and store persistence. The update also introduces \IInboxManager\ for querying, replaying, and purging inbox messages, as well as \InboxCleanupBackgroundService\ for automated retention cleanup. These changes provide a structured, transactional, and observable inbox mechanism within the LiteBus v6 platform.

src/LiteBus.Inbox · high confidence

The \LiteBus.DurableMessaging.Abstractions\ project now includes new interfaces and types that define the durable messaging contract. \IContextualPayloadEncryptor\ and \IPayloadEncryptor\ specify how payloads are encrypted and decrypted, with the former binding encryption to immutable durable metadata (message ID, contract name/version, tenant, and axis) to ensure ciphertext cannot be moved between rows or tenants. \PayloadProtectionContext\ holds this metadata. \MessageProcessorDiagnostics\ provides shared helpers for processing, including trace metadata propagation, error formatting, and validation of retry options. \MessageTraceContextKeys\ defines the keys for correlation, causation, tenant, and trace context. \ProcessorPassResult\ captures the outcome of a processor pass, including counts of succeeded, failed, and dead-lettered messages. \IMessageStoreRetentionOptions\ defines retention settings for inbox and outbox stores. These changes establish the core abstractions for durable messaging, encryption, and processing diagnostics.

src/LiteBus.DurableMessaging.Abstractions · high confidence

The \LiteBus.Messaging.Abstractions\ project now exposes a comprehensive set of interfaces and types that define the messaging pipeline. This includes \IMessageMediator\ and \IMessageMediationStrategy\ for routing and processing messages, along with \IMessageDependencies\ to access collections of pre, main, and post handlers. The change also introduces \IHandleContextData\ for sharing data during handling, \MessageMediationRequest\ for configuring mediation behavior, and \MessageContractAttribute\ for marking message types. Additionally, new interfaces for handler descriptors (\IHandlerDescriptor\, \IPreHandlerDescriptor\, \IPostHandlerDescriptor\, \IErrorHandlerDescriptor\) and message descriptors (\IMessageDescriptor\) are provided to support the registry and resolution strategies (\IMessageResolveStrategy\).

src/LiteBus.Messaging.Abstractions · high confidence

Adds new internal and public classes to support the v6 messaging architecture, including \ExecutionContext\ for managing execution state and cancellation, \HandleContextData\ for storing context data, and \MessageContractRegistry\ for registering and resolving message contracts. The update also introduces \SingleAsyncHandlerMediationStrategy\ and \SingleStreamHandlerMediationStrategy\ to handle message processing, along with \MediationResourceScope\ for managing resource disposal. Additionally, \DeclaredTypeMessageContractResolver\ is added to resolve contracts based on declared types, and \DurableEnvelopeMetadataMapper\ is introduced to map durable metadata to envelope columns.

src/LiteBus.Messaging · high confidence

The \LiteBus.Transport.Abstractions\ package now defines the core interfaces and types for the v6 transport layer. This includes \ITransportPublisher\ and \IMessageConsumer\ for sending and receiving messages, along with supporting types such as \TransportMessage\, \TransportPublishRequest\, \TransportConsumerOptions\, and \TransportConsumerAckHandlers\. The update also adds \TransportHeaders\ for standard header names, \TransportHeaderValues\ for header parsing, and \TransportHeaderMappingException\ for header validation errors. A \packages.lock.json\ file is added to pin the \Microsoft.SourceLink.GitHub\ and \StyleCop.Analyzers\ dependencies.

src/LiteBus.Transport.Abstractions · high confidence

The library now exposes a complete set of interfaces for the query pipeline, including IQueryMediator for executing and streaming queries, along with pre-handlers, post-handlers, and error handlers for both standard and stream queries. A new IQueryValidator interface allows developers to implement validation logic that runs before query processing. To simplify usage, extension methods on IQueryMediator provide convenient overloads for executing queries and streams, including support for tag-based routing via QueryMediationSettings. These changes establish the foundational API for the query side of the CQRS pattern within LiteBus.

src/LiteBus.Queries.Abstractions · high confidence

Adds a new Kafka transport implementation for LiteBus v6, enabling message publishing and consumption via Apache Kafka. The adapter registers a \KafkaTransportModule\ that wires up the \IProducer\, \IConsumer\, and \IAdminClient\ using \Confluent.Kafka\ (v2.8.0). It introduces a \KafkaConnectivityDiagnosticCheck\ for cluster health monitoring, a \KafkaConsumer\ with manual offset management and exponential backoff for seek failures, and a \KafkaPublisher\ with destination-scoped circuit breaking. Configuration is handled via \KafkaTransportOptions\, supporting settings for bootstrap servers, consumer groups, message timeouts, and seek failure backoff parameters.

src/LiteBus.Transport.Kafka · high confidence

The site/app directory now contains the full structure for the public LiteBus documentation site, including a redesigned landing page (page.tsx) with syntax highlighting and feature highlights, alongside global styles (globals.css) and layout (layout.tsx) that integrate Fumadocs UI and Tailwind CSS. A privacy policy page (privacy/page.tsx) is added, specifying that the site is hosted by Vercel and governed by GDPR, with no tracking cookies. Supporting files include site metadata (site.ts), a sitemap (sitemap.ts) that indexes static and dynamic documentation pages, a robots.txt generator (robots.ts) allowing all crawlers except /api/, and a content source loader (source.ts) for Markdown docs. This change prepares the documentation site for public production launch.

site/app · high confidence

The LiteBus.Runtime.Abstractions library introduces two new types to support v6 durable messaging and module composition. StoreSchemaInfo describes the expected and recorded schema versions for inbox/outbox stores, enabling diagnostics and version validation. ModuleDescriptor captures a module and its dependencies for initialization ordering, providing a Create factory that analyzes IRequires\<T\> interfaces to build a frozen set of dependencies. These additions align the runtime abstractions with the broader v6 solution changes.

LiteBus.Runtime.Abstractions · medium confidence

Added a new set of interfaces and configuration types for the durable messaging processor, including ILeaseRenewable, IMessageProcessor, IProcessorBackgroundControl, IProcessorPassRecorder, IProcessorWorkSignal, and ProcessorOptions. These changes introduce the core abstractions for managing message processing passes, lease renewal, background control, and performance tuning (batch size, concurrency, heartbeat intervals). Users will now have access to these new interfaces to implement custom processing logic and configure processor behavior.

src/LiteBus.DurableMessaging.Abstractions/Processing · high confidence

The library introduces a new settings hierarchy for controlling event handler execution. \EventMediationSettings\ now exposes \Execution\ (an \EventExecutionSettings\ object) that allows users to configure concurrency modes (sequential vs. parallel) for both priority groups and individual handlers. Additionally, \EventRoutingSettings\ provides a \HandlerPredicate\ (an \EventHandlerFilter\) for advanced, code-based filtering of handlers based on their metadata, alongside existing tag-based filtering. These changes enable more granular control over how and when event handlers are executed.

src/LiteBus.Events.Abstractions/Settings · high confidence

Added new exception classes in the LiteBus.Messaging.Abstractions library to provide more specific error handling for messaging scenarios. These include AmbiguousMessageResolveException for when multiple message descriptors match a type, NoHandlerFoundException when no handler is registered for a message, MultipleHandlerFoundException for unexpected multiple handlers, MessageContractMismatchException for contract registration conflicts, MessageContractNotRegisteredException for unregistered contracts, MessageDescriptorNotFoundException for missing descriptors, NoExecutionContextException for missing ambient context, UnsupportedOpenGenericHandlerException for invalid generic handlers, LiteBusExecutionAbortedException for aborted executions, and MessageContractAlreadyRegisteredException for duplicate registrations. These exceptions improve diagnostic clarity for developers configuring message mediation and contract registration.

src/LiteBus.Messaging.Abstractions/Exceptions · high confidence

Added new exception classes to handle specific error conditions for Entity Framework Core and PostgreSQL storage implementations. Specifically, EfCoreStorageNotSupportedException is introduced to signal unsupported database providers, while PostgreSqlStorageConfigurationException and PostgreSqlStorageTimeoutException are added to handle configuration errors and timeout scenarios respectively.

src/LiteBus.Storage.EntityFrameworkCore/Exceptions, src/LiteBus.Storage.PostgreSql/Exceptions · high confidence

The inbox abstraction layer now introduces a unified \InboxEnvelope\ record to represent a persisted inbox row, carrying fields for message identity, contract metadata, payload, status, and lease information. Alongside this, \InboxAcceptItem\ and its generic \InboxAcceptItem\<TMessage\>\ are introduced to describe message acceptance units for batch writers, supporting both typed and untyped batch operations with metadata for visibility, idempotency, and tracing.

LiteBus.Inbox.Abstractions · high confidence

The \src/LiteBus.Inbox.Abstractions/Store\ directory now contains a comprehensive set of new interfaces and supporting types that define the contract for a durable inbox store. This includes \IInboxStore\ for message acceptance, \IInboxProcessingStore\ for lease and state transitions, \IInboxOperationsStore\ for administrative operations, and specific interfaces for dead-lettering (\IInboxDeadLetterStore\), diagnostics (\IInboxDiagnosticsStore\), leasing (\IInboxLeaseStore\), querying (\IInboxMessageQuery\), purging (\IInboxPurgeStore\), retention (\IInboxRetentionStore\), and state writing (\IInboxStateWriter\). The change also introduces the \InboxStatus\ enum to represent message states (Pending, Processing, Completed, Failed, DeadLettered) and supporting request/response types like \InboxLeaseRequest\, \InboxMessageFilter\, and \InboxMessagePage\ to enable keyset pagination and filtering.

src/LiteBus.Inbox.Abstractions/Store · high confidence

The \LiteBus.Extensions.AspNetCore\ package now exposes a full set of HTTP management endpoints for inbox and outbox message stores, including query, requeue, purge, and processor state operations, all configurable via \LiteBusManagementOptions\ (route prefix, authorization, drain timeouts, and page size limits). Additionally, the \LiteBus.Extensions.Diagnostics.HealthChecks\ package introduces a \LiteBusHealthCheck\ that runs registered diagnostic probes and maps their results to ASP.NET Core health check statuses, with options to fail health checks when no probes are registered. These changes add new capabilities rather than modifying existing behavior.

src/LiteBus.Extensions.AspNetCore · high confidence

The library introduces a set of new interfaces in the \LiteBus.Messaging.Abstractions\ namespace to support more granular message processing. \IAsyncMessageHandler\ and \IMessageHandler\ now support asynchronous handling with optional results, enabling developers to process messages and return typed outcomes. \IStreamMessageHandler\ is added to support streaming multiple results from a single message via \IAsyncEnumerable\. Additionally, \IMessagePreHandler\ and its generic/async variants (\IAsyncMessagePreHandler\) allow pre-processing steps (like validation or transformation) to be executed before the main handler logic. These changes provide a unified, type-safe API for defining message handling pipelines.

src/LiteBus.Messaging.Abstractions/Handler/Main · high confidence

Added new abstractions for durable messaging orchestration: IProcessorEnvelope provides an axis-neutral view of leased processor envelopes (exposing MessageId, ContractName, ContractVersion, CorrelationId, CausationId, and TenantId), and IProcessorEnvelopeHook defines a lifecycle for pre- and post-dispatch processing. Host processors invoke BeforeDispatchAsync, PrepareDispatchScope, ShouldDispatch, AbandonDispatchScope, and AfterDispatchAsync around the axis dispatcher, enabling features like duplicate dispatch suppression and ambient state management during durable message processing.

src/LiteBus.DurableMessaging.Abstractions/Orchestration · medium confidence

The \LiteBus.Outbox.Abstractions\ package now provides a complete set of interfaces and types for durable messaging, including \IOutbox\ for standard enqueue, \ITransactionalOutbox\ for transactional enqueue, and \IOutboxManager\ for querying, replaying, and purging messages. The update introduces processor control via \IOutboxProcessorControl\ to pause, resume, or drain the background processing loop, and adds \OutboxStatus\ and \OutboxEnqueueOutcome\ enums to track message states. Additionally, it includes \IOutboxDispatcher\ for publishing leased messages, \IOutboxEnvelopeFactory\ for creating envelopes, and \IOutboxPayloadProtector\ for encryption, alongside supporting types like \OutboxReceipt\ and \OutboxEnqueueMetadata\.

src/LiteBus.Outbox.Abstractions · high confidence

The outbox abstraction layer now introduces a unified \OutboxEnvelope\ record to represent a persisted message row, carrying fields for status, lease, and idempotency. Enqueue commands are exposed via \OutboxEnqueueItem\ (non-generic) and \OutboxEnqueueItem\<TEvent\>\ (generic), which allow callers to attach durable metadata such as scheduled visibility, idempotency keys, and explicit message identities. These types provide the core data structures for the outbox system.

LiteBus.Outbox.Abstractions · high confidence

Added RetryOptions to configure retry behavior (max attempts, delays, backoff, jitter) for inbox and outbox processors, and introduced PersistResult to report applied and skipped envelope counts after terminal state writes, enabling processors to detect lease-lost conditions without inferring success from silent zero-row updates.

LiteBus.DurableMessaging.Abstractions · medium confidence

The LiteBus.Saga.Abstractions library introduces two new record types, SagaSaveItem and SagaCompleteItem, which serve as data transfer objects for saga persistence operations. SagaSaveItem carries the state snapshot and expected version for saving saga data, while SagaCompleteItem describes a saga completion with optimistic concurrency expectations. Both records support an optional appliedMessageId for tracking durable inbox messages, enabling more precise control over saga state management and completion handling.

LiteBus.Saga.Abstractions · high confidence

Added new static analysis classes in the LiteBus.Analyzers project to support the v6 messaging architecture. ContractRegistrationAnalysis discovers message types registered via Contracts.Register and assembly scanning. HandlerAnalysis identifies handler registrations and maps them to pipeline stages. MessageAnalysis collects command, query, and stream query message types and checks for handler coverage. ModuleConfigurationAnalysis validates inbox and outbox module builder configurations. TagReferenceAnalysis extracts tag references from mediator extension methods. These components provide the static analysis infrastructure for the new durable messaging and transport platform.

src/LiteBus.Analyzers/Analysis · high confidence

The LiteBus.Analyzers package introduces a suite of new Roslyn-based static analysis rules that enforce correct usage of the v6 messaging platform. The analyzer now detects duplicate or missing command and query handlers, ensuring each message type has exactly one main handler. It flags query handlers that depend on side-effecting mediators or durable writers, and warns about orphaned handler tags. For durable messaging, it enforces that transactional inbox and outbox storage are paired with a DbContext, and that background processors are enabled alongside a dispatcher. Additionally, it ensures commands with result types are not scheduled to the inbox, and that message types with \[MessageContract\] attributes are explicitly registered. These changes help developers catch configuration errors and architectural violations at compile time.

src/LiteBus.Analyzers · high confidence

Added test utilities to simulate and verify message bus behavior. The \LiteBus.Testing.Hosting\ package provides \LiteBusHostedServiceExtensions\ to start, stop, and assert background services. The \LiteBus.Testing.Mediation\ package introduces \TestCommandMediator\, \TestEventMediator\, and \TestQueryMediator\ to record and inspect commands, events, and queries. The \LiteBus.Testing.Transport\ package adds \TestMessageTransport\ to simulate message publishing and track published requests.

src/LiteBus.Testing.Hosting, src/LiteBus.Testing.Mediation, src/LiteBus.Testing.Transport · high confidence

The \LiteBus.Testing.DurableMessaging\ package now provides a complete testing harness for durable messaging. It introduces \InboxOutboxTestHost\ to spin up an isolated service provider with in-memory inbox and outbox storage, \InboxOutboxStoreServiceCollectionExtensions\ to register all inbox and outbox roles against a shared store, and \ProcessorPassHelpers\ to execute single processing passes. Additionally, \TestInboxStore\ and \TestOutboxStore\ offer in-memory store doubles for unit and integration tests, while \ChaosLeaseExpiryFixture\ enables simulating lease expiry during dispatch.

src/LiteBus.Testing.DurableMessaging · high confidence

The repository was initialized with a comprehensive set of governance and configuration files. This includes an \.editorconfig\ for C\# and ReSharper code styles, \AGENTS.md\ for AI agent instructions, \AI\_POLICY.md\ for AI use policy, and standard open-source files like \CODE\_OF\_CONDUCT.md\, \CONTRIBUTING.md\, \Changelog.md\, \SECURITY.md\, and \SUPPORT.md\. The project structure is defined by \LiteBus.slnx\, \global.json\ specifying .NET 10 SDK, \dotnet-tools.json\ for report generation, \coverlet.runsettings\ for code coverage, and \stylecop.json\ for documentation rules. The \LICENSE\ file was updated to reflect the Litenova copyright, and \README.md\ was updated with branding, badges, and a quick start guide.

(repo-wide) · high confidence

The \EventMediatorExtensions\ class was added to \src/LiteBus.Events.Abstractions/Extensions\, providing \PublishAsync\ overloads that accept a tag for routing context. This allows users to publish events with optional tags and cancellation tokens, simplifying the API for event mediation.

src/LiteBus.Events.Abstractions/Extensions · high confidence

The AMQP transport now exposes a dedicated AmqpCircuitBreakerOptions record to configure per-exchange publisher circuit breakers. Users can set the failure threshold and break duration, which are then mapped to the shared transport circuit breaker options.

LiteBus.Transport.Amqp · high confidence

A new \AmbientExecutionContext\ static class has been introduced to provide a thread-local, async-flow-aware storage mechanism for the current execution context. This allows data to be passed between message handlers and other components without explicit parameter passing, using an \AsyncLocal\-backed \Current\ property and a \CreateScope\ method for scoped context management.

src/LiteBus.Messaging.Abstractions/Contexts · medium confidence

New attributes are introduced to the messaging abstraction layer: HandlerPriorityAttribute allows developers to specify an integer priority for event handlers, where lower numbers execute before higher ones and handlers with the same priority execute together; HandlerTagAttribute and HandlerTagsAttribute enable tagging handlers with string-based contexts or scenarios, supporting single or multiple tags for conditional filtering.

src/LiteBus.Messaging.Abstractions/Handler · high confidence

The \MessageContextExtensions\ class is introduced to orchestrate the message handling lifecycle, providing dedicated extension methods to run pre-handlers, error handlers, and post-handlers. This change consolidates the execution of these handler pipelines, ensuring that error handling is explicitly managed and that post-handlers are invoked after message processing, with the original exception being rethrown if no error handlers are present.

src/LiteBus.Messaging.Abstractions/Extensions · high confidence

A new Cursor rule now requires XML documentation comments on every type, member, and field in the src/ directory, including private and internal members. The rule enforces specific formatting and the use of \<inheritdoc /\> for explicit interface implementations, and mandates running dotnet build to resolve StyleCop documentation warnings before completion.

.cursor · high confidence

The \AsyncBroadcastMediationStrategy\ now supports parallel execution of handlers, allowing multiple handlers to run concurrently based on configured concurrency modes. The strategy also groups handlers by priority (renamed from 'order') and executes them in parallel or sequential groups depending on settings, improving performance for broadcast scenarios.

src/LiteBus.Events/MediationStrategies · high confidence

A new \TransportInboxIngressSafetyOptions\ record has been added to define transport-independent safety bounds for inbox acceptance. This includes configurable limits for maximum message size, concurrent handler execution, and batch processing, along with validation to ensure these values remain within supported ranges. This change allows administrators to tune ingress behavior and enforce stricter security boundaries on incoming messages.

LiteBus.Inbox.Ingress · medium confidence

The runtime layer now includes a dedicated dependency management system. A new \DependencyRegistry\ and \DependencyRegistrationTracker\ enforce single-registration rules, preventing conflicting service bindings at configuration time. Additionally, a \LiteBusBuilder\ and \RootMessageDispatchScopeFactory\ are introduced to handle module composition and message dispatch scoping, providing a structured way to register dependencies and manage service lifetimes within the bus.

src/LiteBus.Runtime/Dependencies · high confidence

The PostgreSQL storage implementation was refactored to improve idempotency resolution and work signal management. A new \PostgreSqlBatchIdempotencyLookup\ class enables efficient batch lookups for skipped inserts, while \PostgreSqlIdempotencyResolution\ centralizes SQL generation for idempotency checks. Additionally, \PostgreSqlWorkSignal\ was introduced to manage PostgreSQL \NOTIFY\/\LISTEN\ channels with isolated reconnection logic, and \PostgreSqlParameterExtensions\ provides shared helpers for Npgsql parameter binding.

src/LiteBus.Storage.PostgreSql/Stores · medium confidence

The message registry has been refactored to separate concerns: a new \IMessageReader\ interface provides read-only access to message and handler descriptors for runtime resolution, while \IMessageWriter\ exposes the write surface for module configuration-time registration. The existing \IMessageRegistry\ now inherits from both, combining the two surfaces into a single singleton service for dependency injection.

src/LiteBus.Messaging.Abstractions/Registry · high confidence

Add unit tests for LiteBus C\# analyzers; Added AMQP transport integration tests for LavinMQ and RabbitMQ; Added Azure Service Bus test infrastructure for integration tests; Added Entity Framework Core integration tests for the inbox storage layer; Added PostgreSQL integration tests for inbox storage and processing; Added contract tests for inbox and outbox storage implementations; Added integration tests for AMQP and AWS SQS inbox ingress; Added integration tests for broker dispatch and ingress registration; Added integration tests for inbox dispatch across multiple transports; Added integration tests for management endpoints, health checks, and OpenTelemetry telemetry; Added test infrastructure and dependencies for LiteBus storage tests; Added unit tests for AMQP inbox ingress handler and module registration; Added unit tests for AMQP transport components; Added unit tests for ASP.NET Core management endpoints and Autofac integration; Added unit tests for AWS SQS transport diagnostics, module registration, message mapping, and backoff logic; Added unit tests for Entity Framework Core inbox and outbox storage modules; Added unit tests for W3C trace context parsing; Added unit tests for command and event module behavior; Added unit tests for durable adapter module registration guards; Added unit tests for durable messaging value objects and composition smoke tests; Added unit tests for error handling in commands, events, and queries; Added unit tests for in-memory transport implementation; Added unit tests for inbox and outbox durability, encryption, and management operations; Added unit tests for inbox dispatch mechanisms; Added unit tests for inbox ingress handling and mapping; Added unit tests for inbox, mediator, and integration fixtures; Added unit tests for messaging and mediation behavior; Added unit tests for outbox dispatching and envelope mapping; Added unit tests for payload protection and JSON serialization; Added unit tests for query mediator validation and module prerequisites; Added unit tests for saga persistence, schema validation, and processor hooks; Added unit tests for the LiteBus mediator and extension methods; Added unit tests for transport connectivity diagnostics and module registration; Added unit tests for transport diagnostics, circuit breakers, and tracing; New test infrastructure for durable transport integration tests; Refactored Kafka integration test infrastructure.

The repository introduces centralized package version management via new \Directory.Packages.props\ files in the \benchmarks\ and \src\ directories, which define specific versions for dependencies like \Autofac\, \Microsoft.EntityFrameworkCore\, \xunit\, and \OpenTelemetry\. This is accompanied by the addition of numerous new \.csproj\ files that structure the LiteBus v6 codebase into distinct modules, including \LiteBus.Commands\, \LiteBus.Events\, \LiteBus.Inbox\, \LiteBus.Outbox\, and their respective extensions for Autofac and Microsoft DI. Additionally, a new \site\ directory is added with \package.json\ and \package-lock.json\ files to support the Fumadocs documentation site.

(dependencies) · high confidence

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

• CAI 60 → 60 (-0.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 88 → 71 (-16.7)
• Architecture 87 → 87 (+0.3)
• Maturity 71 → 80 (+9.4)
• Readiness 62 → 65 (+3.2)
• Security 50 → 48 (-1.9)
• Event-Driven 100 → 100 (+0.0)
• Accessibility 78 → 78 (+0.0)
• Performance 70 → 68 (-1.3)

• Bounded contexts not declared
• Deprecated: Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit
• Deprecated: xunit
• Duplicated block (12 lines × 2) (src/LiteBus.Analyzers/Analysis/ModuleConfigurationAnalysis.cs)
• Duplicated block (14 lines × 3) (src/LiteBus.Inbox.Abstractions/InboxReceiptMapper.cs)
• Duplicated block (15 lines × 2) (src/LiteBus.Inbox.Storage.PostgreSql/PostgreSqlInboxStore.cs)
• Duplicated block (15 lines × 4) (src/LiteBus.Commands/CommandModule.cs)
• Duplicated block (15 lines × 5) (src/LiteBus.Inbox.Ingress.Amqp/AmqpInboxIngressModule.cs)
• Duplicated block (16 lines × 2) (src/LiteBus.Analyzers/Analysis/ModuleConfigurationAnalysis.cs)
• Duplicated block (16 lines × 2) (src/LiteBus.Inbox/InboxModule.cs)
• Duplicated block (16 lines × 2) (src/LiteBus.Messaging.Abstractions/Contracts/MessageContractBuilder.cs)
• Duplicated block (16 lines × 2) (src/LiteBus.Outbox.Storage.InMemory/InMemoryOutboxStorageModule.cs)
• Duplicated block (16 lines × 3) (src/LiteBus.Inbox.Storage.EntityFrameworkCore/EfCoreInboxStore.cs)
• Duplicated block (17 lines × 2) (src/LiteBus.Analyzers/TransactionalInboxWithoutDbContextAnalyzer.cs)
• Duplicated block (17 lines × 2) (src/LiteBus.Inbox.Storage.EntityFrameworkCore/EfCoreInboxStore.cs)
• Duplicated block (17 lines × 2) (src/LiteBus.Transport.InMemory/InMemoryConsumer.cs)
• Duplicated block (17 lines × 3) (src/LiteBus.Outbox.Storage.EntityFrameworkCore/EfCoreOutboxStore.cs)
• Duplicated block (18 lines × 2) (src/LiteBus.Inbox/InboxProcessorControl.cs)
• Duplicated block (18 lines × 3) (src/LiteBus.Inbox.Ingress.AwsSqs/AwsSqsInboxIngressModule.cs)
• Duplicated block (20 lines × 2) (src/LiteBus.Inbox/InboxProcessorControl.cs)
• …and 68 more

• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (src/.editorconfig)
• AnalyzerSeverityNone (tests/.editorconfig)
• AnalyzerSeverityNone (tests/.editorconfig)
• …and 381 more

• Unchanged — 2 HTTP endpoints

• Unchanged — 2 containers · 8 contexts · 9 edges

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

litenova/LiteBus 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.