smart_message 0.0.7 → 0.0.9

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

data/lib/smart_message/logger/default.rb

@@ -9,170 +9,141 @@ require 'stringio'
 module SmartMessage
   module Logger
     # Default logger implementation for SmartMessage
-    # 
-    # This logger automatically detects and uses the best available logging option:
-    # - Rails.logger if running in a Rails application
-    # - Standard Ruby Logger writing to log/smart_message.log otherwise
+    #
+    # This logger provides a simple Ruby Logger wrapper with enhanced formatting.
+    # Applications can easily configure Rails.logger or other loggers through
+    # the global configuration system instead.
     #
     # Usage:
-    #   # In your message class
-    #   config do
-    #     logger SmartMessage::Logger::Default.new
+    #   # Use default file logging
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Default.new
     #   end
     #
-    #   # Or with custom options
-    #   config do
-    #     logger SmartMessage::Logger::Default.new(
-    #       log_file: 'custom/path.log',    # File path
+    #   # Use custom options
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Default.new(
+    #       log_file: 'custom/path.log',
     #       level: Logger::DEBUG
     #     )
     #   end
     #
-    #   # To log to STDOUT instead of a file
-    #   config do
-    #     logger SmartMessage::Logger::Default.new(
-    #       log_file: STDOUT,               # STDOUT or STDERR
+    #   # Log to STDOUT
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Default.new(
+    #       log_file: STDOUT,
     #       level: Logger::INFO
     #     )
     #   end
+    #
+    #   # Use Rails logger instead
+    #   SmartMessage.configure do |config|
+    #     config.logger = Rails.logger
+    #   end
     class Default < Base
       attr_reader :logger, :log_file, :level
-      
+
       def initialize(log_file: nil, level: nil)
-        @log_file = log_file || default_log_file
-        @level = level || default_log_level
-        
+        @log_file = log_file || 'log/smart_message.log'
+        @level = level || ::Logger::INFO
+
         @logger = setup_logger
       end
-      
-      # Message lifecycle logging methods
-      
-      def log_message_created(message)
-        logger.debug { "[SmartMessage] Created: #{message.class.name} - #{message_summary(message)}" }
-      end
-      
-      def log_message_published(message, transport)
-        logger.info { "[SmartMessage] Published: #{message.class.name} via #{transport.class.name.split('::').last}" }
-      end
-      
-      def log_message_received(message_class, payload)
-        logger.info { "[SmartMessage] Received: #{message_class.name} (#{payload.bytesize} bytes)" }
-      end
-      
-      def log_message_processed(message_class, result)
-        logger.info { "[SmartMessage] Processed: #{message_class.name} - #{truncate(result.to_s, 100)}" }
-      end
-      
-      def log_message_subscribe(message_class, handler = nil)
-        handler_desc = handler ? " with handler: #{handler}" : ""
-        logger.info { "[SmartMessage] Subscribed: #{message_class.name}#{handler_desc}" }
-      end
-      
-      def log_message_unsubscribe(message_class)
-        logger.info { "[SmartMessage] Unsubscribed: #{message_class.name}" }
-      end
-      
-      # Error logging
-      
-      def log_error(context, error)
-        logger.error { "[SmartMessage] Error in #{context}: #{error.class.name} - #{error.message}" }
-        logger.debug { "[SmartMessage] Backtrace:\n#{error.backtrace.join("\n")}" } if error.backtrace
-      end
-      
-      def log_warning(message)
-        logger.warn { "[SmartMessage] Warning: #{message}" }
-      end
-      
+
+
       # General purpose logging methods matching Ruby's Logger interface
-      
+      # These methods capture caller information and embed it in the log message
+
       def debug(message = nil, &block)
-        logger.debug(message, &block)
+        enhanced_log(:debug, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def info(message = nil, &block)
-        logger.info(message, &block)
+        enhanced_log(:info, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def warn(message = nil, &block)
-        logger.warn(message, &block)
+        enhanced_log(:warn, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def error(message = nil, &block)
-        logger.error(message, &block)
+        enhanced_log(:error, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def fatal(message = nil, &block)
-        logger.fatal(message, &block)
+        enhanced_log(:fatal, message, caller_locations(1, 1).first, &block)
       end
-      
+
       private
-      
-      def setup_logger
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          # Use Rails logger if available
-          setup_rails_logger
+
+      # Enhanced logging method that embeds caller information
+      def enhanced_log(level, message, caller_location, &block)
+        if caller_location
+          file_path = caller_location.path
+          line_number = caller_location.lineno
+          
+          # If a block is provided, call it to get the message
+          if block_given?
+            actual_message = block.call
+          else
+            actual_message = message
+          end
+          
+          # Embed caller info in the message
+          enhanced_message = "[#{file_path}:#{line_number}] #{actual_message}"
+          logger.send(level, enhanced_message)
         else
-          # Use standard Ruby logger
-          setup_ruby_logger
+          # Fallback if caller information is not available
+          if block_given?
+            logger.send(level, &block)
+          else
+            logger.send(level, message)
+          end
         end
       end
-      
-      def setup_rails_logger
-        # Wrap Rails.logger to ensure our messages are properly tagged
-        RailsLoggerWrapper.new(Rails.logger, level: @level)
-      end
-      
-      def setup_ruby_logger
+
+      def setup_logger
         # Handle IO objects (STDOUT, STDERR) vs file paths
         if @log_file.is_a?(IO) || @log_file.is_a?(StringIO)
           # For STDOUT/STDERR, don't use rotation
           ruby_logger = ::Logger.new(@log_file)
         else
           # For file paths, ensure directory exists and use rotation
-          FileUtils.mkdir_p(File.dirname(@log_file))
-          
+          log_dir = File.dirname(@log_file)
+          FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+
           ruby_logger = ::Logger.new(
             @log_file,
             10,           # Keep 10 old log files
             10_485_760    # Rotate when file reaches 10MB
           )
         end
-        
+
         ruby_logger.level = @level
-        
-        # Set a clean formatter
+
+        # Set a formatter that includes file and line number
         ruby_logger.formatter = proc do |severity, datetime, progname, msg|
           timestamp = datetime.strftime('%Y-%m-%d %H:%M:%S.%3N')
-          "[#{timestamp}] #{severity.ljust(5)} -- : #{msg}\n"
-        end
-        
-        ruby_logger
-      end
-      
-      def default_log_file
-        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-          Rails.root.join('log', 'smart_message.log').to_s
-        else
-          'log/smart_message.log'
-        end
-      end
-      
-      def default_log_level
-        if defined?(Rails) && Rails.respond_to?(:env)
-          case Rails.env
-          when 'production'
-            ::Logger::INFO
-          when 'test'
-            ::Logger::ERROR
+          
+          # Extract caller information if it's embedded in the message
+          if msg.is_a?(String) && msg.match(/\A\[(.+?):(\d+)\] (.+)\z/)
+            file_path = $1
+            line_number = $2
+            actual_msg = $3
+            
+            # Get just the filename from the full path
+            filename = File.basename(file_path)
+            
+            "[#{timestamp}] #{severity.ljust(5)} -- #{filename}:#{line_number} : #{actual_msg}\n"
           else
-            ::Logger::DEBUG
+            "[#{timestamp}] #{severity.ljust(5)} -- : #{msg}\n"
           end
-        else
-          # Default to INFO for non-Rails environments
-          ::Logger::INFO
         end
+
+        ruby_logger
       end
-      
+
+
       def message_summary(message)
         # Create a brief summary of the message for logging
         if message.respond_to?(:to_h)
@@ -185,33 +156,12 @@ module SmartMessage
           truncate(message.inspect, 200)
         end
       end
-      
+
       def truncate(string, max_length)
         return string if string.length <= max_length
         "#{string[0...max_length]}..."
       end
-      
-      # Internal wrapper for Rails.logger to handle tagged logging
-      class RailsLoggerWrapper
-        def initialize(rails_logger, level: nil)
-          @rails_logger = rails_logger
-          @rails_logger.level = level if level
-        end
-        
-        def method_missing(method, *args, &block)
-          if @rails_logger.respond_to?(:tagged)
-            @rails_logger.tagged('SmartMessage') do
-              @rails_logger.send(method, *args, &block)
-            end
-          else
-            @rails_logger.send(method, *args, &block)
-          end
-        end
-        
-        def respond_to_missing?(method, include_private = false)
-          @rails_logger.respond_to?(method, include_private)
-        end
-      end
+
     end
   end
-end
+end