smart_message 0.0.5 → 0.0.7

data/lib/smart_message/base.rb

@@ -18,6 +18,9 @@ module SmartMessage
     @@serializer  = nil
     @@logger      = nil
     
+    # Class-level addressing configuration - use a registry for per-class isolation
+    @@addressing_registry = {}
+    
     # Registry for proc-based message handlers
     @@proc_handlers = {}
     
@@ -69,6 +72,14 @@ module SmartMessage
       @transport   = nil
       @serializer  = nil
       @logger      = nil
+      
+      # Extract addressing information from props before creating header
+      addressing_props = props.extract!(:from, :to, :reply_to)
+      
+      # instance-level over ride of class addressing
+      @from        = addressing_props[:from]
+      @to          = addressing_props[:to] 
+      @reply_to    = addressing_props[:reply_to]
 
       # Create header with version validation specific to this message class
       header = SmartMessage::Header.new(
@@ -76,7 +87,10 @@ module SmartMessage
         message_class:  self.class.to_s,
         published_at:   Time.now,
         publisher_pid:  Process.pid,
-        version:        self.class.version
+        version:        self.class.version,
+        from:           from,
+        to:             to,
+        reply_to:       reply_to
       )
       
       # Set up version validation to match the expected class version
@@ -234,6 +248,61 @@ module SmartMessage
     def reset_serializer;       @serializer = nil;  end
 
 
+    #########################################################
+    ## instance-level addressing configuration
+
+    def from(entity_id = nil)
+      if entity_id.nil?
+        @from || self.class.from
+      else
+        @from = entity_id
+        # Update the header with the new value
+        _sm_header.from = entity_id if _sm_header
+      end
+    end
+    
+    def from_configured?; !from.nil?; end
+    def from_missing?;     from.nil?; end
+    def reset_from;       
+      @from = nil
+      _sm_header.from = nil if _sm_header
+    end
+
+    def to(entity_id = nil)
+      if entity_id.nil?
+        @to || self.class.to
+      else
+        @to = entity_id
+        # Update the header with the new value
+        _sm_header.to = entity_id if _sm_header
+      end
+    end
+    
+    def to_configured?;   !to.nil?; end
+    def to_missing?;       to.nil?; end
+    def reset_to;         
+      @to = nil
+      _sm_header.to = nil if _sm_header
+    end
+
+    def reply_to(entity_id = nil)
+      if entity_id.nil?
+        @reply_to || self.class.reply_to
+      else
+        @reply_to = entity_id
+        # Update the header with the new value
+        _sm_header.reply_to = entity_id if _sm_header
+      end
+    end
+    
+    def reply_to_configured?; !reply_to.nil?; end
+    def reply_to_missing?;     reply_to.nil?; end
+    def reset_reply_to;       
+      @reply_to = nil
+      _sm_header.reply_to = nil if _sm_header
+    end
+
+
     #########################################################
     ## instance-level utility methods
 
@@ -358,6 +427,113 @@ module SmartMessage
       def reset_serializer;      @@serializer = nil;  end
 
 
+      #########################################################
+      ## class-level addressing configuration
+      
+      # Helper method to normalize filter values (string -> array, nil -> nil)
+      private def normalize_filter_value(value)
+        case value
+        when nil
+          nil
+        when String
+          [value]
+        when Array
+          value
+        else
+          raise ArgumentError, "Filter value must be a String, Array, or nil, got: #{value.class}"
+        end
+      end
+      
+      # Helper method to find addressing values in the inheritance chain
+      private def find_addressing_value(field)
+        # Start with current class
+        current_class = self
+        
+        while current_class && current_class.respond_to?(:name)
+          class_name = current_class.name || current_class.to_s
+          
+          # Check registry for this class
+          result = @@addressing_registry.dig(class_name, field)
+          return result if result
+          
+          # If we have a proper name but no result, also check the to_s version
+          if current_class.name
+            alternative_key = current_class.to_s
+            result = @@addressing_registry.dig(alternative_key, field)
+            return result if result
+          end
+          
+          # Move up the inheritance chain
+          current_class = current_class.superclass
+          
+          # Stop if we reach SmartMessage::Base or above
+          break if current_class == SmartMessage::Base || current_class.nil?
+        end
+        
+        nil
+      end
+
+      def from(entity_id = nil)
+        class_name = self.name || self.to_s
+        if entity_id.nil?
+          # Try to find the value, checking inheritance chain
+          result = find_addressing_value(:from)
+          result
+        else
+          @@addressing_registry[class_name] ||= {}
+          @@addressing_registry[class_name][:from] = entity_id
+        end
+      end
+      
+      def from_configured?; !from.nil?; end
+      def from_missing?;     from.nil?; end
+      def reset_from; 
+        class_name = self.name || self.to_s
+        @@addressing_registry[class_name] ||= {}
+        @@addressing_registry[class_name][:from] = nil
+      end
+
+      def to(entity_id = nil)
+        class_name = self.name || self.to_s
+        if entity_id.nil?
+          # Try to find the value, checking inheritance chain
+          result = find_addressing_value(:to)
+          result
+        else
+          @@addressing_registry[class_name] ||= {}
+          @@addressing_registry[class_name][:to] = entity_id
+        end
+      end
+      
+      def to_configured?;   !to.nil?; end
+      def to_missing?;       to.nil?; end
+      def reset_to; 
+        class_name = self.name || self.to_s
+        @@addressing_registry[class_name] ||= {}
+        @@addressing_registry[class_name][:to] = nil
+      end
+
+      def reply_to(entity_id = nil)
+        class_name = self.name || self.to_s
+        if entity_id.nil?
+          # Try to find the value, checking inheritance chain
+          result = find_addressing_value(:reply_to)
+          result
+        else
+          @@addressing_registry[class_name] ||= {}
+          @@addressing_registry[class_name][:reply_to] = entity_id
+        end
+      end
+      
+      def reply_to_configured?; !reply_to.nil?; end
+      def reply_to_missing?;     reply_to.nil?; end
+      def reset_reply_to; 
+        class_name = self.name || self.to_s
+        @@addressing_registry[class_name] ||= {}
+        @@addressing_registry[class_name][:reply_to] = nil
+      end
+
+
       #########################################################
       ## class-level subscription management via the transport
 
@@ -369,25 +545,30 @@ module SmartMessage
       #   - String: Method name like "MyService.handle_message" 
       #   - Proc: A proc/lambda that accepts (message_header, message_payload)
       #   - nil: Uses default "MessageClass.process" method
+      # @param broadcast [Boolean, nil] Filter for broadcast messages (to: nil)
+      # @param to [String, Array, nil] Filter for messages directed to specific entities
+      # @param from [String, Array, nil] Filter for messages from specific entities
       # @param block [Proc] Alternative way to pass a processing block
       # @return [String] The identifier used for this subscription
       #
-      # @example Using default handler
+      # @example Using default handler (all messages)
       #   MyMessage.subscribe
       #
-      # @example Using custom method name
-      #   MyMessage.subscribe("MyService.handle_message")
+      # @example Using custom method name with filtering
+      #   MyMessage.subscribe("MyService.handle_message", to: 'my-service')
       #
-      # @example Using a block
-      #   MyMessage.subscribe do |header, payload|
+      # @example Using a block with broadcast filtering
+      #   MyMessage.subscribe(broadcast: true) do |header, payload|
       #     data = JSON.parse(payload)
-      #     puts "Received: #{data}"
+      #     puts "Received broadcast: #{data}"
       #   end
       #
-      # @example Using a proc
-      #   handler = proc { |header, payload| puts "Processing..." }
-      #   MyMessage.subscribe(handler)
-      def subscribe(process_method = nil, &block)
+      # @example Entity-specific filtering
+      #   MyMessage.subscribe(to: 'order-service', from: ['payment', 'user'])
+      #
+      # @example Broadcast + directed messages
+      #   MyMessage.subscribe(to: 'my-service', broadcast: true)
+      def subscribe(process_method = nil, broadcast: nil, to: nil, from: nil, &block)
         message_class = whoami
         
         # Handle different parameter types
@@ -405,10 +586,21 @@ module SmartMessage
         end
         # If process_method is a String, use it as-is
 
+        # Normalize string filters to arrays
+        to_filter = normalize_filter_value(to)
+        from_filter = normalize_filter_value(from)
+        
+        # Create filter options
+        filter_options = {
+          broadcast: broadcast,
+          to: to_filter,
+          from: from_filter
+        }
+
         # TODO: Add proper logging here
 
         raise Errors::TransportNotConfigured if transport_missing?
-        transport.subscribe(message_class, process_method)
+        transport.subscribe(message_class, process_method, filter_options)
         
         process_method
       end

data/lib/smart_message/circuit_breaker.rb

@@ -0,0 +1,227 @@
+# lib/smart_message/circuit_breaker.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'breaker_machines'
+
+module SmartMessage
+  # Circuit breaker configuration and management for SmartMessage
+  # Provides production-grade reliability patterns using BreakerMachines gem
+  module CircuitBreaker
+    extend self
+
+    # Default circuit breaker configurations
+    DEFAULT_CONFIGS = {
+      message_processor: {
+        threshold: { failures: 3, within: 60 }, # 3 failures within 1 minute
+        reset_after: 30,                        # Reset after 30 seconds
+        storage: :memory                        # Use memory storage by default
+      },
+      transport_publish: {
+        threshold: { failures: 5, within: 30 }, # 5 failures within 30 seconds
+        reset_after: 15,                        # Reset after 15 seconds
+        storage: :memory
+      },
+      transport_subscribe: {
+        threshold: { failures: 3, within: 60 }, # 3 failures within 1 minute
+        reset_after: 45,                        # Reset after 45 seconds
+        storage: :memory
+      },
+      serializer: {
+        threshold: { failures: 5, within: 30 }, # 5 failures within 30 seconds
+        reset_after: 10,                        # Reset after 10 seconds
+        storage: :memory
+      },
+      dispatcher_shutdown: {
+        threshold: { failures: 2, within: 10 }, # 2 failures within 10 seconds
+        reset_after: 5,                         # Reset after 5 seconds
+        storage: :memory
+      }
+    }.freeze
+
+    # Configure circuit breakers for a class
+    # @param target_class [Class] The class to add circuit breakers to
+    # @param options [Hash] Configuration options
+    def configure_for(target_class, options = {})
+      target_class.include BreakerMachines::DSL
+      
+      # Configure each circuit breaker type
+      DEFAULT_CONFIGS.each do |circuit_name, config|
+        final_config = config.merge(options[circuit_name] || {})
+        
+        target_class.circuit circuit_name do
+          threshold failures: final_config[:threshold][:failures], 
+                   within: final_config[:threshold][:within].seconds
+          reset_after final_config[:reset_after].seconds
+          
+          # Configure storage backend
+          case final_config[:storage]
+          when :redis
+            # Use Redis storage if configured
+            storage BreakerMachines::Storage::Redis.new(
+              redis: SmartMessage::Transport::RedisTransport.new.redis_pub
+            )
+          else
+            # Default to memory storage
+            storage BreakerMachines::Storage::Memory.new
+          end
+          
+          # Default fallback that logs the failure
+          fallback do |exception|
+            {
+              circuit_breaker: {
+                circuit: circuit_name,
+                state: 'open',
+                error: exception.message,
+                timestamp: Time.now.iso8601,
+                fallback_triggered: true
+              }
+            }
+          end
+        end
+      end
+    end
+
+    # Create a specialized circuit breaker for entity-specific processing
+    # @param target_class [Class] The class to add the circuit to
+    # @param entity_id [String] The entity identifier
+    # @param options [Hash] Configuration options
+    def configure_entity_circuit(target_class, entity_id, options = {})
+      circuit_name = "entity_#{entity_id}".to_sym
+      config = DEFAULT_CONFIGS[:message_processor].merge(options)
+      
+      target_class.circuit circuit_name do
+        threshold failures: config[:threshold][:failures], 
+                 within: config[:threshold][:within].seconds
+        reset_after config[:reset_after].seconds
+        
+        # Configure storage
+        case config[:storage]
+        when :redis
+          storage BreakerMachines::Storage::Redis.new(
+            redis: SmartMessage::Transport::RedisTransport.new.redis_pub
+          )
+        else
+          storage BreakerMachines::Storage::Memory.new
+        end
+        
+        # Entity-specific fallback
+        fallback do |exception|
+          {
+            circuit_breaker: {
+              circuit: circuit_name,
+              entity_id: entity_id,
+              state: 'open',
+              error: exception.message,
+              timestamp: Time.now.iso8601,
+              fallback_triggered: true
+            }
+          }
+        end
+      end
+      
+      circuit_name
+    end
+
+    # Get circuit breaker statistics
+    # @param circuit_instance [Object] Instance with circuit breakers
+    # @param circuit_name [Symbol] Name of the circuit
+    def stats(circuit_instance, circuit_name)
+      breaker = circuit_instance.circuit(circuit_name)
+      return nil unless breaker
+      
+      {
+        name: circuit_name,
+        state: breaker.state,
+        failure_count: breaker.failure_count,
+        last_failure_time: breaker.last_failure_time,
+        next_attempt_time: breaker.next_attempt_time
+      }
+    end
+
+    # Check if circuit breaker is available (closed or half-open)
+    # @param circuit_instance [Object] Instance with circuit breakers
+    # @param circuit_name [Symbol] Name of the circuit
+    def available?(circuit_instance, circuit_name)
+      breaker = circuit_instance.circuit(circuit_name)
+      return true unless breaker # No circuit breaker means always available
+      
+      breaker.state != :open
+    end
+
+    # Manually reset a circuit breaker
+    # @param circuit_instance [Object] Instance with circuit breakers
+    # @param circuit_name [Symbol] Name of the circuit
+    def reset!(circuit_instance, circuit_name)
+      breaker = circuit_instance.circuit(circuit_name)
+      breaker&.reset!
+    end
+
+    # Configure fallback handlers for different scenarios
+    module Fallbacks
+      # Dead letter queue fallback
+      def self.dead_letter_queue(dlq_transport = nil)
+        proc do |exception, *args|
+          # Extract message details from args if available
+          message_header = args[0] if args[0].is_a?(SmartMessage::Header)
+          message_payload = args[1] if args.length > 1
+          
+          # Log to dead letter queue if transport provided
+          if dlq_transport && message_header && message_payload
+            dlq_transport.publish(message_header, message_payload)
+          end
+          
+          {
+            circuit_breaker: {
+              state: 'open',
+              error: exception.message,
+              sent_to_dlq: !!(dlq_transport && message_header && message_payload),
+              timestamp: Time.now.iso8601
+            }
+          }
+        end
+      end
+
+      # Retry with exponential backoff fallback
+      def self.retry_with_backoff(max_retries: 3, base_delay: 1)
+        proc do |exception, *args|
+          retry_count = Thread.current[:circuit_retry_count] ||= 0
+          
+          if retry_count < max_retries
+            Thread.current[:circuit_retry_count] += 1
+            delay = base_delay * (2 ** retry_count)
+            sleep(delay)
+            
+            # Re-raise to trigger retry
+            raise exception
+          else
+            Thread.current[:circuit_retry_count] = nil
+            
+            {
+              circuit_breaker: {
+                state: 'open',
+                error: exception.message,
+                max_retries_exceeded: true,
+                timestamp: Time.now.iso8601
+              }
+            }
+          end
+        end
+      end
+
+      # Graceful degradation fallback
+      def self.graceful_degradation(degraded_response)
+        proc do |exception|
+          {
+            circuit_breaker: {
+              state: 'open',
+              error: exception.message,
+              degraded_response: degraded_response,
+              timestamp: Time.now.iso8601
+            }
+          }
+        end
+      end
+    end
+  end
+end