smart_message 0.0.5 → 0.0.7

data/lib/smart_message/dispatcher.rb

@@ -3,26 +3,25 @@
 # frozen_string_literal: true
 
 require 'concurrent'
+require_relative 'circuit_breaker'
 
 module SmartMessage
 
   # The disoatcher routes incoming messages to all of the methods that
   # have been subscribed to the message.
   class Dispatcher
+    include BreakerMachines::DSL
 
     # TODO: setup forwardable for some @router_pool methods
 
-    def initialize
+    def initialize(circuit_breaker_options = {})
       @subscribers = Hash.new(Array.new)
       @router_pool = Concurrent::CachedThreadPool.new
+      
+      # Configure circuit breakers
+      configure_circuit_breakers(circuit_breaker_options)
       at_exit do
-        print "Shuttingdown down the dispatcher's @router_pool ..."
-        @router_pool.shutdown
-        while @router_pool.shuttingdown?
-          print '.'
-          sleep 1
-        end
-        puts " done."
+        shutdown_pool
       end
     end
 
@@ -83,17 +82,30 @@ module SmartMessage
     end
 
 
-    def add(message_class, process_method_as_string)
+    def add(message_class, process_method_as_string, filter_options = {})
       klass = String(message_class)
-      unless @subscribers[klass].include? process_method_as_string
-        @subscribers[klass] += [process_method_as_string]
+      
+      # Create subscription entry with filter options
+      subscription = {
+        process_method: process_method_as_string,
+        filters: filter_options
+      }
+      
+      # Check if this exact subscription already exists
+      existing_subscription = @subscribers[klass].find do |sub|
+        sub[:process_method] == process_method_as_string && sub[:filters] == filter_options
+      end
+      
+      unless existing_subscription
+        @subscribers[klass] += [subscription]
       end
     end
 
 
     # drop a processer from a subscribed message
     def drop(message_class, process_method_as_string)
-      @subscribers[String(message_class)].delete process_method_as_string
+      klass = String(message_class)
+      @subscribers[klass].reject! { |sub| sub[:process_method] == process_method_as_string }
     end
 
 
@@ -115,10 +127,19 @@ module SmartMessage
     def route(message_header, message_payload)
       message_klass = message_header.message_class
       return nil if @subscribers[message_klass].empty?
-      @subscribers[message_klass].each do |message_processor|
+      
+      @subscribers[message_klass].each do |subscription|
+        # Extract subscription details
+        message_processor = subscription[:process_method]
+        filters = subscription[:filters]
+        
+        # Check if message matches filters
+        next unless message_matches_filters?(message_header, filters)
+        
         SS.add(message_klass, message_processor, 'routed' )
         @router_pool.post do
-          begin
+          # Use circuit breaker to protect message processing
+          circuit_result = circuit(:message_processor).wrap do
             # Check if this is a proc handler or a regular method call
             if proc_handler?(message_processor)
               # Call the proc handler via SmartMessage::Base
@@ -132,17 +153,90 @@ module SmartMessage
                           .method(class_method)
                           .call(message_header, message_payload)
             end
-          rescue Exception => e
-            # TODO: Add proper exception logging
-            # Exception details: #{e.message}
-            # Processor: #{message_processor}
-            puts "Error processing message: #{e.message}" if $DEBUG
+          end
+          
+          # Handle circuit breaker fallback responses
+          if circuit_result.is_a?(Hash) && circuit_result[:circuit_breaker]
+            handle_circuit_breaker_fallback(circuit_result, message_header, message_payload, message_processor)
           end
         end
       end
     end
 
-    private
+    # Get circuit breaker statistics
+    # @return [Hash] Circuit breaker statistics
+    def circuit_breaker_stats
+      stats = {}
+      
+      begin
+        if respond_to?(:circuit)
+          breaker = circuit(:message_processor)
+          if breaker
+            stats[:message_processor] = {
+              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[:error] = "Failed to get circuit breaker stats: #{e.message}"
+      end
+      
+      stats
+    end
+
+    # Reset circuit breakers
+    # @param circuit_name [Symbol] Optional specific circuit to reset
+    def reset_circuit_breakers!(circuit_name = nil)
+      if circuit_name
+        circuit(circuit_name)&.reset!
+      else
+        # Reset all known circuits
+        circuit(:message_processor)&.reset!
+      end
+    end
+
+    # Shutdown the router pool with timeout and fallback
+    def shutdown_pool
+      @router_pool.shutdown
+      
+      # Wait for graceful shutdown, force kill if timeout
+      unless @router_pool.wait_for_termination(3)
+        @router_pool.kill
+      end
+    end
+
+    # Check if a message matches the subscription filters
+    # @param message_header [SmartMessage::Header] The message header
+    # @param filters [Hash] The filter criteria
+    # @return [Boolean] True if the message matches all filters
+    def message_matches_filters?(message_header, filters)
+      # If no filters specified, accept all messages (backward compatibility)
+      return true if filters.nil? || filters.empty? || filters.values.all?(&:nil?)
+      
+      # Check from filter
+      if filters[:from]
+        from_match = filters[:from].include?(message_header.from)
+        return false unless from_match
+      end
+      
+      # Check to/broadcast filters (OR logic between them)
+      if filters[:broadcast] || filters[:to]
+        broadcast_match = filters[:broadcast] && message_header.to.nil?
+        to_match = filters[:to] && filters[:to].include?(message_header.to)
+        
+        # If either broadcast or to filter is specified, at least one must match
+        combined_match = (broadcast_match || to_match)
+        return false unless combined_match
+      end
+      
+      true
+    end
 
     # Check if a message processor is a proc handler
     # @param message_processor [String] The message processor identifier
@@ -151,6 +245,81 @@ module SmartMessage
       SmartMessage::Base.proc_handler?(message_processor)
     end
 
+    # Configure circuit breakers for the dispatcher
+    # @param options [Hash] Circuit breaker configuration options
+    def configure_circuit_breakers(options = {})
+      # Ensure CircuitBreaker module is available
+      return unless defined?(SmartMessage::CircuitBreaker::DEFAULT_CONFIGS)
+      
+      # Configure message processor circuit breaker
+      default_config = SmartMessage::CircuitBreaker::DEFAULT_CONFIGS[:message_processor]
+      return unless default_config
+      
+      processor_config = default_config.merge(options[:message_processor] || {})
+      
+      # Define the circuit using the class-level DSL
+      self.class.circuit :message_processor do
+        threshold failures: processor_config[:threshold][:failures], 
+                 within: processor_config[:threshold][:within].seconds
+        reset_after processor_config[:reset_after].seconds
+        
+        # Configure storage backend
+        case processor_config[:storage]
+        when :redis
+          # Use Redis storage if configured and available
+          if defined?(SmartMessage::Transport::RedisTransport)
+            begin
+              redis_transport = SmartMessage::Transport::RedisTransport.new
+              storage BreakerMachines::Storage::Redis.new(redis: redis_transport.redis_pub)
+            rescue
+              # Fall back to memory storage if Redis not available
+              storage BreakerMachines::Storage::Memory.new
+            end
+          else
+            storage BreakerMachines::Storage::Memory.new
+          end
+        else
+          storage BreakerMachines::Storage::Memory.new
+        end
+        
+        # Default fallback for message processing failures
+        fallback do |exception|
+          {
+            circuit_breaker: {
+              circuit: :message_processor,
+              state: 'open',
+              error: exception.message,
+              error_class: exception.class.name,
+              timestamp: Time.now.iso8601,
+              fallback_triggered: true
+            }
+          }
+        end
+      end
+      
+    end
+
+    # Handle circuit breaker fallback responses
+    # @param circuit_result [Hash] The circuit breaker fallback result
+    # @param message_header [SmartMessage::Header] The message header
+    # @param message_payload [String] The message payload
+    # @param message_processor [String] The processor that failed
+    def handle_circuit_breaker_fallback(circuit_result, message_header, message_payload, message_processor)
+      # Log circuit breaker activation
+      if $DEBUG
+        puts "Circuit breaker activated for processor: #{message_processor}"
+        puts "Error: #{circuit_result[:circuit_breaker][:error]}"
+        puts "Message: #{message_header.message_class} from #{message_header.from}"
+      end
+      
+      # TODO: Integrate with structured logging when implemented
+      # TODO: Send to dead letter queue when implemented
+      # TODO: Emit metrics/events for monitoring
+      
+      # For now, record the failure in simple stats
+      SS.add(message_header.message_class, message_processor, 'circuit_breaker_fallback')
+    end
+
 
     #######################################################
     ## Class methods

data/lib/smart_message/header.rb

@@ -43,5 +43,19 @@ module SmartMessage
       description: "Schema version of the message format, used for schema evolution and compatibility checking",
       validate: ->(v) { v.is_a?(Integer) && v > 0 },
       validation_message: "Header version must be a positive integer"
+    
+    # Message addressing properties for entity-to-entity communication
+    property :from,
+      required: true,
+      message: "From entity ID is required for message routing and replies",
+      description: "Unique identifier of the entity sending this message, used for routing responses and audit trails"
+    
+    property :to,
+      required: false,
+      description: "Optional unique identifier of the intended recipient entity. When nil, message is broadcast to all subscribers"
+    
+    property :reply_to,
+      required: false,
+      description: "Optional unique identifier of the entity that should receive replies to this message. Defaults to 'from' entity if not specified"
   end
 end

data/lib/smart_message/serializer/base.rb

@@ -2,22 +2,95 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require_relative '../circuit_breaker'
+
 module SmartMessage::Serializer
   # the standard super class
   class Base
+    include BreakerMachines::DSL
+    
     # provide basic configuration
     def initialize
-      # TODO: write this
+      configure_serializer_circuit_breakers
     end
 
     def encode(message_instance)
-      # TODO: Add proper logging here
-      raise ::SmartMessage::Errors::NotImplemented
+      circuit(:serializer).wrap do
+        do_encode(message_instance)
+      end
+    rescue => e
+      # Handle circuit breaker fallback
+      if e.is_a?(Hash) && e[:circuit_breaker]
+        handle_serializer_fallback(e, :encode, message_instance)
+      else
+        raise
+      end
     end
 
     def decode(payload)
-      # TODO: Add proper logging here
+      circuit(:serializer).wrap do
+        do_decode(payload)
+      end
+    rescue => e
+      # Handle circuit breaker fallback
+      if e.is_a?(Hash) && e[:circuit_breaker]
+        handle_serializer_fallback(e, :decode, payload)
+      else
+        raise
+      end
+    end
+
+    # Template methods for actual serialization (implement in subclasses)
+    def do_encode(message_instance)
+      raise ::SmartMessage::Errors::NotImplemented
+    end
+
+    def do_decode(payload)
       raise ::SmartMessage::Errors::NotImplemented
     end
+
+    private
+
+    # Configure circuit breaker for serializer operations
+    def configure_serializer_circuit_breakers
+      serializer_config = SmartMessage::CircuitBreaker::DEFAULT_CONFIGS[:serializer]
+      
+      self.class.circuit :serializer do
+        threshold failures: serializer_config[:threshold][:failures], 
+                 within: serializer_config[:threshold][:within].seconds
+        reset_after serializer_config[:reset_after].seconds
+        
+        storage BreakerMachines::Storage::Memory.new
+        
+        # Fallback for serializer failures
+        fallback do |exception|
+          {
+            circuit_breaker: {
+              circuit: :serializer,
+              serializer_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 serializer circuit breaker fallback
+    def handle_serializer_fallback(fallback_result, operation, data)
+      if $DEBUG
+        puts "Serializer circuit breaker activated: #{self.class.name}"
+        puts "Operation: #{operation}"
+        puts "Error: #{fallback_result[:circuit_breaker][:error]}"
+      end
+      
+      # TODO: Integrate with structured logging when implemented
+      
+      # Return the fallback result
+      fallback_result
+    end
   end # class Base
 end # module SmartMessage::Serializer

data/lib/smart_message/serializer/json.rb

@@ -6,13 +6,13 @@ require 'json'  # STDLIB
 
 module SmartMessage::Serializer
   class JSON < Base
-    def encode(message_instance)
+    def do_encode(message_instance)
       # TODO: is this the right place to insert an automated-invisible
       #       message header?
       message_instance.to_json
     end
 
-    def decode(payload)
+    def do_decode(payload)
       # TODO: so how do I know to which message class this payload
       #       belongs?  The class needs to be in some kind of message
       #       header.

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,18 +30,34 @@ 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
       # @param message_class [String] The message class name
       # @param process_method [String] The processing method identifier
-      def subscribe(message_class, process_method)
-        @dispatcher.add(message_class, process_method)
+      # @param filter_options [Hash] Optional filtering criteria
+      def subscribe(message_class, process_method, filter_options = {})
+        @dispatcher.add(message_class, process_method, filter_options)
       end
 
       # Unsubscribe from a specific message class and process method
@@ -72,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
@@ -80,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
+          fallback do |exception|
+            {
+              circuit_breaker: {
+                circuit: :transport_publish,
+                transport_type: self.class.name,
+                state: 'open',
+                error: exception.message,
+                error_class: exception.class.name,
+                timestamp: Time.now.iso8601,
+                fallback_triggered: true
+              }
+            }
+          end
+        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
+          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}"
+        end
+        
+        # TODO: Integrate with structured logging when implemented
+        # TODO: Queue for retry or send to dead letter queue
+        
+        # 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,19 +36,26 @@ 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
 
       # Subscribe to a message class (Redis channel)
-      def subscribe(message_class, process_method)
-        super(message_class, process_method)
+      def subscribe(message_class, process_method, filter_options = {})
+        super(message_class, process_method, filter_options)
         
         @mutex.synchronize do
           @subscribed_channels.add(message_class)
@@ -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|