shared_broker 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d47439f3383e9d40d13664b67dc8b77318b64f628e6a1efa0f4684130ff2ff4b
-  data.tar.gz: 85d081f58ac1608a1629b29f14c634b370b963c65338eb7f9a32ace26bc90502
+  metadata.gz: b161a64893a9f15f9bb4568c1b281c2851904bc9e8730e8992d5f6d0847a4de4
+  data.tar.gz: 6a771b8df2dc371516b2d7f97d6e157ff493141034106c40236f952c6aef0f2e
 SHA512:
-  metadata.gz: 25151e9182b26d17334f04b121831703eee6c8b95981ac2b235085472501f06ec97c2a6b14cedc434dd3ee49963577b8eceedc175680525025d31e3246ac81dd
-  data.tar.gz: 07cb36e946dd24260fdd70d7cd995f4aeae8167b764d1df18e2026bc523481ec4d788308f720494472985a3b1a4adc7ae8751ded5abbd20b02c8c475c10a97c6
+  metadata.gz: '06494d11f1575ac5e13353acad3e9896f9ff7e5b7f64b164cecaa39b492aadeb170590e2ec9c9628c80691d08fc521e07e384fa43d2fe4e7874424704e39aedb'
+  data.tar.gz: 6781b513d75bd232c5c75738a6078aad08d096133e410335ec707ac203548b653af222bbb37ee7594fff40044e8122f8e362b12f68927939a7a19655f021ca16

data/CHANGELOG.md

@@ -1,45 +1,60 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [1.2.0] - 2026-06-07
-
-### Added
-- Pipeline of customizable Middlewares (Interceptors) for publishing and subscribing messages.
-- Distributed Tracing using W3C Trace Context (`traceparent`/`tracestate`) context injection and extraction.
-
-## [1.1.1] - 2026-06-06
-
-### Changed
-- Restructured `README.md` to clearly separate minimum required configuration from optional/advanced setups.
-
-## [1.1.0] - 2026-06-06
-
-### Added
-- Scalable Adapters:
-  - Apache Kafka adapter (`SharedBroker::Adapters::Kafka`) with dynamic dependency loading.
-  - Redis Pub/Sub adapter (`SharedBroker::Adapters::Redis`) with list-based DLQ routing.
-  - Mock test configurations for Kafka and Redis to run adapter unit tests.
-
-## [1.0.0] - 2026-06-06
-
-### Added
-- Fault Tolerance & Resilience features:
-  - Exponential backoff retry loop for message processing.
-  - Automatic Dead Letter Queue (DLQ) routing with rich metadata headers (`x_failed_at`, `x_exception_class`, `x_exception_message`, `x_original_routing_key`).
-  - Thread-safe `CircuitBreaker` wrapping all outbound publisher calls.
-- Schema Validation and Security:
-  - Outbound/Inbound boundary validation using `dry-schema`.
-  - Transparent AES-256-GCM symmetric payload encryption by default, configurable with `SharedBroker.encryption_key`.
-- Comprehensive test coverage for all the above features using isolated fakes and Minitest.
-
-## [0.1.0] - 2026-06-06
-
-### Added
-- Initial release with the pluggable `Client` messaging system.
-- `InMemory` adapter for local testing.
-- `RabbitMQ` adapter using the `bunny` gem.
-- Basic OpenTelemetry instrumentation utility (`SharedBroker::Telemetry`).
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.4.0] - 2026-06-10
+
+### Added
+- Schema Registry Integration. Support for pluggable schema registries allowing dynamic schema validation during `publish` and `subscribe` actions.
+- `Local` Schema Provider (default) leveraging `dry-schema` for backward compatibility.
+- `Http` Schema Provider fetching JSON schemas over HTTP/HTTPS with in-memory caching and TTL.
+- Validation using standard JSON Schema syntax for the `Http` provider.
+
+## [1.3.0] - 2026-06-08
+
+### Added
+- Hybrid Multi-Adapter Routing to allow publishing and subscribing to different broker adapters (e.g., RabbitMQ, Kafka, Redis, or InMemory) dynamically.
+- Support for exact match and wildcard matching (using File.fnmatch? glob patterns) routing rules, with default fallback adapter.
+- Full backward compatibility with legacy single-adapter initialization.
+
+## [1.2.0] - 2026-06-07
+
+### Added
+- Pipeline of customizable Middlewares (Interceptors) for publishing and subscribing messages.
+- Distributed Tracing using W3C Trace Context (`traceparent`/`tracestate`) context injection and extraction.
+
+## [1.1.1] - 2026-06-06
+
+### Changed
+- Restructured `README.md` to clearly separate minimum required configuration from optional/advanced setups.
+
+## [1.1.0] - 2026-06-06
+
+### Added
+- Scalable Adapters:
+  - Apache Kafka adapter (`SharedBroker::Adapters::Kafka`) with dynamic dependency loading.
+  - Redis Pub/Sub adapter (`SharedBroker::Adapters::Redis`) with list-based DLQ routing.
+  - Mock test configurations for Kafka and Redis to run adapter unit tests.
+
+## [1.0.0] - 2026-06-06
+
+### Added
+- Fault Tolerance & Resilience features:
+  - Exponential backoff retry loop for message processing.
+  - Automatic Dead Letter Queue (DLQ) routing with rich metadata headers (`x_failed_at`, `x_exception_class`, `x_exception_message`, `x_original_routing_key`).
+  - Thread-safe `CircuitBreaker` wrapping all outbound publisher calls.
+- Schema Validation and Security:
+  - Outbound/Inbound boundary validation using `dry-schema`.
+  - Transparent AES-256-GCM symmetric payload encryption by default, configurable with `SharedBroker.encryption_key`.
+- Comprehensive test coverage for all the above features using isolated fakes and Minitest.
+
+## [0.1.0] - 2026-06-06
+
+### Added
+- Initial release with the pluggable `Client` messaging system.
+- `InMemory` adapter for local testing.
+- `RabbitMQ` adapter using the `bunny` gem.
+- Basic OpenTelemetry instrumentation utility (`SharedBroker::Telemetry`).

data/README.md

@@ -1,155 +1,204 @@
-# SharedBroker
-
-`SharedBroker` is a high-performance Ruby library designed to simplify event-based communication (asynchronous messaging) and telemetry (observability) in Rails microservice architectures.
-
-The library implements the **Adapter Pattern** to decouple your application from physical queue providers, allowing easy broker swapping and clean synchronous testing with an in-memory adapter.
-
----
-
-## Key Features
-
-- **Pluggable Messaging**: Adapter pattern supporting:
-  - `InMemory`: Synchronous local simulation for fast TDD testing (no inline external I/O stubs required).
-  - `RabbitMQ`: Robust connection using the `bunny` gem.
-  - `Kafka`: High-throughput adapter using the `kafka` gem.
-  - `Redis`: Light-weight Pub/Sub broker using the `redis` gem.
-- **Resilience & Fault Tolerance**:
-  - **Automatic Retry**: Automatic retry mechanism on message processing failures using exponential backoff.
-  - **Dead Letter Queue (DLQ)**: Messages that exhaust their retries are automatically moved to a DLQ (`#{queue_name}.dlq` or a custom topic/list depending on the adapter) containing error metadata headers.
-  - **Circuit Breaker**: Integrated thread-safe Circuit Breaker wrapping message publication to prevent cascading failures.
-- **Security & Data Validation**:
-  - **Strict Schema Validation**: Integration with `dry-schema` to validate message structures on both publish (boundaries out) and subscribe (boundaries in).
-  - **Transparent Payload Encryption**: Payloads are automatically encrypted at rest using AES-256-GCM via `SharedBroker.encryption_key`.
-- **Integrated OpenTelemetry**: Centralized SDK configuration with auto-instrumentation for all supported libraries (ActiveRecord, Bunny, Faraday, Rails, PG, etc.).
-
----
-
-## Installation
-
-Add this line to your application's `Gemfile`:
-
-```ruby
-gem "shared_broker", path: "gems/shared_broker" # for local gem
-# or when published:
-# gem "shared_broker"
-```
-
-And execute:
-
-```bash
-bundle install
-```
-
----
-
-## Configuration
-
-Create an initializer in your Rails application (`config/initializers/shared_broker.rb`). Below is the breakdown of what is **required** versus what is **optional**.
-
-### 1. Required Configuration (Minimum Setup)
-
-You must configure the adapter depending on the environment, initialize the client, and configure the payload encryption key (required since AES-256-GCM is active by default):
-
-```ruby
-require "shared_broker"
-
-# A. Configure Payload Encryption Key (AES-256-GCM)
-# Expects a 32-byte string. Use a secure production key in production.
-SharedBroker.encryption_key = ENV.fetch("SHARED_BROKER_ENCRYPTION_KEY") { "a" * 32 }
-
-# B. Configure the Adapter based on Environment
-if Rails.env.test?
-  # In-memory adapter prevents external queue dependency during unit tests
-  BROKER_ADAPTER = SharedBroker::Adapters::InMemory.new
-else
-  # Connects to real RabbitMQ broker
-  amqp_url = ENV.fetch("RABBITMQ_URL") { "amqp://guest:guest@localhost:5672" }
-  BROKER_ADAPTER = SharedBroker::Adapters::RabbitMQ.new(amqp_url: amqp_url)
-end
-
-# C. Instantiate the Client by Injecting the Adapter
-SPOT_BROKER = SharedBroker::Client.new(adapter: BROKER_ADAPTER)
-```
-
----
-
-### 2. Optional Configuration
-
-These features can be configured optionally depending on your needs.
-
-#### A. Event Payload Validation (dry-schema)
-Register schemas to validate payload structure automatically on outbound (`publish`) and inbound (`subscribe`) boundaries:
-
-```ruby
-user_created_schema = Dry::Schema.Params do
-  required(:id).filled(:integer)
-  required(:email).filled(:string)
-end
-
-SharedBroker::Validation.register("user.created", user_created_schema)
-```
-
-#### B. Custom Circuit Breaker
-By default, the client instantiates a standard Circuit Breaker. You can provide a custom one to tune the failure threshold and recovery window:
-
-```ruby
-custom_circuit_breaker = SharedBroker::CircuitBreaker.new(
-  failure_threshold: 5,   # trip circuit after 5 failures
-  recovery_timeout: 30    # wait 30 seconds before attempting recovery
-)
-
-SPOT_BROKER = SharedBroker::Client.new(
-  adapter: BROKER_ADAPTER,
-  circuit_breaker: custom_circuit_breaker
-)
-```
-
-#### C. Initialize Distributed Tracing (OpenTelemetry)
-Initialize the OpenTelemetry SDK with auto-instrumentation for the microservice:
-
-```ruby
-SharedBroker::Telemetry.configure(service_name: "my_microservice")
-```
-
----
-
-## Usage
-
-### Publishing Events
-Send events by passing the topic name and a structured payload (must be a `Hash`):
-
-```ruby
-event_data = {
-  id: 1,
-  email: "test@example.com"
-}
-
-# The payload will be validated against its dry-schema, encrypted, and published safely.
-SPOT_BROKER.publish("user.created", event_data)
-```
-
-### Subscribing to Events (Consumer with Retry and DLQ)
-To start a persistent event subscriber daemon, register a queue/group name associated with the topic. You can customize the retries and backoff rate:
-
-```ruby
-SPOT_BROKER.subscribe("user.created", "my_consumption_queue", max_retries: 3, backoff_base: 2) do |payload|
-  puts "Decrypted event successfully validated & consumed! ID: #{payload[:id]}"
-  # execute your business logic here...
-end
-```
-
----
-
-## Running Gem Tests
-
-To run the unit test suite using **Minitest**:
-
-```bash
-bundle exec rake test
-```
-
----
-
-## License
-
-This Gem is available under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+[![Gem Version](https://badge.fury.io/rb/shared_broker.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/shared_broker)
+
+# SharedBroker
+
+`SharedBroker` is a high-performance Ruby library designed to simplify event-based communication (asynchronous messaging) and telemetry (observability) in Rails microservice architectures.
+
+The library implements the **Adapter Pattern** to decouple your application from physical queue providers, allowing easy broker swapping and clean synchronous testing with an in-memory adapter.
+
+---
+
+## Key Features
+
+- **Pluggable Messaging**: Adapter pattern supporting:
+  - `InMemory`: Synchronous local simulation for fast TDD testing (no inline external I/O stubs required).
+  - `RabbitMQ`: Robust connection using the `bunny` gem.
+  - `Kafka`: High-throughput adapter using the `kafka` gem.
+  - `Redis`: Light-weight Pub/Sub broker using the `redis` gem.
+- **Resilience & Fault Tolerance**:
+  - **Automatic Retry**: Automatic retry mechanism on message processing failures using exponential backoff.
+  - **Dead Letter Queue (DLQ)**: Messages that exhaust their retries are automatically moved to a DLQ (`#{queue_name}.dlq` or a custom topic/list depending on the adapter) containing error metadata headers.
+  - **Circuit Breaker**: Integrated thread-safe Circuit Breaker wrapping message publication to prevent cascading failures.
+- **Security & Data Validation**:
+  - **Strict Schema Validation**: Integration with `dry-schema` to validate message structures on both publish (boundaries out) and subscribe (boundaries in).
+  - **Transparent Payload Encryption**: Payloads are automatically encrypted at rest using AES-256-GCM via `SharedBroker.encryption_key`.
+- **Integrated OpenTelemetry**: Centralized SDK configuration with auto-instrumentation for all supported libraries (ActiveRecord, Bunny, Faraday, Rails, PG, etc.).
+
+---
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem "shared_broker", path: "gems/shared_broker" # for local gem
+# or when published:
+# gem "shared_broker"
+```
+
+And execute:
+
+```bash
+bundle install
+```
+
+---
+
+## Configuration
+
+Create an initializer in your Rails application (`config/initializers/shared_broker.rb`). Below is the breakdown of what is **required** versus what is **optional**.
+
+### 1. Required Configuration (Minimum Setup)
+
+You must configure the adapter depending on the environment, initialize the client, and configure the payload encryption key (required since AES-256-GCM is active by default):
+
+```ruby
+require "shared_broker"
+
+# A. Configure Payload Encryption Key (AES-256-GCM)
+# Expects a 32-byte string. Use a secure production key in production.
+SharedBroker.encryption_key = ENV.fetch("SHARED_BROKER_ENCRYPTION_KEY") { "a" * 32 }
+
+# B. Configure the Adapter based on Environment
+if Rails.env.test?
+  # In-memory adapter prevents external queue dependency during unit tests
+  BROKER_ADAPTER = SharedBroker::Adapters::InMemory.new
+else
+  # Connects to real RabbitMQ broker
+  amqp_url = ENV.fetch("RABBITMQ_URL") { "amqp://guest:guest@localhost:5672" }
+  BROKER_ADAPTER = SharedBroker::Adapters::RabbitMQ.new(amqp_url: amqp_url)
+end
+
+# C. Instantiate the Client by Injecting the Adapter
+SPOT_BROKER = SharedBroker::Client.new(adapter: BROKER_ADAPTER)
+```
+
+---
+
+### 2. Optional Configuration
+
+These features can be configured optionally depending on your needs.
+
+#### A. Event Payload Validation & Schema Registry
+
+`SharedBroker` supports validation on outbound (`publish`) and inbound (`subscribe`) boundaries. It includes a pluggable **Schema Registry** supporting both local definitions and remote registry servers.
+
+##### A1. Local Validation (dry-schema - default)
+Register schemas to validate payload structure locally using `dry-schema`:
+
+```ruby
+user_created_schema = Dry::Schema.Params do
+  required(:id).filled(:integer)
+  required(:email).filled(:string)
+end
+
+# Registered on the default local provider
+SharedBroker::Validation.register("user.created", user_created_schema)
+```
+
+##### A2. Http Schema Registry (JSON Schema)
+Configure `SharedBroker` to fetch schemas dynamically from an HTTP-based Schema Registry. The HTTP provider validates payloads using the standard JSON Schema specification and caches schemas in-memory to prevent validation latency:
+
+```ruby
+# Configure the HTTP Schema Registry provider
+SharedBroker::SchemaRegistry.provider = SharedBroker::SchemaRegistry::Providers::Http.new(
+  url: "https://schema-registry.mycorp.internal",
+  headers: { "Authorization" => "Bearer my-secret-token" },
+  cache_ttl: 300 # cache schemas in-memory for 5 minutes
+)
+```
+When configured with the HTTP provider, any published or subscribed event will automatically trigger a lookup against `https://schema-registry.mycorp.internal/schemas/{topic}.json`.
+
+
+#### B. Custom Circuit Breaker
+By default, the client instantiates a standard Circuit Breaker. You can provide a custom one to tune the failure threshold and recovery window:
+
+```ruby
+custom_circuit_breaker = SharedBroker::CircuitBreaker.new(
+  failure_threshold: 5,   # trip circuit after 5 failures
+  recovery_timeout: 30    # wait 30 seconds before attempting recovery
+)
+
+SPOT_BROKER = SharedBroker::Client.new(
+  adapter: BROKER_ADAPTER,
+  circuit_breaker: custom_circuit_breaker
+)
+```
+
+#### C. Initialize Distributed Tracing (OpenTelemetry)
+Initialize the OpenTelemetry SDK with auto-instrumentation for the microservice:
+
+```ruby
+SharedBroker::Telemetry.configure(service_name: "my_microservice")
+```
+
+#### D. Hybrid Multi-Adapter Routing
+If your system requires directing different topics to different message brokers (e.g., Kafka for telemetry, RabbitMQ for transactional events, Redis for quick cache invalidation), you can configure `SharedBroker::Client` with multiple adapters and a routing table:
+
+```ruby
+# 1. Initialize physical adapters
+rabbit_adapter = SharedBroker::Adapters::RabbitMQ.new(amqp_url: "amqp://guest:guest@localhost:5672")
+kafka_adapter  = SharedBroker::Adapters::Kafka.new(seed_brokers: ["localhost:9092"])
+redis_adapter  = SharedBroker::Adapters::Redis.new(redis_url: "redis://localhost:6379")
+
+# 2. Instantiate the Client in Hybrid mode
+HYBRID_BROKER = SharedBroker::Client.new(
+  adapters: {
+    rabbitmq: rabbit_adapter,
+    kafka:    kafka_adapter,
+    redis:    redis_adapter
+  },
+  routing: {
+    # Exact routing match
+    "payment.processed" => :rabbitmq,
+    # Wildcard routing match
+    "telemetry.*"       => :kafka,
+    "cache.*"           => :redis,
+    # Default fallback routing
+    "*"                 => :rabbitmq
+  }
+)
+```
+
+---
+
+## Usage
+
+### Publishing Events
+Send events by passing the topic name and a structured payload (must be a `Hash`):
+
+```ruby
+event_data = {
+  id: 1,
+  email: "test@example.com"
+}
+
+# The payload will be validated against its dry-schema, encrypted, and published safely.
+SPOT_BROKER.publish("user.created", event_data)
+```
+
+### Subscribing to Events (Consumer with Retry and DLQ)
+To start a persistent event subscriber daemon, register a queue/group name associated with the topic. You can customize the retries and backoff rate:
+
+```ruby
+SPOT_BROKER.subscribe("user.created", "my_consumption_queue", max_retries: 3, backoff_base: 2) do |payload|
+  puts "Decrypted event successfully validated & consumed! ID: #{payload[:id]}"
+  # execute your business logic here...
+end
+```
+
+---
+
+## Running Gem Tests
+
+To run the unit test suite using **Minitest**:
+
+```bash
+bundle exec rake test
+```
+
+---
+
+## License
+
+This Gem is available under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/shared_broker/schema_registry/providers/http.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "json-schema"
+
+module SharedBroker
+  module SchemaRegistry
+    module Providers
+      class Http
+        def initialize(url:, headers: {}, cache_ttl: 300)
+          @base_url = url.chomp("/")
+          @headers = headers
+          @cache_ttl = cache_ttl
+          @cache = {}
+        end
+
+        def validate!(topic, payload)
+          schema = fetch_schema(topic)
+          return unless schema
+
+          begin
+            JSON::Validator.validate!(schema, payload)
+          rescue JSON::Schema::ValidationError => e
+            raise SharedBroker::Validation::ValidationError,
+                  "Schema validation failed for topic #{topic.inspect} against schema #{schema.inspect}. Offending payload: #{payload.inspect}. Error: #{e.message}"
+          end
+        end
+
+        def clear_cache
+          @cache.clear
+        end
+
+        private
+
+        def fetch_schema(topic)
+          cached = @cache[topic.to_s]
+          return cached[:schema] if cached && cached[:expires_at] > Time.now
+
+          schema = download_schema(topic)
+          @cache[topic.to_s] = { schema: schema, expires_at: Time.now + @cache_ttl } if schema
+          schema
+        end
+
+        def download_schema(topic)
+          uri = URI("#{@base_url}/schemas/#{topic}.json")
+          request = Net::HTTP::Get.new(uri)
+          @headers.each { |k, v| request[k.to_s] = v.to_s }
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+            http.request(request)
+          end
+
+          return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/shared_broker/schema_registry/providers/local.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "dry-schema"
+
+module SharedBroker
+  module SchemaRegistry
+    module Providers
+      class Local
+        def initialize
+          @schemas = {}
+        end
+
+        def register(topic, schema)
+          unless schema.respond_to?(:call)
+            raise ArgumentError, "Expected schema to respond to :call, got #{schema.class} with value #{schema.inspect}. Expected shape: respond_to?(:call)"
+          end
+
+          @schemas[topic.to_s] = schema
+        end
+
+        def validate!(topic, payload)
+          schema = @schemas[topic.to_s]
+          return unless schema
+
+          result = schema.call(payload)
+          return if result.success?
+
+          raise SharedBroker::Validation::ValidationError,
+                "Schema validation failed for topic #{topic.inspect}. Expected keys: #{schema.rules.keys.inspect}, got payload: #{payload.inspect}. Errors: #{result.errors.to_h.inspect}"
+        end
+
+        def clear
+          @schemas.clear
+        end
+      end
+    end
+  end
+end

data/lib/shared_broker/schema_registry.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SharedBroker
+  module SchemaRegistry
+    class << self
+      attr_accessor :provider
+    end
+
+    def self.validate!(topic, payload)
+      resolved_provider = provider || default_provider
+      resolved_provider.validate!(topic, payload)
+    end
+
+    def self.clear_cache
+      return unless provider.respond_to?(:clear_cache)
+
+      provider.clear_cache
+    end
+
+    def self.default_provider
+      @default_provider ||= SharedBroker::SchemaRegistry::Providers::Local.new
+    end
+    private_class_method :default_provider
+  end
+end

data/lib/shared_broker/validation.rb

@@ -1,32 +1,27 @@
-# frozen_string_literal: true
-
-require "dry-schema"
-
-module SharedBroker
-  module Validation
-    class ValidationError < StandardError; end
-
-    @schemas = {}
-
-    def self.register(topic, schema)
-      unless schema.respond_to?(:call)
-        raise ArgumentError, "Expected schema to respond to :call, got #{schema.class} with value #{schema.inspect}"
-      end
-      @schemas[topic.to_s] = schema
-    end
-
-    def self.validate!(topic, message)
-      schema = @schemas[topic.to_s]
-      return unless schema
-
-      result = schema.call(message)
-      unless result.success?
-        raise ValidationError, "Schema validation failed for topic #{topic.inspect}. Expected keys: #{schema.rules.keys.inspect}, got payload: #{message.inspect}. Errors: #{result.errors.to_h.inspect}"
-      end
-    end
-
-    def self.clear
-      @schemas.clear
-    end
-  end
-end
+# frozen_string_literal: true
+
+module SharedBroker
+  module Validation
+    class ValidationError < StandardError; end
+
+    def self.register(topic, schema)
+      provider = SharedBroker::SchemaRegistry.provider || SharedBroker::SchemaRegistry.send(:default_provider)
+      if provider.respond_to?(:register)
+        provider.register(topic, schema)
+      else
+        raise RuntimeError, "Current SchemaRegistry provider #{provider.class} does not support local registration. Expected a provider that responds to :register."
+      end
+    end
+
+    def self.validate!(topic, message)
+      SharedBroker::SchemaRegistry.validate!(topic, message)
+    end
+
+    def self.clear
+      SharedBroker::SchemaRegistry.clear_cache
+      provider = SharedBroker::SchemaRegistry.provider || SharedBroker::SchemaRegistry.send(:default_provider)
+      provider.clear if provider.respond_to?(:clear)
+    end
+  end
+end
+

data/lib/shared_broker/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-module SharedBroker
-  VERSION = "1.2.0"
-end
+# frozen_string_literal: true
+
+module SharedBroker
+  VERSION = "1.4.0"
+end

data/lib/shared_broker.rb

@@ -3,6 +3,9 @@
 require_relative "shared_broker/version"
 require_relative "shared_broker/telemetry"
 require_relative "shared_broker/circuit_breaker"
+require_relative "shared_broker/schema_registry"
+require_relative "shared_broker/schema_registry/providers/local"
+require_relative "shared_broker/schema_registry/providers/http"
 require_relative "shared_broker/validation"
 require_relative "shared_broker/cipher"
 require_relative "shared_broker/middleware_pipeline"
@@ -22,16 +25,11 @@ module SharedBroker
   @encryption_key = ENV.fetch("SHARED_BROKER_ENCRYPTION_KEY") { "a" * 32 }
 
   class Client
-    attr_reader :circuit_breaker, :middleware_pipeline
+    attr_reader :circuit_breaker, :middleware_pipeline, :adapters, :routing
 
-    def initialize(adapter:, circuit_breaker: nil, middlewares: nil)
-      unless adapter.respond_to?(:publish) && adapter.respond_to?(:subscribe)
-        raise ArgumentError, "Expected adapter to respond to :publish and :subscribe, got #{adapter.class} with value #{adapter.inspect}"
-      end
-
-      @adapter = adapter
+    def initialize(adapter: nil, adapters: nil, routing: nil, circuit_breaker: nil, middlewares: nil)
+      setup_adapters(adapter: adapter, adapters: adapters, routing: routing)
       @circuit_breaker = circuit_breaker || CircuitBreaker.new
-      
       resolved_middlewares = middlewares || [SharedBroker::Middlewares::OpenTelemetryPropagation.new]
       @middleware_pipeline = MiddlewarePipeline.new(resolved_middlewares)
     end
@@ -43,13 +41,13 @@ module SharedBroker
         encrypted_msg = SharedBroker::Cipher.encrypt(message, SharedBroker.encryption_key)
 
         @circuit_breaker.run do
-          @adapter.publish(topic, encrypted_msg, correlation_id: correlation_id)
+          resolve_adapter(topic).publish(topic, encrypted_msg, correlation_id: correlation_id)
         end
       end
     end
 
     def subscribe(topic, queue_name, max_retries: 3, backoff_base: 2, &block)
-      @adapter.subscribe(topic, queue_name, max_retries: max_retries, backoff_base: backoff_base) do |raw_message|
+      resolve_adapter(topic).subscribe(topic, queue_name, max_retries: max_retries, backoff_base: backoff_base) do |raw_message|
         decrypted_msg = SharedBroker::Cipher.decrypt(raw_message, SharedBroker.encryption_key)
         SharedBroker::Validation.validate!(topic, decrypted_msg)
 
@@ -59,5 +57,55 @@ module SharedBroker
         end
       end
     end
+
+    private
+
+    def setup_adapters(adapter: nil, adapters: nil, routing: nil)
+      if adapter || (adapters.nil? && routing.nil?)
+        validate_single_adapter!(adapter)
+        @adapters = { default: adapter }
+        @routing = { "*" => :default }
+      else
+        validate_multi_adapters!(adapters, routing)
+        @adapters = adapters
+        @routing = routing.transform_keys(&:to_s)
+      end
+    end
+
+    def validate_single_adapter!(adapter)
+      unless adapter.respond_to?(:publish) && adapter.respond_to?(:subscribe)
+        raise ArgumentError, "Expected adapter to respond to :publish and :subscribe, got: #{adapter.inspect} (must shape like SharedBroker::Adapters::Base)"
+      end
+    end
+
+    def validate_multi_adapters!(adapters, routing)
+      unless adapters.is_a?(Hash) && routing.is_a?(Hash)
+        raise ArgumentError, "Expected adapters and routing to be Hashes, got adapters: #{adapters.inspect} (class: #{adapters.class}), routing: #{routing.inspect} (class: #{routing.class})"
+      end
+      adapters.each do |key, ad|
+        unless ad.respond_to?(:publish) && ad.respond_to?(:subscribe)
+          raise ArgumentError, "Expected adapter #{key.inspect} to respond to :publish and :subscribe, got: #{ad.inspect} (class: #{ad.class})"
+        end
+      end
+    end
+
+    def resolve_adapter(topic)
+      topic_str = topic.to_s
+      return @adapters[@routing[topic_str]] if @routing.key?(topic_str)
+
+      @routing.each do |pattern, adapter_key|
+        next if pattern == "*"
+        if File.fnmatch?(pattern, topic_str)
+          return @adapters[adapter_key]
+        end
+      end
+
+      fallback_key = @routing["*"]
+      if fallback_key && @adapters.key?(fallback_key)
+        @adapters[fallback_key]
+      else
+        raise RuntimeError, "No adapter resolved for topic: #{topic.inspect}. Expected one of #{@routing.keys.inspect}"
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shared_broker
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Wesley Lima
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-07 00:00:00.000000000 Z
+date: 2026-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +157,9 @@ files:
 - lib/shared_broker/circuit_breaker.rb
 - lib/shared_broker/middleware_pipeline.rb
 - lib/shared_broker/middlewares/open_telemetry_propagation.rb
+- lib/shared_broker/schema_registry.rb
+- lib/shared_broker/schema_registry/providers/http.rb
+- lib/shared_broker/schema_registry/providers/local.rb
 - lib/shared_broker/telemetry.rb
 - lib/shared_broker/validation.rb
 - lib/shared_broker/version.rb