shared_broker 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 113868a35ebcb87b89d4ce8b0ba3079276ffdb8a07a519ec5ee5cbb28d605f24
-  data.tar.gz: 5d7cbddbf655269f55bc9b752172de08d52bbcf8d3864ef1164c9458731ae66b
+  metadata.gz: a691e6fa4ea7eb0d9b7974a55ed217c25a325be29c7beba0211d05633e947c02
+  data.tar.gz: '09abf8886190595bbcf09d7faeaf0676f848c763b8efef6ed092c8b23eac5853'
 SHA512:
-  metadata.gz: dd263b0bf50aec4e4ac83e85de4c8fadf8a59bc8ddbcdc4195862bc791aeb2770c866f15cfecec5633313b457897923cc56c2ab990299f95f1fbff03465b9022
-  data.tar.gz: 7693f227da2d82c5389074f4e8375ed011ffe2cd77c7e4517480ec38308500c15ccab679a2a326af31ac3ca08f77cc084b7031ebb3d0e291e18745c9335e97ab
+  metadata.gz: 96d856ee56c3d1db971a0a751920d03b65c3f67922b77ef67e42443f2586cc6e6063a5301fff1e050e8f2b81ab334e4479d80739604938c76f1880824692b097
+  data.tar.gz: 46d39087d7e875d84cd8a82223e68edadd965651e795c013c1da85cbfc847663fe594ed90bf8b1f60c5eb7ade7f14056f4aed3fbb5fe2a46e43fa5bc7aaf7ed0

data/README.md

@@ -2,15 +2,24 @@
 
 `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 (like RabbitMQ), allowing easy broker swapping and clean synchronous testing with an in-memory adapter.
+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 to decouple Rails from physical messaging queues.
-- **RabbitMQ Adapter**: Robust, persistent connection wrapper using the `bunny` gem.
-- **InMemory Adapter**: Synchronous local queue simulation for fast TDD testing (no inline external I/O stubs required).
+- **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.).
 
 ---
@@ -40,20 +49,42 @@ Create an initializer in your Rails application (`config/initializers/shared_bro
 ```ruby
 require "shared_broker"
 
-# 1. Configure the Adapter based on Environment
+# 1. Configure Validation Schemas (dry-schema)
+user_created_schema = Dry::Schema.Params do
+  required(:id).filled(:integer)
+  required(:email).filled(:string)
+end
+SharedBroker::Validation.register("user.created", user_created_schema)
+
+# 2. Configure Payload Encryption Key (AES-256-GCM)
+# Expects a 32-byte string. Default key is used in development if ENV is not set.
+SharedBroker.encryption_key = ENV.fetch("SHARED_BROKER_ENCRYPTION_KEY") { "a" * 32 }
+
+# 3. 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
+elsif Rails.env.production?
+  # High-throughput production setup using Kafka
+  BROKER_ADAPTER = SharedBroker::Adapters::Kafka.new(seed_brokers: ["kafka-1:9092", "kafka-2:9092"])
 else
-  # Connects to real RabbitMQ broker
+  # Connects to RabbitMQ or Redis for development
   amqp_url = ENV.fetch("RABBITMQ_URL") { "amqp://guest:guest@localhost:5672" }
   BROKER_ADAPTER = SharedBroker::Adapters::RabbitMQ.new(amqp_url: amqp_url)
 end
 
-# 2. Instantiate the Client by Injecting the Adapter
-SPOT_BROKER = SharedBroker::Client.new(adapter: BROKER_ADAPTER)
+# 4. Instantiate the Client by Injecting the Adapter and optional custom Circuit Breaker configuration
+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
+)
 
-# 3. Initialize Telemetry (OpenTelemetry)
+# 5. Initialize Telemetry (OpenTelemetry)
 SharedBroker::Telemetry.configure(service_name: "my_microservice")
 ```
 
@@ -62,25 +93,24 @@ SharedBroker::Telemetry.configure(service_name: "my_microservice")
 ## Usage
 
 ### Publishing Events
-Send simple events by passing the topic name and a structured payload (must be a `Hash`):
+Send events by passing the topic name and a structured payload (must be a `Hash`):
 
 ```ruby
 event_data = {
   id: 1,
-  name: "Eiffel Tower",
-  latitude: 48.8584,
-  longitude: 2.2945
+  email: "test@example.com"
 }
 
-SPOT_BROKER.publish("spot.created", event_data)
+# The payload will be validated against its dry-schema, encrypted, and published safely.
+SPOT_BROKER.publish("user.created", event_data)
 ```
 
-### Subscribing to Events (Consumer)
-To start a persistent event subscriber daemon, register a queue associated with the topic:
+### 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("spot.created", "my_consumption_queue") do |payload|
-  puts "Event successfully consumed! ID: #{payload[:id]}"
+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
 ```

data/lib/shared_broker/adapters/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SharedBroker
+  module Adapters
+    class Base
+      def publish(topic, message, correlation_id: nil)
+        raise NotImplementedError, "#{self.class.name} must implement #publish"
+      end
+
+      def subscribe(topic, queue_name, max_retries: 3, backoff_base: 2, &block)
+        raise NotImplementedError, "#{self.class.name} must implement #subscribe"
+      end
+    end
+  end
+end

data/lib/shared_broker/adapters/in_memory.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "base"
+
+module SharedBroker
+  module Adapters
+    class InMemory < Base
+      def initialize
+        @storage = Hash.new { |h, k| h[k] = [] }
+        @subscribers = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def publish(topic, message, correlation_id: nil)
+        msg_with_metadata = message.merge(_correlation_id: correlation_id)
+        @storage[topic] << msg_with_metadata
+        
+        @subscribers[topic].each do |sub|
+          attempts = 0
+          begin
+            sub[:block].call(msg_with_metadata)
+          rescue => e
+            attempts += 1
+            if attempts <= sub[:max_retries]
+              # Sleep briefly or not at all in memory to keep tests fast
+              sleep(0.001 * sub[:backoff_base]**attempts)
+              retry
+            else
+              dlq_topic = "#{sub[:queue_name]}.dlq"
+              dlq_msg = msg_with_metadata.merge(
+                _x_original_routing_key: topic,
+                _x_failed_at: Time.now.utc.iso8601,
+                _x_exception_class: e.class.name,
+                _x_exception_message: e.message
+              )
+              @storage[dlq_topic] << dlq_msg
+            end
+          end
+        end
+      end
+
+      def subscribe(topic, queue_name, max_retries: 3, backoff_base: 2, &block)
+        @subscribers[topic] << { queue_name: queue_name, max_retries: max_retries, backoff_base: backoff_base, block: block }
+      end
+
+      def published_messages(topic)
+        @storage[topic]
+      end
+    end
+  end
+end

data/lib/shared_broker/adapters/kafka.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "json"
+require "time"
+
+module SharedBroker
+  module Adapters
+    class Kafka < Base
+      def initialize(seed_brokers:, client_id: "shared_broker")
+        begin
+          require "kafka"
+        rescue LoadError
+          raise unless defined?(::Kafka)
+        end
+        @kafka = ::Kafka.new(seed_brokers, client_id: client_id)
+      end
+
+      def publish(topic, message, correlation_id: nil)
+        unless message.is_a?(Hash)
+          raise ArgumentError, "Expected message to be a Hash, got #{message.class} with value #{message.inspect}"
+        end
+
+        headers = {}
+        headers["correlation_id"] = correlation_id if correlation_id
+        
+        @kafka.deliver_message(message.to_json, topic: topic, headers: headers)
+      end
+
+      def subscribe(topic, queue_name, max_retries: 3, backoff_base: 2, &block)
+        consumer = @kafka.consumer(group_id: queue_name)
+        consumer.subscribe(topic)
+        
+        Thread.new do
+          consumer.each_message do |message|
+            data = JSON.parse(message.value, symbolize_names: true)
+            if message.headers && message.headers["correlation_id"]
+              data[:_correlation_id] = message.headers["correlation_id"]
+            end
+            
+            attempts = 0
+            begin
+              block.call(data)
+            rescue => e
+              attempts += 1
+              if attempts <= max_retries
+                sleep(backoff_base**attempts)
+                retry
+              else
+                publish_to_dlq(topic, queue_name, message.value, message.headers, e)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def publish_to_dlq(original_topic, queue_name, payload, original_headers, exception)
+        dlq_topic = "#{original_topic}.#{queue_name}.dlq"
+        headers = (original_headers || {}).merge(
+          "x_original_topic" => original_topic,
+          "x_failed_at" => Time.now.utc.iso8601,
+          "x_exception_class" => exception.class.name,
+          "x_exception_message" => exception.message
+        )
+        @kafka.deliver_message(payload, topic: dlq_topic, headers: headers)
+      end
+    end
+  end
+end

data/lib/shared_broker/adapters/rabbit_mq.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "bunny"
+require "json"
+require "time"
+require_relative "base"
+
+module SharedBroker
+  module Adapters
+    class RabbitMQ < Base
+      EXCHANGE_NAME = "shared_broker_events"
+
+      def initialize(amqp_url:)
+        @connection = Bunny.new(amqp_url)
+        @connection.start
+        @channel = @connection.create_channel
+        @exchange = @channel.topic(EXCHANGE_NAME, durable: true)
+      end
+
+      def publish(topic, message, correlation_id: nil)
+        unless message.is_a?(Hash)
+          raise ArgumentError, "Message must be a Hash, got #{message.class} with value #{message.inspect}"
+        end
+
+        options = { routing_key: topic }
+        options[:correlation_id] = correlation_id if correlation_id
+        @exchange.publish(message.to_json, options)
+      end
+
+      def subscribe(topic, queue_name, max_retries: 3, backoff_base: 2, &block)
+        queue = @channel.queue(queue_name, durable: true)
+        queue.bind(@exchange, routing_key: topic)
+        
+        queue.subscribe(manual_ack: true) do |delivery_info, metadata, payload|
+          data = JSON.parse(payload, symbolize_names: true)
+          if metadata.respond_to?(:correlation_id) && metadata.correlation_id
+            data[:_correlation_id] = metadata.correlation_id
+          end
+
+          attempts = 0
+          begin
+            block.call(data)
+            @channel.acknowledge(delivery_info.delivery_tag, false)
+          rescue => e
+            attempts += 1
+            if attempts <= max_retries
+              sleep(backoff_base**attempts)
+              retry
+            else
+              publish_to_dlq(queue_name, payload, delivery_info, metadata, e)
+              @channel.acknowledge(delivery_info.delivery_tag, false)
+            end
+          end
+        end
+      end
+
+      def close
+        @channel.close if @channel
+        @connection.close if @connection
+      end
+
+      private
+
+      def publish_to_dlq(queue_name, payload, delivery_info, metadata, exception)
+        dlq_name = "#{queue_name}.dlq"
+        dlq_queue = @channel.queue(dlq_name, durable: true)
+        
+        headers = {
+          x_original_routing_key: delivery_info.routing_key,
+          x_failed_at: Time.now.utc.iso8601,
+          x_exception_class: exception.class.name,
+          x_exception_message: exception.message
+        }
+        
+        @channel.default_exchange.publish(
+          payload,
+          routing_key: dlq_queue.name,
+          correlation_id: metadata.correlation_id,
+          headers: headers
+        )
+      end
+    end
+  end
+end

data/lib/shared_broker/adapters/redis.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "json"
+require "time"
+
+module SharedBroker
+  module Adapters
+    class Redis < Base
+      def initialize(redis_url:)
+        begin
+          require "redis"
+        rescue LoadError
+          raise unless defined?(::Redis)
+        end
+        @redis = ::Redis.new(url: redis_url)
+      end
+
+      def publish(topic, message, correlation_id: nil)
+        unless message.is_a?(Hash)
+          raise ArgumentError, "Expected message to be a Hash, got #{message.class} with value #{message.inspect}"
+        end
+
+        payload = message.merge(_correlation_id: correlation_id)
+        @redis.publish(topic, payload.to_json)
+      end
+
+      def subscribe(topic, queue_name, max_retries: 3, backoff_base: 2, &block)
+        Thread.new do
+          @redis.subscribe(topic) do |on|
+            on.message do |_channel, msg_json|
+              data = JSON.parse(msg_json, symbolize_names: true)
+              attempts = 0
+              begin
+                block.call(data)
+              rescue => e
+                attempts += 1
+                if attempts <= max_retries
+                  sleep(backoff_base**attempts)
+                  retry
+                else
+                  publish_to_dlq(topic, queue_name, msg_json, e)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def publish_to_dlq(topic, queue_name, payload_json, exception)
+        dlq_key = "dlq:#{topic}:#{queue_name}"
+        dlq_payload = {
+          payload: JSON.parse(payload_json, symbolize_names: true),
+          x_failed_at: Time.now.utc.iso8601,
+          x_exception_class: exception.class.name,
+          x_exception_message: exception.message
+        }
+        @redis.rpush(dlq_key, dlq_payload.to_json)
+      end
+    end
+  end
+end

data/lib/shared_broker/cipher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "json"
+
+module SharedBroker
+  module Cipher
+    class DecryptionError < StandardError; end
+
+    ALGORITHM = "aes-256-gcm"
+
+    def self.encrypt(payload_hash, key)
+      return payload_hash unless key
+
+      unless payload_hash.is_a?(Hash)
+        raise ArgumentError, "Expected payload_hash to be a Hash, got #{payload_hash.class} with value #{payload_hash.inspect}"
+      end
+
+      # We don't want to encrypt correlation ID or special metadata keys if we want the broker to read them,
+      # but we want to encrypt the actual payload data.
+      # Let's extract metadata starting with underscore and encrypt the rest.
+      metadata = payload_hash.select { |k, _| k.to_s.start_with?("_") }
+      data_to_encrypt = payload_hash.reject { |k, _| k.to_s.start_with?("_") }
+
+      cipher = OpenSSL::Cipher.new(ALGORITHM)
+      cipher.encrypt
+      cipher.key = key
+      iv = cipher.random_iv
+
+      encrypted_data = cipher.update(data_to_encrypt.to_json) + cipher.final
+      auth_tag = cipher.auth_tag
+
+      metadata.merge(
+        _encrypted: true,
+        _iv: Base64.strict_encode64(iv),
+        _auth_tag: Base64.strict_encode64(auth_tag),
+        _data: Base64.strict_encode64(encrypted_data)
+      )
+    end
+
+    def self.decrypt(payload_hash, key)
+      return payload_hash unless payload_hash.is_a?(Hash) && payload_hash[:_encrypted]
+      return payload_hash unless key
+
+      cipher = OpenSSL::Cipher.new(ALGORITHM)
+      cipher.decrypt
+      cipher.key = key
+      cipher.iv = Base64.strict_decode64(payload_hash[:_iv])
+      cipher.auth_tag = Base64.strict_decode64(payload_hash[:_auth_tag])
+
+      encrypted_bytes = Base64.strict_decode64(payload_hash[:_data])
+      decrypted_json = cipher.update(encrypted_bytes) + cipher.final
+
+      decrypted_data = JSON.parse(decrypted_json, symbolize_names: true)
+      
+      # Merge back the unencrypted metadata
+      metadata = payload_hash.select { |k, _| k.to_s.start_with?("_") }
+      metadata.delete(:_encrypted)
+      metadata.delete(:_iv)
+      metadata.delete(:_auth_tag)
+      metadata.delete(:_data)
+
+      decrypted_data.merge(metadata)
+    rescue => e
+      raise DecryptionError, "Failed to decrypt payload. Error: #{e.message}. Offending payload: #{payload_hash.inspect}"
+    end
+  end
+end

data/lib/shared_broker/circuit_breaker.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module SharedBroker
+  class CircuitBreaker
+    class OpenError < StandardError; end
+
+    attr_reader :state, :failure_threshold, :recovery_timeout, :failure_count
+
+    def initialize(failure_threshold: 5, recovery_timeout: 30)
+      @failure_threshold = failure_threshold
+      @recovery_timeout = recovery_timeout
+      @state = :closed
+      @failure_count = 0
+      @last_failure_time = nil
+      @mutex = Mutex.new
+    end
+
+    def run
+      check_state!
+
+      begin
+        result = yield
+        success!
+        result
+      rescue => e
+        record_failure!
+        raise e
+      end
+    end
+
+    private
+
+    def check_state!
+      @mutex.synchronize do
+        if @state == :open
+          if Time.now.utc - @last_failure_time > @recovery_timeout
+            @state = :half_open
+          else
+            raise OpenError, "Circuit is open. Refusing to execute command."
+          end
+        end
+      end
+    end
+
+    def success!
+      @mutex.synchronize do
+        if @state == :half_open || @state == :closed
+          @state = :closed
+          @failure_count = 0
+        end
+      end
+    end
+
+    def record_failure!
+      @mutex.synchronize do
+        @failure_count += 1
+        @last_failure_time = Time.now.utc
+        if @failure_count >= @failure_threshold
+          @state = :open
+        end
+      end
+    end
+  end
+end

data/lib/shared_broker/telemetry.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "opentelemetry/sdk"
+require "opentelemetry/instrumentation/all"
+
+module SharedBroker
+  module Telemetry
+    def self.configure(service_name:)
+      unless service_name.is_a?(String) && !service_name.empty?
+        raise ArgumentError, "service_name must be a non-empty String, got #{service_name.inspect}"
+      end
+
+      OpenTelemetry::SDK.configure do |config|
+        config.service_name = service_name
+        config.use_all
+      end
+    end
+  end
+end

data/lib/shared_broker/validation.rb

@@ -0,0 +1,32 @@
+# 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

data/lib/shared_broker/version.rb

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

data/lib/shared_broker.rb

@@ -2,26 +2,50 @@
 
 require_relative "shared_broker/version"
 require_relative "shared_broker/telemetry"
+require_relative "shared_broker/circuit_breaker"
+require_relative "shared_broker/validation"
+require_relative "shared_broker/cipher"
 require_relative "shared_broker/adapters/base"
 require_relative "shared_broker/adapters/in_memory"
 require_relative "shared_broker/adapters/rabbit_mq"
+require_relative "shared_broker/adapters/kafka"
+require_relative "shared_broker/adapters/redis"
 
 module SharedBroker
+  class << self
+    attr_accessor :encryption_key
+  end
+
+  # Default key for development/test if not set
+  @encryption_key = ENV.fetch("SHARED_BROKER_ENCRYPTION_KEY") { "a" * 32 }
+
   class Client
-    def initialize(adapter:)
+    attr_reader :circuit_breaker
+
+    def initialize(adapter:, circuit_breaker: 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
+      @circuit_breaker = circuit_breaker || CircuitBreaker.new
     end
 
-    def publish(topic, message)
-      @adapter.publish(topic, message)
+    def publish(topic, message, correlation_id: nil)
+      SharedBroker::Validation.validate!(topic, message)
+      encrypted_msg = SharedBroker::Cipher.encrypt(message, SharedBroker.encryption_key)
+
+      @circuit_breaker.run do
+        @adapter.publish(topic, encrypted_msg, correlation_id: correlation_id)
+      end
     end
 
-    def subscribe(topic, queue_name, &block)
-      @adapter.subscribe(topic, queue_name, &block)
+    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|
+        decrypted_msg = SharedBroker::Cipher.decrypt(raw_message, SharedBroker.encryption_key)
+        SharedBroker::Validation.validate!(topic, decrypted_msg)
+        block.call(decrypted_msg)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shared_broker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Gemini Antigravity
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.22'
+- !ruby/object:Gem::Dependency
+  name: dry-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
   requirement: !ruby/object:Gem::Requirement
@@ -119,14 +133,23 @@ files:
 - README.md
 - Rakefile
 - lib/shared_broker.rb
+- lib/shared_broker/adapters/base.rb
+- lib/shared_broker/adapters/in_memory.rb
+- lib/shared_broker/adapters/kafka.rb
+- lib/shared_broker/adapters/rabbit_mq.rb
+- lib/shared_broker/adapters/redis.rb
+- lib/shared_broker/cipher.rb
+- lib/shared_broker/circuit_breaker.rb
+- lib/shared_broker/telemetry.rb
+- lib/shared_broker/validation.rb
 - lib/shared_broker/version.rb
 - sig/shared_broker.rbs
-homepage: https://github.com/onkai/shared_broker
+homepage: https://github.com/wesleyskap/shared_broker
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/onkai/shared_broker
-  changelog_uri: https://github.com/onkai/shared_broker/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/wesleyskap/shared_broker
+  changelog_uri: https://github.com/wesleyskap/shared_broker/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: