How to set up Obvs with RabbitMQ in .NET Core?

Install the Obvs.RabbitMQ NuGet package, then use the fluent configuration to define endpoints with the broker connection string. The README's ActiveMQ example adapts easily—just replace the transport method and specify serialization like JSON.

Obvs vs MassTransit: which is better for microservices?

Obvs is a lightweight, library-based approach ideal for transport flexibility and Rx integration, while MassTransit is a full framework with built-in features like sagas and retries. Choose Obvs for minimal overhead and custom control; opt for MassTransit if you need out-of-the-box tooling.

Can I use Obvs without the IMessage interfaces?

Yes, Obvs provides a generic ServiceBus that allows custom message types without implementing IMessage, but you'll lose convention-based benefits like auto-discovery and multiplexing, requiring more manual configuration.

How to handle errors in Obvs messaging?

Obvs catches exceptions and raises them on an asynchronous error channel, as noted in the README. Subscribe to this channel to log or handle failures, ensuring errors don't disrupt the entire reactive stream.

Does Obvs support .NET 5 or .NET 6?

Yes, Obvs V6 supports net5.0 and netstandard2.0, per the version roadmap. It's compatible with modern .NET versions, including .NET Core and .NET 5/6, for cross-platform development.

Setting up custom endpoints for external APIs in Obvs?

Implement IServiceEndpointClient to wrap API calls, define methods for sending commands and handling events as observables, then add the endpoint to the ServiceBus configuration—the README example illustrates this with a custom class.

Performance overhead of Obvs compared to raw transport clients?

Obvs adds abstraction layers with Rx and multiplexing, which may introduce slight latency, but it optimizes with efficient serialization and reduces code complexity. For most distributed systems, the trade-off in flexibility outweighs minimal performance impacts.

Open-Awesome

Obvs

MITC#v6.0.0

A .NET library providing observable microservice buses with Reactive Extensions interfaces over multiple message transports.

Visit Website GitHub

338 stars45 forks0 contributors

What is Obvs?

Obvs is a .NET library that provides observable microservice buses, wrapping underlying message transports like ActiveMQ, RabbitMQ, or Kafka with Reactive Extensions (Rx) interfaces. It simplifies building decoupled, event-driven microservices by offering a consistent programming model across different transports. The library focuses on flexibility, allowing developers to mix transports and serialization formats as needed.

Target Audience

.NET developers building microservices or distributed systems who want to use reactive programming patterns and need transport-agnostic messaging solutions. It's ideal for teams looking to avoid vendor lock-in and maintain flexibility in their architecture.

Value Proposition

Developers choose Obvs for its simplicity and transport independence—it's a library, not a framework, so you use only what you need. Its integration with Reactive Extensions enables powerful composition of asynchronous data streams, while support for multiple transports and serialization formats reduces migration headaches.

Overview

An observable microservice bus library for .NET, that wraps the underlying message transports in simple Rx based interfaces.

Use Cases

Best For

Building decoupled microservices with reactive programming in .NET
Migrating between message brokers (e.g., RabbitMQ to Kafka) with minimal code changes
Creating transport-agnostic event-driven architectures
Integrating external APIs into a consistent messaging system via custom endpoints
Developing systems that require flexible serialization formats (JSON, ProtoBuf, XML)
Implementing local in-memory messaging for testing or non-distributed scenarios

Not Ideal For

Teams preferring full-fledged frameworks with built-in saga orchestration and advanced tooling
Developers unfamiliar with Reactive Extensions who need a simpler, callback-based messaging approach
Projects requiring deep, low-level integration with specific broker features like Kafka partitions
Applications that are primarily synchronous and don't benefit from reactive streaming complexities

Pros & Cons

Pros

Transport Agnosticism

Allows seamless migration between brokers like ActiveMQ, RabbitMQ, and Kafka with minimal code changes, as emphasized in the README's transport-agnostic design.

Reactive Extensions Integration

Leverages System.Reactive for composing asynchronous data streams, enabling powerful event handling with IObservable interfaces, as shown in command and event subscriptions.

Convention-Based Messaging

Auto-discovers message contracts and multiplexes types over single topics, reducing boilerplate code through dynamic deserializer creation.

Flexible Serialization Options

Supports multiple formats like JSON, ProtoBuf, and XML, with the ability to write custom serializers, adapting to various performance and compatibility needs.

Local Development Support

Includes an in-memory bus option for testing or non-distributed scenarios, simplifying development without external dependencies.

Cons

Rx Learning Curve

Requires familiarity with Reactive Extensions concepts, which can be a barrier for teams not already using Rx in their .NET stack, as the library heavily relies on IObservable patterns.

Limited Advanced Features

Lacks built-in support for common microservices patterns like sagas or compensation, unlike more comprehensive frameworks such as NServiceBus or MassTransit.

Custom Endpoint Complexity

Creating endpoints for external APIs involves manually implementing IServiceEndpointClient, as shown in the example, which can be time-consuming and error-prone.

Ecosystem Maturity

Has a smaller community and fewer third-party extensions compared to established frameworks, potentially affecting long-term support and integration options.

Frequently Asked Questions

Related Projects

Polly

Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. From version 6.0.1, Polly targets .NET Standard 1.1 and 2.0+.

Stars14,202

Forks1,276

Last commit4 days ago

.NET API Gateway

AspNetCore.Diagnostics.HealthChecks

Enterprise HealthChecks for ASP.NET Core Diagnostics Package

Stars4,368

Forks865

Last commit9 days ago

Foundatio

Pluggable foundation blocks for building distributed apps.

Stars2,091

Forks251

Last commit19 hours ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub