smart_message 0.0.6 → 0.0.8

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,243 @@
+# 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 - stores failed messages to file-based DLQ
+      def self.dead_letter_queue(dlq_instance = 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
+          
+          # Use provided DLQ instance or default
+          dlq = dlq_instance || SmartMessage::DeadLetterQueue.default
+          
+          # Store failed message in dead letter queue
+          sent_to_dlq = false
+          if message_header && message_payload
+            begin
+              dlq.enqueue(message_header, message_payload, 
+                error: exception.message,
+                retry_count: 0,
+                serializer: 'json',  # Default to JSON, could be enhanced to detect actual serializer
+                stack_trace: exception.backtrace&.join("\n")
+              )
+              sent_to_dlq = true
+            rescue => dlq_error
+              # DLQ storage failed - log but don't raise
+              puts "Warning: Failed to store message in DLQ: #{dlq_error.message}" if $DEBUG
+            end
+          end
+          
+          {
+            circuit_breaker: {
+              circuit: :transport_publish,  # Default circuit name, overridden by specific configurations
+              state: 'open',
+              error: exception.message,
+              sent_to_dlq: sent_to_dlq,
+              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