smart_message 0.0.13 → 0.0.16

data/lib/smart_message/plugins.rb

@@ -30,9 +30,14 @@ module SmartMessage
     def transport(klass_or_instance = nil)
       if klass_or_instance.nil?
         # Return instance transport, class transport, or global configuration
-        @transport || self.class.class_variable_get(:@@transport) || SmartMessage::Transport.default
+        # For backward compatibility, return first transport if array, otherwise single transport
+        transport_value = @transport || self.class.class_variable_get(:@@transport) || SmartMessage::Transport.default
+        transport_value.is_a?(Array) ? transport_value.first : transport_value
       else
-        @transport = klass_or_instance
+        # Normalize to array for internal consistent handling
+        @transport = Array(klass_or_instance)
+        # Return the original value for backward compatibility with method chaining
+        klass_or_instance
       end
     end
 
@@ -44,6 +49,22 @@ module SmartMessage
     end
     def reset_transport;        @transport = nil;  end
 
+    # Utility methods for working with transport collections
+    def transports
+      # Get the raw transport value (which is internally stored as array)
+      raw_transport = @transport || self.class.class_variable_get(:@@transport) || SmartMessage::Transport.default
+      # Always return as array for consistent handling
+      raw_transport.is_a?(Array) ? raw_transport : Array(raw_transport)
+    end
+
+    def single_transport?
+      transports.length == 1
+    end
+
+    def multiple_transports?
+      transports.length > 1
+    end
+
     module ClassMethods
       #########################################################
       ## class-level configuration
@@ -58,9 +79,14 @@ module SmartMessage
       def transport(klass_or_instance = nil)
         if klass_or_instance.nil?
           # Return class-level transport or fall back to global configuration
-          class_variable_get(:@@transport) || SmartMessage::Transport.default
+          # For backward compatibility, return first transport if array, otherwise single transport
+          transport_value = class_variable_get(:@@transport) || SmartMessage::Transport.default
+          transport_value.is_a?(Array) ? transport_value.first : transport_value
         else
-          class_variable_set(:@@transport, klass_or_instance)
+          # Normalize to array for internal consistent handling
+          class_variable_set(:@@transport, Array(klass_or_instance))
+          # Return the original value for backward compatibility with method chaining
+          klass_or_instance
         end
       end
 
@@ -71,6 +97,22 @@ module SmartMessage
       end
       def reset_transport;       class_variable_set(:@@transport, nil);  end
 
+      # Utility methods for working with transport collections  
+      def transports
+        # Get the raw transport value (which is internally stored as array)
+        raw_transport = class_variable_get(:@@transport) || SmartMessage::Transport.default
+        # Always return as array for consistent handling
+        raw_transport.is_a?(Array) ? raw_transport : Array(raw_transport)
+      end
+
+      def single_transport?
+        transports.length == 1
+      end
+
+      def multiple_transports?
+        transports.length > 1
+      end
+
       #########################################################
       ## class-level logger configuration
 

data/lib/smart_message/serializer/base.rb

@@ -58,7 +58,7 @@ module SmartMessage::Serializer
 
     # Template methods for actual serialization (implement in subclasses)
     def do_encode(message_instance)
-      # Default implementation: serialize only the payload portion for wrapper architecture
+      # Default implementation: serialize only the payload portion for message architecture
       # Subclasses can override this for specific serialization formats
       message_hash = message_instance.to_h
       payload_portion = message_hash[:_sm_payload]

data/lib/smart_message/serializer.rb

@@ -6,8 +6,9 @@ module SmartMessage
   module Serializer
     class << self
       def default
-        # Check global configuration first, then fall back to framework default
-        SmartMessage.configuration.default_serializer
+        # Return the framework's default serializer class
+        # Note: Serialization is handled by transports, not messages
+        SmartMessage::Serializer::Json
       end
     end
   end

data/lib/smart_message/subscription.rb

@@ -32,12 +32,11 @@ module SmartMessage
 
       # Call a registered proc handler
       # @param handler_id [String] The handler identifier
-      # @param wrapper [SmartMessage::Wrapper::Base] The message wrapper
-      def call_proc_handler(handler_id, wrapper)
+      def call_proc_handler(handler_id, message)
         handler_proc = class_variable_get(:@@proc_handlers)[handler_id]
         return unless handler_proc
 
-        handler_proc.call(wrapper)
+        handler_proc.call(message)
       end
 
       # Remove a proc handler from the registry
@@ -61,8 +60,8 @@ module SmartMessage
       # an exception.
       #
       # @param process_method [String, Proc, nil] The processing method:
-      #   - String: Method name like "MyService.handle_message" 
-      #   - Proc: A proc/lambda that accepts (message_header, message_payload)
+      #   - String: Method name like "MyService.handle_message"
+      #   - Proc: A proc/lambda that accepts (message)
       #   - nil: Uses default "MessageClass.process" method
       # @param broadcast [Boolean, nil] Filter for broadcast messages (to: nil)
       # @param to [String, Array, nil] Filter for messages directed to specific entities
@@ -70,26 +69,25 @@ module SmartMessage
       # @param block [Proc] Alternative way to pass a processing block
       # @return [String] The identifier used for this subscription
       #
-      # @example Using default handler 
+      # @example Using default handler
       #   MyMessage.subscribe
       #
       # @example Using custom method name with filtering
       #   MyMessage.subscribe("MyService.handle_message", from: ['order-service'])
       #
       # @example Using a block with broadcast filtering
-      #   MyMessage.subscribe(broadcast: true) do |header, payload|
-      #     data = JSON.parse(payload)
-      #     puts "Received broadcast: #{data}"
+      #   MyMessage.subscribe(broadcast: true) do |message|
+      #     puts "Received broadcast: #{message.content}"
       #   end
       #
       # @example Entity-specific filtering (receives only messages from payment service)
       #   MyMessage.subscribe("OrderService.process", from: ['payment'])
       #
-      # @example Explicit to filter 
+      # @example Explicit to filter
       #   MyMessage.subscribe("AdminService.handle", to: 'admin', broadcast: false)
       def subscribe(process_method = nil, broadcast: nil, to: nil, from: nil, &block)
         message_class = whoami
-        
+
         # Handle different parameter types
         if block_given?
           # Block was passed - use it as the handler
@@ -107,11 +105,11 @@ module SmartMessage
 
         # Subscriber identity is derived from the process method (handler)
         # This ensures each handler gets its own DDQ scope per message class
-        
+
         # Normalize string filters to arrays
         to_filter = normalize_filter_value(to)
         from_filter = normalize_filter_value(from)
-        
+
         # Create filter options (no explicit subscriber identity needed)
         filter_options = {
           broadcast: broadcast,
@@ -121,16 +119,16 @@ module SmartMessage
 
         # Add proper logging
         logger = SmartMessage::Logger.default
-        
+
         begin
           raise Errors::TransportNotConfigured if transport_missing?
           transport.subscribe(message_class, process_method, filter_options)
-          
+
           # Log successful subscription
           handler_desc = block_given? || process_method.respond_to?(:call) ? " with block/proc handler" : ""
           logger.info { "[SmartMessage] Subscribed: #{self.name}#{handler_desc}" }
           logger.debug { "[SmartMessage::Subscription] Subscribed #{message_class} with filters: #{filter_options}" }
-          
+
           process_method
         rescue => e
           logger.error { "[SmartMessage] Error in message subscription: #{e.class.name} - #{e.message}" }
@@ -148,16 +146,16 @@ module SmartMessage
         process_method  = message_class + '.process' if process_method.nil?
         # Add proper logging
         logger = SmartMessage::Logger.default
-        
+
         begin
           if transport_configured?
             transport.unsubscribe(message_class, process_method)
-            
+
             # If this was a proc handler, clean it up from the registry
             if proc_handler?(process_method)
               unregister_proc_handler(process_method)
             end
-            
+
             # Log successful unsubscription
             logger.info { "[SmartMessage] Unsubscribed: #{self.name}" }
             logger.debug { "[SmartMessage::Subscription] Unsubscribed #{message_class} from #{process_method}" }
@@ -193,4 +191,4 @@ module SmartMessage
       end
     end
   end
-end
+end

data/lib/smart_message/transport/async_publish_queue.rb

@@ -0,0 +1,284 @@
+# lib/smart_message/transport/async_publish_queue.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'timeout'
+
+module SmartMessage
+  module Transport
+    # Module for asynchronous publishing queue.
+    module AsyncPublishQueue
+      
+      private
+      
+      def logger
+        # Ensure we have a proper logger, not just an IO object
+        if @logger && @logger.respond_to?(:error) && @logger.respond_to?(:info) && @logger.respond_to?(:warn)
+          return @logger
+        end
+        @logger = SmartMessage::Logger.default
+      end
+      
+      public
+      def configure_async_publishing
+        return unless @options[:async]
+        
+        # Ensure file configuration is set up first
+        configure_file_output if respond_to?(:configure_file_output)
+        
+        @publish_queue = @options[:max_queue] ? SizedQueue.new(@options[:max_queue]) : Queue.new
+        @queue_stats = { queued: 0, processed: 0, failed: 0, dropped: 0, blocked_count: 0, max_queue_size_reached: 0 }
+        @last_warning_time = nil
+        
+        start_publish_worker
+        start_queue_monitoring if @options[:enable_queue_monitoring]
+      end
+
+      def async_publish(message_class, serialized_message)
+        check_queue_warning
+        
+        if queue_full?
+          handle_queue_overflow(message_class, serialized_message)
+          return false
+        end
+        
+        @publish_queue << { 
+          message_class: message_class, 
+          serialized_message: serialized_message, 
+          timestamp: Time.now, 
+          retry_count: 0 
+        }
+        @queue_stats[:queued] += 1
+        true
+      rescue => e
+        begin
+          logger.error { "[FileTransport] Error queuing message: #{e.message}" }
+        rescue
+          # Fallback if logger is not available
+        end
+        false
+      end
+
+      def queue_full?
+        @publish_queue.is_a?(SizedQueue) && @publish_queue.size >= @options[:max_queue]
+      end
+
+      def queue_usage_percentage
+        return 0 unless @publish_queue.is_a?(SizedQueue)
+        (@publish_queue.size.to_f / @options[:max_queue] * 100).round(1)
+      end
+
+      def publish_stats
+        return {} unless @options[:async]
+        @queue_stats.merge(
+          current_size: @publish_queue.size,
+          worker_alive: @publish_worker_thread&.alive? || false
+        )
+      end
+
+      private
+
+      def start_publish_worker
+        @publish_worker_thread = Thread.new do
+          Thread.current.name = "FileTransport-Publisher"
+          
+          loop do
+            begin
+              message_data = Timeout.timeout(@options[:worker_timeout] || 5) { @publish_queue.pop }
+              process_queued_message(message_data)
+            rescue Timeout::Error
+              next
+            rescue => e
+              begin
+                logger.error { "[FileTransport] Publish worker error: #{e.message}" }
+              rescue
+                # Fallback if logger is not available
+              end
+              sleep 1
+            end
+          end
+        end
+      end
+
+      def process_queued_message(message_data)
+        success = do_sync_publish(message_data[:message_class], message_data[:serialized_message])
+        if success
+          @queue_stats[:processed] += 1
+        else
+          handle_publish_failure(message_data)
+        end
+      end
+
+      def do_sync_publish(message_class, serialized_message)
+        begin
+          if @options[:file_type] == :fifo
+            write_to_fifo(serialized_message)
+          else
+            write_to_file(serialized_message)
+          end
+          true
+        rescue => e
+          begin
+            logger.error { "[FileTransport] Sync write error: #{e.message}" }
+          rescue
+            # Fallback if logger is not available
+          end
+          false
+        end
+      end
+
+      def handle_publish_failure(message_data)
+        retry_count = message_data[:retry_count] + 1
+        max_retries = @options[:max_retries] || 3
+        
+        if retry_count <= max_retries
+          sleep_time = [2 ** retry_count, @options[:max_retry_delay] || 30].min
+          Thread.new do
+            sleep sleep_time
+            message_data[:retry_count] = retry_count
+            @publish_queue << message_data
+          end
+          logger.warn { "[FileTransport] Retrying message publish (attempt #{retry_count}/#{max_retries})" }
+        else
+          @queue_stats[:failed] += 1
+          send_to_dead_letter_queue(message_data) if defined?(SmartMessage::DeadLetterQueue)
+        end
+      end
+
+      def handle_queue_overflow(message_class, serialized_message)
+        case @options[:queue_overflow_strategy]
+        when :drop_newest
+          @queue_stats[:dropped] += 1
+          logger.warn { "[FileTransport] Dropping newest message - queue full (#{@publish_queue.size}/#{@options[:max_queue]})" }
+        when :drop_oldest
+          begin
+            dropped_message = @publish_queue.pop(true)
+            @publish_queue << {
+              message_class: message_class,
+              serialized_message: serialized_message,
+              timestamp: Time.now,
+              retry_count: 0
+            }
+            @queue_stats[:dropped] += 1
+            logger.warn { "[FileTransport] Dropped oldest message to make room for new message" }
+            send_to_dead_letter_queue(dropped_message) if @options[:send_dropped_to_dlq]
+          rescue ThreadError
+            @queue_stats[:dropped] += 1
+            logger.error { "[FileTransport] Queue overflow but queue appears empty - dropping message" }
+          end
+        when :block
+          @queue_stats[:blocked_count] += 1
+          start_time = Time.now
+          logger.warn { "[FileTransport] Queue full (#{@publish_queue.size}/#{@options[:max_queue]}) - blocking until space available" }
+          
+          @publish_queue << {
+            message_class: message_class,
+            serialized_message: serialized_message,
+            timestamp: Time.now,
+            retry_count: 0
+          }
+          logger.info { "[FileTransport] Queue space available after #{(Time.now - start_time).round(2)}s - message queued" }
+          @queue_stats[:queued] += 1
+          return true
+        else
+          @queue_stats[:dropped] += 1
+          logger.error { "[FileTransport] Unknown overflow strategy '#{@options[:queue_overflow_strategy]}', dropping message" }
+        end
+        false
+      end
+
+      def send_to_dead_letter_queue(message_data)
+        SmartMessage::DeadLetterQueue.default.enqueue(
+          message_data[:message_class],
+          message_data[:serialized_message],
+          error: "Failed async publish after #{@options[:max_retries]} retries",
+          transport: self.class.name,
+          retry_count: message_data[:retry_count]
+        )
+      rescue => e
+        begin
+          logger.error { "[FileTransport] Failed to send to DLQ: #{e.message}" }
+        rescue
+          # Fallback if logger is not available
+        end
+      end
+
+      def check_queue_warning
+        return unless @options[:queue_warning_threshold]
+        return if @options[:max_queue] == 0
+        
+        usage = queue_usage_percentage
+        threshold = @options[:queue_warning_threshold] * 100
+        
+        if usage >= threshold
+          now = Time.now
+          if @last_warning_time.nil? || (now - @last_warning_time) > 60
+            logger.warn { "[FileTransport] Publish queue is #{usage}% full (#{@publish_queue.size}/#{@options[:max_queue]})" }
+            @last_warning_time = now
+          end
+        end
+      end
+
+      def start_queue_monitoring
+        @queue_monitoring_thread = Thread.new do
+          Thread.current.name = "FileTransport-QueueMonitor"
+          
+          loop do
+            sleep 30
+            
+            begin
+              stats = publish_stats
+              usage = queue_usage_percentage
+              
+              logger.info do
+                "[FileTransport] Queue stats: #{stats[:current_size]} messages " \
+                "(#{usage}% full), processed: #{stats[:processed]}, " \
+                "failed: #{stats[:failed]}, worker: #{stats[:worker_alive] ? 'alive' : 'dead'}"
+              end
+            rescue => e
+              logger.error { "[FileTransport] Queue monitoring error: #{e.message}" }
+            end
+          end
+        end
+      end
+
+      def stop_async_publishing
+        return unless @publish_worker_thread
+        
+        @publish_worker_thread.kill
+        @publish_worker_thread.join(@options[:shutdown_timeout] || 10)
+        
+        if @options[:drain_queue_on_shutdown]
+          drain_publish_queue
+        end
+        
+        @publish_worker_thread = nil
+        @queue_monitoring_thread&.kill
+        @queue_monitoring_thread&.join(5)
+      end
+
+      def drain_publish_queue
+        begin
+          logger.info { "[FileTransport] Draining #{@publish_queue.size} queued messages" }
+        rescue
+          # Fallback if logger is not available
+        end
+        
+        until @publish_queue.empty?
+          begin
+            message_data = @publish_queue.pop(true)
+            process_queued_message(message_data)
+          rescue ThreadError
+            break
+          end
+        end
+        
+        begin
+          logger.info { "[FileTransport] Queue drained" }
+        rescue
+          # Fallback if logger is not available
+        end
+      end
+    end
+  end
+end