smart_message 0.0.6 → 0.0.8

data/lib/smart_message/transport/base.rb

@@ -2,17 +2,22 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require_relative '../circuit_breaker'
+
 module SmartMessage
   module Transport
     # Base class for all transport implementations
     # This defines the standard interface that all transports must implement
     class Base
+      include BreakerMachines::DSL
+      
       attr_reader :options, :dispatcher
 
       def initialize(**options)
         @options = default_options.merge(options)
         @dispatcher = options[:dispatcher] || SmartMessage::Dispatcher.new
         configure
+        configure_transport_circuit_breakers
       end
 
       # Transport-specific configuration
@@ -25,11 +30,26 @@ module SmartMessage
         {}
       end
 
-      # Publish a message
+      # Publish a message with circuit breaker protection
       # @param message_header [SmartMessage::Header] Message routing information
       # @param message_payload [String] Serialized message content
       def publish(message_header, message_payload)
-        raise NotImplementedError, 'Transport must implement #publish'
+        circuit(:transport_publish).wrap do
+          do_publish(message_header, message_payload)
+        end
+      rescue => e
+        # Re-raise if it's not a circuit breaker fallback
+        raise unless e.is_a?(Hash) && e[:circuit_breaker]
+        
+        # Handle circuit breaker fallback
+        handle_publish_fallback(e, message_header, message_payload)
+      end
+
+      # Template method for actual publishing (implement in subclasses)
+      # @param message_header [SmartMessage::Header] Message routing information
+      # @param message_payload [String] Serialized message content
+      def do_publish(message_header, message_payload)
+        raise NotImplementedError, 'Transport must implement #do_publish'
       end
 
       # Subscribe to a message class
@@ -73,6 +93,47 @@ module SmartMessage
         # Override in subclasses if cleanup is needed
       end
 
+      # Get transport circuit breaker statistics
+      # @return [Hash] Circuit breaker statistics
+      def transport_circuit_stats
+        stats = {}
+        
+        [:transport_publish, :transport_subscribe].each do |circuit_name|
+          begin
+            if respond_to?(:circuit)
+              breaker = circuit(circuit_name)
+              if breaker
+                stats[circuit_name] = {
+                  status: breaker.status,
+                  closed: breaker.closed?,
+                  open: breaker.open?,
+                  half_open: breaker.half_open?,
+                  last_error: breaker.last_error,
+                  opened_at: breaker.opened_at,
+                  stats: breaker.stats
+                }
+              end
+            end
+          rescue => e
+            stats[circuit_name] = { error: "Failed to get stats: #{e.message}" }
+          end
+        end
+        
+        stats
+      end
+
+      # Reset transport circuit breakers
+      # @param circuit_name [Symbol] Optional specific circuit to reset
+      def reset_transport_circuits!(circuit_name = nil)
+        if circuit_name
+          circuit(circuit_name)&.reset!
+        else
+          # Reset all transport circuits
+          circuit(:transport_publish)&.reset!
+          circuit(:transport_subscribe)&.reset!
+        end
+      end
+
       # Receive and route a message (called by transport implementations)
       # @param message_header [SmartMessage::Header] Message routing information
       # @param message_payload [String] Serialized message content
@@ -81,6 +142,81 @@ module SmartMessage
       def receive(message_header, message_payload)
         @dispatcher.route(message_header, message_payload)
       end
+
+      # Configure circuit breakers for transport operations
+      def configure_transport_circuit_breakers
+        # Configure publish circuit breaker
+        publish_config = SmartMessage::CircuitBreaker::DEFAULT_CONFIGS[:transport_publish]
+        
+        self.class.circuit :transport_publish do
+          threshold failures: publish_config[:threshold][:failures], 
+                   within: publish_config[:threshold][:within].seconds
+          reset_after publish_config[:reset_after].seconds
+          
+          # Use memory storage by default for transport circuits
+          storage BreakerMachines::Storage::Memory.new
+          
+          # Fallback for publish failures - use DLQ fallback
+          fallback SmartMessage::CircuitBreaker::Fallbacks.dead_letter_queue
+        end
+
+        # Configure subscribe circuit breaker
+        subscribe_config = SmartMessage::CircuitBreaker::DEFAULT_CONFIGS[:transport_subscribe]
+        
+        self.class.circuit :transport_subscribe do
+          threshold failures: subscribe_config[:threshold][:failures], 
+                   within: subscribe_config[:threshold][:within].seconds
+          reset_after subscribe_config[:reset_after].seconds
+          
+          storage BreakerMachines::Storage::Memory.new
+          
+          # Fallback for subscribe failures - log and return error info
+          fallback do |exception|
+            {
+              circuit_breaker: {
+                circuit: :transport_subscribe,
+                transport_type: self.class.name,
+                state: 'open',
+                error: exception.message,
+                error_class: exception.class.name,
+                timestamp: Time.now.iso8601,
+                fallback_triggered: true
+              }
+            }
+          end
+        end
+      end
+
+      # Handle publish circuit breaker fallback
+      # @param fallback_result [Hash] The circuit breaker fallback result
+      # @param message_header [SmartMessage::Header] The message header
+      # @param message_payload [String] The message payload
+      def handle_publish_fallback(fallback_result, message_header, message_payload)
+        # Log the circuit breaker activation
+        if $DEBUG
+          puts "Transport publish circuit breaker activated: #{self.class.name}"
+          puts "Error: #{fallback_result[:circuit_breaker][:error]}"
+          puts "Message: #{message_header.message_class}"
+          puts "Sent to DLQ: #{fallback_result[:circuit_breaker][:sent_to_dlq]}"
+        end
+        
+        # If message wasn't sent to DLQ by circuit breaker, send it now
+        unless fallback_result.dig(:circuit_breaker, :sent_to_dlq)
+          begin
+            SmartMessage::DeadLetterQueue.default.enqueue(
+              message_header, 
+              message_payload,
+              error: fallback_result.dig(:circuit_breaker, :error) || 'Circuit breaker activated',
+              transport: self.class.name
+            )
+          rescue => dlq_error
+            puts "Warning: Failed to store message in DLQ: #{dlq_error.message}" if $DEBUG
+          end
+        end
+        
+        # Return the fallback result to indicate failure
+        fallback_result
+      end
     end
   end
 end

data/lib/smart_message/transport/memory_transport.rb

@@ -22,7 +22,7 @@ module SmartMessage
       end
 
       # Publish message to memory queue
-      def publish(message_header, message_payload)
+      def do_publish(message_header, message_payload)
         @message_mutex.synchronize do
           # Prevent memory overflow
           @messages.shift if @messages.size >= @options[:max_messages]

data/lib/smart_message/transport/redis_transport.rb

@@ -5,6 +5,7 @@
 require 'redis'
 require 'securerandom'
 require 'set'
+require 'json'
 
 module SmartMessage
   module Transport
@@ -35,13 +36,20 @@ module SmartMessage
       end
 
       # Publish message to Redis channel using message class name
-      def publish(message_header, message_payload)
+      def do_publish(message_header, message_payload)
         channel = message_header.message_class
         
+        # Combine header and payload for Redis transport
+        # This ensures header information (from, to, reply_to, etc.) is preserved
+        redis_message = {
+          header: message_header.to_hash,
+          payload: message_payload
+        }.to_json
+        
         begin
-          @redis_pub.publish(channel, message_payload)
+          @redis_pub.publish(channel, redis_message)
         rescue Redis::ConnectionError
-          retry_with_reconnect('publish') { @redis_pub.publish(channel, message_payload) }
+          retry_with_reconnect('publish') { @redis_pub.publish(channel, redis_message) }
         end
       end
 
@@ -135,16 +143,38 @@ module SmartMessage
         
         begin
           @redis_sub.subscribe(*@subscribed_channels) do |on|
-            on.message do |channel, message_payload|
-              # Create a header with the channel as message_class
-              message_header = SmartMessage::Header.new(
-                message_class: channel,
-                uuid: SecureRandom.uuid,
-                published_at: Time.now,
-                publisher_pid: 'redis_subscriber'
-              )
-              
-              receive(message_header, message_payload)
+            on.message do |channel, redis_message|
+              begin
+                # Parse the Redis message to extract header and payload
+                parsed_message = JSON.parse(redis_message)
+                
+                if parsed_message.is_a?(Hash) && parsed_message.has_key?('header') && parsed_message.has_key?('payload')
+                  # Reconstruct the original header from the parsed data
+                  header_data = parsed_message['header']
+                  message_header = SmartMessage::Header.new(header_data)
+                  message_payload = parsed_message['payload']
+                else
+                  # Fallback for messages that don't have header/payload structure (legacy support)
+                  message_header = SmartMessage::Header.new(
+                    message_class: channel,
+                    uuid: SecureRandom.uuid,
+                    published_at: Time.now,
+                    publisher_pid: 'redis_subscriber'
+                  )
+                  message_payload = redis_message
+                end
+                
+                receive(message_header, message_payload)
+              rescue JSON::ParserError
+                # Handle malformed JSON - fallback to legacy behavior
+                message_header = SmartMessage::Header.new(
+                  message_class: channel,
+                  uuid: SecureRandom.uuid,
+                  published_at: Time.now,
+                  publisher_pid: 'redis_subscriber'
+                )
+                receive(message_header, redis_message)
+              end
             end
             
             on.subscribe do |channel, subscriptions|

data/lib/smart_message/transport/stdout_transport.rb

@@ -28,7 +28,7 @@ module SmartMessage
       end
 
       # Publish message to STDOUT
-      def publish(message_header, message_payload)
+      def do_publish(message_header, message_payload)
         @output.puts format_message(message_header, message_payload)
         @output.flush
 

data/lib/smart_message/version.rb

@@ -3,5 +3,5 @@
 # frozen_string_literal: true
 
 module SmartMessage
-  VERSION = '0.0.6'
+  VERSION = '0.0.8'
 end

data/lib/smart_message.rb

@@ -21,6 +21,8 @@ require_relative './simple_stats'
 
 require_relative './smart_message/version'
 require_relative './smart_message/errors'
+require_relative './smart_message/circuit_breaker'
+require_relative './smart_message/dead_letter_queue'
 
 require_relative './smart_message/dispatcher.rb'
 require_relative './smart_message/transport.rb'

data/smart_message.gemspec

@@ -40,6 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport'
   spec.add_dependency 'concurrent-ruby'
   spec.add_dependency 'redis'
+  spec.add_dependency 'breaker_machines'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_message
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -65,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: breaker_machines
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -234,6 +248,8 @@ files:
 - lib/simple_stats.rb
 - lib/smart_message.rb
 - lib/smart_message/base.rb
+- lib/smart_message/circuit_breaker.rb
+- lib/smart_message/dead_letter_queue.rb
 - lib/smart_message/dispatcher.rb
 - lib/smart_message/dispatcher/.keep
 - lib/smart_message/errors.rb