smart_message 0.0.8 → 0.0.10

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/ddq/base.rb

@@ -0,0 +1,71 @@
+# lib/smart_message/ddq/base.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module DDQ
+    # Base class for Deduplication Queue implementations
+    # 
+    # Defines the interface that all DDQ storage backends must implement.
+    # Provides circular queue semantics with O(1) lookup performance.
+    class Base
+      attr_reader :size, :logger
+      
+      def initialize(size)
+        @size = size
+        @logger = SmartMessage::Logger.default
+        validate_size!
+      end
+      
+      # Check if a UUID exists in the queue
+      # @param uuid [String] The UUID to check
+      # @return [Boolean] true if UUID exists, false otherwise
+      def contains?(uuid)
+        raise NotImplementedError, "Subclasses must implement #contains?"
+      end
+      
+      # Add a UUID to the queue (removes oldest if full)
+      # @param uuid [String] The UUID to add
+      # @return [void]
+      def add(uuid)
+        raise NotImplementedError, "Subclasses must implement #add"
+      end
+      
+      # Get current queue statistics
+      # @return [Hash] Statistics about the queue
+      def stats
+        {
+          size: @size,
+          storage_type: storage_type,
+          implementation: self.class.name
+        }
+      end
+      
+      # Clear all entries from the queue
+      # @return [void]
+      def clear
+        raise NotImplementedError, "Subclasses must implement #clear"
+      end
+      
+      # Get the storage type identifier
+      # @return [Symbol] Storage type (:memory, :redis, etc.)
+      def storage_type
+        raise NotImplementedError, "Subclasses must implement #storage_type"
+      end
+      
+      private
+      
+      def validate_size!
+        unless @size.is_a?(Integer) && @size > 0
+          raise ArgumentError, "DDQ size must be a positive integer, got: #{@size.inspect}"
+        end
+      end
+      
+      def validate_uuid!(uuid)
+        unless uuid.is_a?(String) && !uuid.empty?
+          raise ArgumentError, "UUID must be a non-empty string, got: #{uuid.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/smart_message/ddq/memory.rb

@@ -0,0 +1,109 @@
+# lib/smart_message/ddq/memory.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'base'
+
+module SmartMessage
+  module DDQ
+    # Memory-based Deduplication Queue implementation
+    # 
+    # Uses a hybrid approach with Array for circular queue behavior 
+    # and Set for O(1) lookup performance. Thread-safe with Mutex protection.
+    class Memory < Base
+      def initialize(size)
+        super(size)
+        @circular_array = Array.new(@size)
+        @lookup_set = Set.new
+        @index = 0
+        @mutex = Mutex.new
+        @count = 0
+        
+        logger.debug { "[SmartMessage::DDQ::Memory] Initialized with size: #{@size}" }
+      end
+      
+      # Check if a UUID exists in the queue (O(1) operation)
+      # @param uuid [String] The UUID to check
+      # @return [Boolean] true if UUID exists, false otherwise
+      def contains?(uuid)
+        validate_uuid!(uuid)
+        
+        @mutex.synchronize do
+          @lookup_set.include?(uuid)
+        end
+      end
+      
+      # Add a UUID to the queue, removing oldest if full (O(1) operation)
+      # @param uuid [String] The UUID to add
+      # @return [void]
+      def add(uuid)
+        validate_uuid!(uuid)
+        
+        @mutex.synchronize do
+          # Don't add if already exists
+          return if @lookup_set.include?(uuid)
+          
+          # Remove old entry if slot is occupied
+          old_uuid = @circular_array[@index]
+          if old_uuid
+            @lookup_set.delete(old_uuid)
+            logger.debug { "[SmartMessage::DDQ::Memory] Evicted UUID: #{old_uuid}" }
+          end
+          
+          # Add new entry
+          @circular_array[@index] = uuid
+          @lookup_set.add(uuid)
+          @index = (@index + 1) % @size
+          @count = [@count + 1, @size].min
+          
+          logger.debug { "[SmartMessage::DDQ::Memory] Added UUID: #{uuid}, count: #{@count}" }
+        end
+      end
+      
+      # Get current queue statistics
+      # @return [Hash] Statistics about the queue
+      def stats
+        @mutex.synchronize do
+          super.merge(
+            current_count: @count,
+            utilization: (@count.to_f / @size * 100).round(2),
+            next_index: @index
+          )
+        end
+      end
+      
+      # Clear all entries from the queue
+      # @return [void]
+      def clear
+        @mutex.synchronize do
+          @circular_array = Array.new(@size)
+          @lookup_set.clear
+          @index = 0
+          @count = 0
+          
+          logger.debug { "[SmartMessage::DDQ::Memory] Cleared all entries" }
+        end
+      end
+      
+      # Get the storage type identifier
+      # @return [Symbol] Storage type
+      def storage_type
+        :memory
+      end
+      
+      # Get current entries (for debugging/testing)
+      # @return [Array<String>] Current UUIDs in insertion order
+      def entries
+        @mutex.synchronize do
+          result = []
+          @count.times do |i|
+            idx = (@index - @count + i) % @size
+            result << @circular_array[idx] if @circular_array[idx]
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/smart_message/ddq/redis.rb

@@ -0,0 +1,168 @@
+# lib/smart_message/ddq/redis.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module SmartMessage
+  module DDQ
+    # Redis-based Deduplication Queue implementation
+    # 
+    # Uses Redis SET for O(1) lookup and LIST for circular queue behavior.
+    # Supports distributed deduplication across multiple processes/servers.
+    class Redis < Base
+      attr_reader :redis, :key_prefix, :ttl
+      
+      def initialize(size, options = {})
+        super(size)
+        @redis = options[:redis] || default_redis_connection
+        @key_prefix = options[:key_prefix] || 'smart_message:ddq'
+        @ttl = options[:ttl] || 3600  # 1 hour default TTL
+        
+        validate_redis_connection!
+        
+        logger.debug { "[SmartMessage::DDQ::Redis] Initialized with size: #{@size}, TTL: #{@ttl}s" }
+      end
+      
+      # Check if a UUID exists in the queue (O(1) operation)
+      # @param uuid [String] The UUID to check
+      # @return [Boolean] true if UUID exists, false otherwise
+      def contains?(uuid)
+        validate_uuid!(uuid)
+        
+        result = @redis.sismember(set_key, uuid)
+        logger.debug { "[SmartMessage::DDQ::Redis] UUID #{uuid} exists: #{result}" }
+        result
+      rescue ::Redis::BaseError => e
+        logger.error { "[SmartMessage::DDQ::Redis] Error checking UUID #{uuid}: #{e.message}" }
+        # Fail open - allow processing if Redis is down
+        false
+      end
+      
+      # Add a UUID to the queue, removing oldest if full (O(1) amortized)
+      # @param uuid [String] The UUID to add
+      # @return [void]
+      def add(uuid)
+        validate_uuid!(uuid)
+        
+        # Check if UUID already exists first (avoid unnecessary work)
+        return if @redis.sismember(set_key, uuid)
+        
+        # Use Redis transaction for atomicity
+        @redis.multi do |pipeline|
+          # Add to set for O(1) lookup
+          pipeline.sadd(set_key, uuid)
+          
+          # Add to list for ordering/eviction
+          pipeline.lpush(list_key, uuid)
+          
+          # Trim list to maintain size (removes oldest)
+          pipeline.ltrim(list_key, 0, @size - 1)
+          
+          # Set TTL on both keys
+          pipeline.expire(set_key, @ttl)
+          pipeline.expire(list_key, @ttl)
+        end
+        
+        # Get and remove evicted items from set (outside transaction)
+        list_length = @redis.llen(list_key)
+        if list_length > @size
+          evicted_uuids = @redis.lrange(list_key, @size, -1)
+          evicted_uuids.each do |evicted_uuid|
+            @redis.srem(set_key, evicted_uuid)
+          end
+        end
+        
+        logger.debug { "[SmartMessage::DDQ::Redis] Added UUID: #{uuid}" }
+      rescue ::Redis::BaseError => e
+        logger.error { "[SmartMessage::DDQ::Redis] Error adding UUID #{uuid}: #{e.message}" }
+        # Don't raise - deduplication failure shouldn't break message processing
+      end
+      
+      # Get current queue statistics
+      # @return [Hash] Statistics about the queue
+      def stats
+        set_size = @redis.scard(set_key)
+        list_size = @redis.llen(list_key)
+        
+        super.merge(
+          current_count: set_size,
+          list_count: list_size,
+          utilization: (set_size.to_f / @size * 100).round(2),
+          ttl_remaining: @redis.ttl(set_key),
+          redis_info: {
+            host: redis_host,
+            port: redis_port,
+            db: redis_db
+          }
+        )
+      rescue ::Redis::BaseError => e
+        logger.error { "[SmartMessage::DDQ::Redis] Error getting stats: #{e.message}" }
+        super.merge(error: e.message)
+      end
+      
+      # Clear all entries from the queue
+      # @return [void]
+      def clear
+        @redis.multi do |pipeline|
+          pipeline.del(set_key)
+          pipeline.del(list_key)
+        end
+        
+        logger.debug { "[SmartMessage::DDQ::Redis] Cleared all entries" }
+      rescue ::Redis::BaseError => e
+        logger.error { "[SmartMessage::DDQ::Redis] Error clearing queue: #{e.message}" }
+      end
+      
+      # Get the storage type identifier
+      # @return [Symbol] Storage type
+      def storage_type
+        :redis
+      end
+      
+      # Get current entries (for debugging/testing)
+      # @return [Array<String>] Current UUIDs in insertion order (newest first)
+      def entries
+        @redis.lrange(list_key, 0, -1)
+      rescue ::Redis::BaseError => e
+        logger.error { "[SmartMessage::DDQ::Redis] Error getting entries: #{e.message}" }
+        []
+      end
+      
+      private
+      
+      def set_key
+        "#{@key_prefix}:set"
+      end
+      
+      def list_key
+        "#{@key_prefix}:list"
+      end
+      
+      def default_redis_connection
+        require 'redis'
+        ::Redis.new
+      rescue LoadError
+        raise LoadError, "Redis gem not available. Install with: gem install redis"
+      end
+      
+      def validate_redis_connection!
+        @redis.ping
+      rescue ::Redis::BaseError => e
+        raise ConnectionError, "Failed to connect to Redis: #{e.message}"
+      end
+      
+      def redis_host
+        @redis.connection[:host] rescue 'unknown'
+      end
+      
+      def redis_port
+        @redis.connection[:port] rescue 'unknown'
+      end
+      
+      def redis_db
+        @redis.connection[:db] rescue 'unknown'
+      end
+    end
+  end
+end

data/lib/smart_message/ddq.rb

@@ -0,0 +1,31 @@
+# lib/smart_message/ddq.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'ddq/base'
+require_relative 'ddq/memory'
+require_relative 'ddq/redis'
+
+module SmartMessage
+  # Deduplication Queue (DDQ) for preventing duplicate message processing
+  # 
+  # Provides a circular queue with O(1) lookup performance for detecting
+  # duplicate messages based on UUID. Supports both memory and Redis storage.
+  module DDQ
+    # Default configuration
+    DEFAULT_SIZE = 100
+    DEFAULT_STORAGE = :memory
+    
+    # Create a DDQ instance based on storage type
+    def self.create(storage_type, size = DEFAULT_SIZE, options = {})
+      case storage_type.to_sym
+      when :memory
+        Memory.new(size)
+      when :redis
+        Redis.new(size, options)
+      else
+        raise ArgumentError, "Unknown DDQ storage type: #{storage_type}. Supported types: :memory, :redis"
+      end
+    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