smart_message 0.0.8 → 0.0.9

data/lib/smart_message/circuit_breaker.rb

@@ -182,7 +182,8 @@ module SmartMessage
               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
+              # Note: Logger might not be available in circuit breaker context
+              warn "Warning: Failed to store message in DLQ: #{dlq_error.message}"
             end
           end
           

data/lib/smart_message/configuration.rb

@@ -0,0 +1,199 @@
+# lib/smart_message/configuration.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  # Global configuration class for SmartMessage framework
+  #
+  # This class provides a centralized way for applications to configure
+  # default behavior for all SmartMessage classes. Applications can set
+  # global defaults for logger, transport, and serializer, which will be
+  # used by all message classes unless explicitly overridden.
+  #
+  # IMPORTANT: No configuration = NO LOGGING
+  # Applications must explicitly configure logging if they want it.
+  #
+  # Usage:
+  #   # No configuration block = NO LOGGING (default behavior)
+  #   
+  #   # Use framework default logger (Lumberjack) with custom log file:
+  #   SmartMessage.configure do |config|
+  #     config.logger = "log/my_app.log"              # String path = Lumberjack logger
+  #   end
+  #   
+  #   # Use framework default logger with STDOUT/STDERR:
+  #   SmartMessage.configure do |config|
+  #     config.logger = STDOUT                        # Log to STDOUT
+  #     config.logger = STDERR                        # Log to STDERR
+  #   end
+  #   
+  #   # Use framework default logger with default file (log/smart_message.log):
+  #   SmartMessage.configure do |config|
+  #     config.logger = :default                      # Framework default
+  #   end
+  #
+  #   # Configure Lumberjack logger options:
+  #   SmartMessage.configure do |config|
+  #     config.logger = :default                      # Use framework default
+  #     config.log_level = :debug                     # :debug, :info, :warn, :error, :fatal
+  #     config.log_format = :json                     # :text or :json
+  #     config.log_include_source = true              # Include file:line source info
+  #     config.log_structured_data = true             # Include structured message data
+  #     config.log_colorize = true                    # Enable colorized output (console only)
+  #     config.log_options = {                        # Additional Lumberjack options
+  #       roll_by_date: true,                         # Enable date-based log rolling
+  #       date_pattern: '%Y-%m-%d',                   # Date pattern for rolling
+  #       roll_by_size: true,                         # Enable size-based log rolling
+  #       max_file_size: 50 * 1024 * 1024,            # Max file size before rolling (50 MB)
+  #       keep_files: 10                              # Number of rolled files to keep
+  #     }
+  #   end
+  #
+  #   # Use custom logger:
+  #   SmartMessage.configure do |config|
+  #     config.logger = MyApp::Logger.new             # Custom logger object
+  #     config.transport = MyApp::Transport.new
+  #     config.serializer = MyApp::Serializer.new
+  #   end
+  #
+  #   # Explicitly disable logging:
+  #   SmartMessage.configure do |config|
+  #     config.logger = nil                           # Explicit no logging
+  #   end
+  #
+  #   # Individual message classes use these defaults automatically
+  #   class OrderMessage < SmartMessage::Base
+  #     property :order_id
+  #     # No config block needed - uses global defaults
+  #   end
+  #
+  #   # Override global defaults when needed
+  #   class SpecialMessage < SmartMessage::Base
+  #     config do
+  #       logger MyApp::SpecialLogger.new  # Override just the logger
+  #       # transport and serializer still use global defaults
+  #     end
+  #   end
+  class Configuration
+    attr_accessor :transport, :serializer, :log_level, :log_format, :log_include_source, :log_structured_data, :log_colorize, :log_options
+    attr_reader :logger
+    
+    def initialize
+      @logger = nil
+      @transport = nil
+      @serializer = nil
+      @logger_explicitly_set_to_nil = false
+      @log_level = nil
+      @log_format = nil
+      @log_include_source = nil
+      @log_structured_data = nil
+      @log_colorize = nil
+      @log_options = {}
+    end
+    
+    # Custom logger setter to track explicit nil assignment
+    def logger=(value)
+      @logger = value
+      @logger_explicitly_set_to_nil = value.nil?
+    end
+    
+    # Reset configuration to defaults
+    def reset!
+      @logger = nil
+      @transport = nil
+      @serializer = nil
+      @logger_explicitly_set_to_nil = false
+      @log_level = nil
+      @log_format = nil
+      @log_include_source = nil
+      @log_structured_data = nil
+      @log_colorize = nil
+      @log_options = {}
+    end
+    
+    # Check if logger is configured (including explicit nil for no logging)
+    def logger_configured?
+      !@logger.nil? || @logger_explicitly_set_to_nil || @logger == :default || @logger.is_a?(String) || @logger == STDOUT || @logger == STDERR
+    end
+    
+    # Check if transport is configured
+    def transport_configured?
+      !@transport.nil?
+    end
+    
+    # Check if serializer is configured
+    def serializer_configured?
+      !@serializer.nil?
+    end
+    
+    # Get the configured logger or no logging
+    def default_logger
+      case @logger
+      when nil
+        # If explicitly set to nil, use null logger (no logging)
+        if @logger_explicitly_set_to_nil
+          SmartMessage::Logger::Null.new
+        else
+          # Not configured, NO LOGGING
+          SmartMessage::Logger::Null.new
+        end
+      when :default
+        # Explicitly requested framework default
+        framework_default_logger
+      when String
+        # String path means use Lumberjack logger with that file path
+        SmartMessage::Logger::Lumberjack.new(**logger_options.merge(log_file: @logger))
+      when STDOUT, STDERR
+        # STDOUT/STDERR constants mean use Lumberjack logger with that output
+        SmartMessage::Logger::Lumberjack.new(**logger_options.merge(log_file: @logger))
+      else
+        @logger
+      end
+    end
+    
+    # Get the configured transport or framework default
+    def default_transport
+      @transport || framework_default_transport
+    end
+    
+    # Get the configured serializer or framework default
+    def default_serializer
+      @serializer || framework_default_serializer
+    end
+    
+    private
+    
+    # Framework's built-in default logger (Lumberjack)
+    def framework_default_logger
+      SmartMessage::Logger::Lumberjack.new(**logger_options)
+    end
+    
+    # Build logger options from configuration
+    def logger_options
+      options = {}
+      options[:level] = @log_level if @log_level
+      options[:format] = @log_format if @log_format
+      options[:include_source] = @log_include_source unless @log_include_source.nil?
+      options[:structured_data] = @log_structured_data unless @log_structured_data.nil?
+      options[:colorize] = @log_colorize unless @log_colorize.nil?
+      
+      # Merge in log_options (for roll_by_date, roll_by_size, max_file_size, etc.)
+      options.merge!(@log_options) if @log_options && @log_options.is_a?(Hash)
+      
+      options
+    end
+    
+    # Framework's built-in default transport (Redis)
+    def framework_default_transport
+      SmartMessage::Transport::RedisTransport.new
+    end
+    
+    # Framework's built-in default serializer (JSON)
+    def framework_default_serializer
+      SmartMessage::Serializer::Json.new
+    rescue => e
+      # Fallback if JSON serializer is not available
+      nil
+    end
+  end
+end

data/lib/smart_message/dead_letter_queue.rb

@@ -26,20 +26,35 @@ module SmartMessage
       @file_path = File.expand_path(file_path)
       @mutex = Mutex.new
       ensure_directory_exists
+      
+      logger.debug { "[SmartMessage::DeadLetterQueue] Initialized with file path: #{@file_path}" }
+    rescue => e
+      logger&.error { "[SmartMessage] Error in dead letter queue initialization: #{e.class.name} - #{e.message}" }
+      raise
+    end
+    
+    private
+    
+    def logger
+      @logger ||= SmartMessage::Logger.default
     end
+    
+    public
 
     # Core FIFO queue operations
 
     # Add a failed message to the dead letter queue
-    # @param message_header [SmartMessage::Header] The message header
-    # @param message_payload [String] The serialized message payload
+    # @param message [SmartMessage::Base] The message instance
     # @param error_info [Hash] Error details including :error, :retry_count, :transport, etc.
-    def enqueue(message_header, message_payload, error_info = {})
+    def enqueue(message, error_info = {})
+      message_header = message._sm_header
+      message_payload = message.encode
+
       entry = {
         timestamp: Time.now.iso8601,
         header: message_header.to_hash,
         payload: message_payload,
-        payload_format: error_info[:serializer] || 'json',  # Track serialization format
+        payload_format: error_info[:serializer] || 'json',
         error: error_info[:error] || 'Unknown error',
         retry_count: error_info[:retry_count] || 0,
         transport: error_info[:transport],
@@ -77,7 +92,7 @@ module SmartMessage
         oldest_entry
       end
     rescue JSON::ParserError => e
-      puts "Warning: Corrupted DLQ entry skipped: #{e.message}" if $DEBUG
+      logger.warn { "[SmartMessage] Warning: Corrupted DLQ entry skipped: #{e.message}" }
       nil
     end
 
@@ -209,8 +224,10 @@ module SmartMessage
       read_entries_with_filter do |entry|
         stats[:total] += 1
         
-        message_class = entry.dig(:header, :message_class) || 'Unknown'
-        stats[:by_class][message_class] += 1
+        full_class_name = entry.dig(:header, :message_class) || 'Unknown'
+        # Extract short class name (everything after the last ::)
+        short_class_name = full_class_name.split('::').last || full_class_name
+        stats[:by_class][short_class_name] += 1
         
         error = entry[:error] || 'Unknown error'
         stats[:by_error][error] += 1
@@ -286,11 +303,11 @@ module SmartMessage
         JSON.parse(payload, symbolize_names: true)
       else
         # For unknown formats, assume JSON as fallback but log warning
-        puts "Warning: Unknown payload format '#{format}', attempting JSON" if $DEBUG
+        logger.warn { "[SmartMessage] Warning: Unknown payload format '#{format}', attempting JSON" }
         JSON.parse(payload, symbolize_names: true)
       end
     rescue JSON::ParserError => e
-      puts "Error: Failed to deserialize payload as #{format}: #{e.message}" if $DEBUG
+      logger.error { "[SmartMessage] Error in payload deserialization: #{e.class.name} - #{e.message}" }
       nil
     end
 
@@ -310,7 +327,7 @@ module SmartMessage
       message._sm_header.to = header_data[:to] if header_data[:to]
       message._sm_header.reply_to = header_data[:reply_to] if header_data[:reply_to]
     rescue => e
-      puts "Warning: Failed to restore some header fields: #{e.message}" if $DEBUG
+      logger.warn { "[SmartMessage] Warning: Failed to restore some header fields: #{e.message}" }
     end
 
     # Generic file reading iterator with error handling

data/lib/smart_message/dispatcher.rb

@@ -15,15 +15,28 @@ module SmartMessage
     # TODO: setup forwardable for some @router_pool methods
 
     def initialize(circuit_breaker_options = {})
-      @subscribers = Hash.new(Array.new)
+      @subscribers = Hash.new { |h, k| h[k] = [] }
       @router_pool = Concurrent::CachedThreadPool.new
-      
+
       # Configure circuit breakers
       configure_circuit_breakers(circuit_breaker_options)
       at_exit do
         shutdown_pool
       end
+      
+      logger.debug { "[SmartMessage::Dispatcher] Initialized with circuit breaker options: #{circuit_breaker_options}" }
+    rescue => e
+      logger.error { "[SmartMessage] Error in dispatcher initialization: #{e.class.name} - #{e.message}" }
+      raise
+    end
+    
+    private
+    
+    def logger
+      @logger ||= SmartMessage::Logger.default
     end
+    
+    public
 
 
     def what_can_i_do?
@@ -84,20 +97,20 @@ module SmartMessage
 
     def add(message_class, process_method_as_string, filter_options = {})
       klass = String(message_class)
-      
+
       # 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]
+        @subscribers[klass] << subscription
       end
     end
 
@@ -117,25 +130,27 @@ module SmartMessage
 
     # complete reset all subscriptions
     def drop_all!
-      @subscribers = Hash.new(Array.new)
+      @subscribers = Hash.new { |h, k| h[k] = [] }
     end
 
 
-    # message_header is of class SmartMessage::Header
-    # message_payload is a string buffer that is a serialized
-    # SmartMessage
-    def route(message_header, message_payload)
+    # Route a decoded message to appropriate message processors
+    # @param decoded_message [SmartMessage::Base] The decoded message instance
+    def route(decoded_message)
+      message_header = decoded_message._sm_header
       message_klass = message_header.message_class
-      return nil if @subscribers[message_klass].empty?
-      
+      logger.debug { "[SmartMessage::Dispatcher] Routing message #{message_klass} to #{@subscribers[message_klass]&.size || 0} subscribers" }
+      logger.debug { "[SmartMessage::Dispatcher] Available subscribers: #{@subscribers.keys}" }
+      return nil if @subscribers[message_klass].nil? || @subscribers[message_klass].empty?
+
       @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
           # Use circuit breaker to protect message processing
@@ -143,21 +158,21 @@ module SmartMessage
             # Check if this is a proc handler or a regular method call
             if proc_handler?(message_processor)
               # Call the proc handler via SmartMessage::Base
-              SmartMessage::Base.call_proc_handler(message_processor, message_header, message_payload)
+              SmartMessage::Base.call_proc_handler(message_processor, decoded_message)
             else
-              # Original method call logic
+              # Method call logic with decoded message
               parts         = message_processor.split('.')
               target_klass  = parts[0]
               class_method  = parts[1]
               target_klass.constantize
                           .method(class_method)
-                          .call(message_header, message_payload)
+                          .call(decoded_message)
             end
           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)
+            handle_circuit_breaker_fallback(circuit_result, decoded_message, message_processor)
           end
         end
       end
@@ -167,7 +182,7 @@ module SmartMessage
     # @return [Hash] Circuit breaker statistics
     def circuit_breaker_stats
       stats = {}
-      
+
       begin
         if respond_to?(:circuit)
           breaker = circuit(:message_processor)
@@ -186,7 +201,7 @@ module SmartMessage
       rescue => e
         stats[:error] = "Failed to get circuit breaker stats: #{e.message}"
       end
-      
+
       stats
     end
 
@@ -204,7 +219,7 @@ module SmartMessage
     # 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
@@ -218,26 +233,46 @@ module SmartMessage
     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)
+        from_match = filter_value_matches?(message_header.from, filters[: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)
-        
+        to_match = filters[:to] && filter_value_matches?(message_header.to, filters[: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 value matches any of the filter criteria
+    # Supports both exact string matching and regex pattern matching
+    # @param value [String, nil] The value to match against
+    # @param filter_array [Array] Array of strings and/or regexps to match against
+    # @return [Boolean] True if the value matches any filter in the array
+    def filter_value_matches?(value, filter_array)
+      return false if value.nil? || filter_array.nil?
+
+      filter_array.any? do |filter|
+        case filter
+        when String
+          filter == value
+        when Regexp
+          filter.match?(value)
+        else
+          false
+        end
+      end
+    end
+
     # Check if a message processor is a proc handler
     # @param message_processor [String] The message processor identifier
     # @return [Boolean] True if this is a proc handler
@@ -250,19 +285,19 @@ module SmartMessage
     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], 
+        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
@@ -281,7 +316,7 @@ module SmartMessage
         else
           storage BreakerMachines::Storage::Memory.new
         end
-        
+
         # Default fallback for message processing failures
         fallback do |exception|
           {
@@ -296,27 +331,33 @@ module SmartMessage
           }
         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 decoded_message [SmartMessage::Base] The decoded message instance
     # @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
-      
+    def handle_circuit_breaker_fallback(circuit_result, decoded_message, message_processor)
+      message_header = decoded_message._sm_header
+
+      # Always log circuit breaker activation for debugging
+      error_msg = circuit_result[:circuit_breaker][:error]
+      logger.error { "[SmartMessage::Dispatcher] Circuit breaker activated for processor: #{message_processor}" }
+      logger.error { "[SmartMessage::Dispatcher] Error: #{error_msg}" }
+      logger.error { "[SmartMessage::Dispatcher] Message: #{message_header.message_class} from #{message_header.from}" }
+
+      # Send to dead letter queue
+      SmartMessage::DeadLetterQueue.default.enqueue(decoded_message,
+        error: circuit_result[:circuit_breaker][:error],
+        retry_count: 0,
+        transport: 'circuit_breaker'
+      )
+
       # 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
+
+      # Record the failure in simple stats
       SS.add(message_header.message_class, message_processor, 'circuit_breaker_fallback')
     end
 

data/lib/smart_message/header.rb

@@ -57,5 +57,10 @@ module SmartMessage
     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"
+    
+    # Serialization tracking for wrapper architecture
+    property :serializer,
+      required: false,
+      description: "Class name of the serializer used to encode the payload (e.g., 'SmartMessage::Serializer::Json'). Used by DLQ and cross-serializer gateway patterns"
   end
 end

data/lib/smart_message/logger/base.rb

@@ -4,5 +4,25 @@
 
 module SmartMessage::Logger
   class Base
+    # Standard logging methods that subclasses should implement
+    def debug(message = nil, &block)
+      raise NotImplementedError, "Subclass must implement #debug"
+    end
+
+    def info(message = nil, &block)
+      raise NotImplementedError, "Subclass must implement #info"
+    end
+
+    def warn(message = nil, &block)
+      raise NotImplementedError, "Subclass must implement #warn"
+    end
+
+    def error(message = nil, &block)
+      raise NotImplementedError, "Subclass must implement #error"
+    end
+
+    def fatal(message = nil, &block)
+      raise NotImplementedError, "Subclass must implement #fatal"
+    end
   end
-end # module SmartMessage::Logger
+end # module SmartMessage::Logger