smart_message 0.0.6 → 0.0.7

data/examples/08_entity_addressing_with_filtering.rb

@@ -87,7 +87,8 @@ puts "\n📤 Publishing test messages..."
 # Broadcast message - should only be received by broadcast handler
 broadcast_msg = ServiceMessage.new(
   message_type: 'system_announcement',
-  data: 'System maintenance at 2 AM'
+  data: 'System maintenance at 2 AM',
+  from: 'sender-service'
 )
 broadcast_msg.to(nil)  # Explicitly set as broadcast
 puts "\n1. Publishing broadcast message (no 'to' field)..."
@@ -97,7 +98,8 @@ sleep(0.2)  # Allow time for handlers to process
 # Directed message to 'my-service' - should only be received by directed handler
 directed_msg = ServiceMessage.new(
   message_type: 'service_update',
-  data: 'Update your configuration'
+  data: 'Update your configuration',
+  from: 'sender-service'
 )
 directed_msg.to('my-service')
 puts "\n2. Publishing message to 'my-service'..."
@@ -107,7 +109,8 @@ sleep(0.2)  # Allow time for handlers to process
 # Directed message to different service - should NOT be received
 other_msg = ServiceMessage.new(
   message_type: 'other_update',
-  data: 'This is for another service'
+  data: 'This is for another service',
+  from: 'sender-service'
 )
 other_msg.to('other-service')
 puts "\n3. Publishing message to 'other-service' (should not be received)..."
@@ -117,7 +120,8 @@ sleep(0.2)  # Allow time to confirm no handlers process this
 # Message from admin - should only be received by admin handler
 admin_msg = ServiceMessage.new(
   message_type: 'admin_command',
-  data: 'Restart all services'
+  data: 'Restart all services',
+  from: 'admin-service'
 )
 admin_msg.from('admin-service')
 admin_msg.to('my-service')
@@ -191,7 +195,8 @@ puts "\n📤 Publishing alert messages..."
 broadcast_alert = AlertMessage.new(
   severity: 'warning',
   alert_text: 'CPU usage high across cluster',
-  source_system: 'cluster-monitor'
+  source_system: 'cluster-monitor',
+  from: 'monitoring-system-1'
 )
 broadcast_alert.from('monitoring-system-1')
 broadcast_alert.to(nil)  # Broadcast
@@ -203,7 +208,8 @@ sleep(0.2)  # Allow time for handlers to process
 directed_alert = AlertMessage.new(
   severity: 'critical',
   alert_text: 'Database connection lost',
-  source_system: 'db-monitor'
+  source_system: 'db-monitor',
+  from: 'monitoring-system-2'
 )
 directed_alert.from('monitoring-system-2')
 directed_alert.to('alert-service')
@@ -215,7 +221,8 @@ sleep(0.2)  # Allow time for handlers to process
 other_alert = AlertMessage.new(
   severity: 'info',
   alert_text: 'Backup completed successfully',
-  source_system: 'backup-system'
+  source_system: 'backup-system',
+  from: 'monitoring-system-1'
 )
 other_alert.from('monitoring-system-1')
 other_alert.to('backup-service')
@@ -285,7 +292,8 @@ normal_order = OrderMessage.new(
   order_id: "ORD-001",
   priority: 'normal',
   items: ["Widget A", "Widget B"],
-  total_amount: 99.99
+  total_amount: 99.99,
+  from: 'order-service'
 )
 puts "\n1. Publishing normal order to fulfillment..."
 normal_order.publish
@@ -296,7 +304,8 @@ high_priority_order = OrderMessage.new(
   order_id: "ORD-002",
   priority: 'high',
   items: ["Premium Widget", "Express Gadget"],
-  total_amount: 999.99
+  total_amount: 999.99,
+  from: 'order-service'
 )
 puts "\n2. Publishing high-priority order..."
 high_priority_order.publish
@@ -307,7 +316,8 @@ misrouted_order = OrderMessage.new(
   order_id: "ORD-003",
   priority: 'normal',
   items: ["Test Item"],
-  total_amount: 50.00
+  total_amount: 50.00,
+  from: 'order-service'
 )
 misrouted_order.to('wrong-service')
 puts "\n3. Publishing order to 'wrong-service' (should not be received)..."
@@ -371,7 +381,8 @@ puts "\n📤 Publishing service requests..."
 api_request = ServiceRequest.new(
   request_id: SecureRandom.uuid,
   request_type: 'user_lookup',
-  data: { user_id: 'USER-123' }
+  data: { user_id: 'USER-123' },
+  from: 'web-frontend'
 )
 api_request.from('web-frontend')
 api_request.to('api-service')
@@ -384,7 +395,8 @@ sleep(0.2)  # Allow time for handlers to process
 data_request = ServiceRequest.new(
   request_id: SecureRandom.uuid,
   request_type: 'query',
-  data: { table: 'orders', limit: 100 }
+  data: { table: 'orders', limit: 100 },
+  from: 'analytics-service'
 )
 data_request.from('analytics-service')
 data_request.to('data-service')

data/examples/tmux_chat/bot_agent.rb

@@ -110,7 +110,8 @@ class BotChatAgent < BaseAgent
       user_name: chat_data['sender_name'],
       command: command,
       parameters: parameters,
-      timestamp: Time.now.iso8601
+      timestamp: Time.now.iso8601,
+      from: chat_data['sender_id']
     )
     
     bot_command.publish

data/examples/tmux_chat/shared_chat_system.rb

@@ -244,7 +244,8 @@ class BaseAgent
       message_type: message_type,
       timestamp: Time.now.iso8601,
       mentions: extract_mentions(content),
-      metadata: { agent_type: @agent_type }
+      metadata: { agent_type: @agent_type },
+      from: @agent_id
     )
     
     log_display("💬 [#{room_id}] #{@name}: #{content}")
@@ -291,7 +292,8 @@ class BaseAgent
       notification_type: notification_type,
       content: content,
       timestamp: Time.now.iso8601,
-      metadata: { triggered_by: @agent_id }
+      metadata: { triggered_by: @agent_id },
+      from: @agent_id
     )
     
     notification.publish

data/lib/smart_message/base.rb

@@ -73,10 +73,13 @@ module SmartMessage
       @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        = nil
-      @to          = nil
-      @reply_to    = nil
+      @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(

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

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
 
@@ -139,7 +138,8 @@ module SmartMessage
         
         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
@@ -153,17 +153,63 @@ 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
+
+    # 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
 
-    private
+    # 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
@@ -199,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/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