smart_message 0.0.12 → 0.0.16

data/lib/smart_message/base.rb

@@ -37,11 +37,9 @@ module SmartMessage
     include Hashie::Extensions::MethodAccess
 
     # Common attrubutes for all messages
-    # TODO: Need to change the SmartMessage::Header into a
-    #       smartMessage::Wrapper concept where the message
-    #       content is serialized into an element in the wrapper
-    #       where the wrapper contains header/routing information
-    #       in addition to the serialized message data.
+    # TODO: This comment is now obsolete - the flat message structure 
+    #       has been implemented where header and message properties
+    #       exist at the same level in a flat structure.
     property :_sm_header
 
     # Constructor for a messsage definition that allows the
@@ -50,7 +48,6 @@ module SmartMessage
       # instance-level override of class plugins  
       # Don't use fallback defaults here - let the methods handle fallbacks when actually used
       @transport   = (self.class.class_variable_get(:@@transport) rescue nil)
-      @serializer  = (self.class.class_variable_get(:@@serializer) rescue nil)
 
       # Check if we're reconstructing from serialized data (complete header provided)
       if props[:_sm_header]
@@ -71,8 +68,8 @@ module SmartMessage
         @to = header.to
         @reply_to = header.reply_to
         
-        # Extract payload properties
-        payload_props = props[:_sm_payload] || {}
+        # Extract payload properties directly from props (flat structure)
+        payload_props = props.except(:_sm_header)
         
         attributes = {
           _sm_header: header
@@ -132,14 +129,14 @@ module SmartMessage
       # Extract payload properties (non-header properties)
       payload_props = self.class.properties.each_with_object({}) do |prop, hash|
         next if prop == :_sm_header
-        hash[prop.to_s] = self[prop]  # Use string keys to match old format
+        hash[prop.to_s] = self[prop]  # Access property value
       end
       
       JSON.generate(payload_props)
     end
 
-    # Backward compatibility method for handlers that expect wrapper.split
-    # Returns [header, payload_json] in the old wrapper format
+    # Backward compatibility method for handlers that expect message.split
+    # Returns [header, payload_json] in the old two-tier format
     def split
       [_sm_header, _sm_payload]
     end
@@ -154,29 +151,39 @@ module SmartMessage
 
 
 
+    # Convert message to hash for serialization
+    def to_hash
+      # Get all properties and their values
+      hash = {}
+      self.class.properties.each do |prop|
+        hash[prop] = self[prop]
+      end
+      hash
+    end
+
     ###########################################################
     ## class methods
 
     class << self
       # Decode a complete serialized message back to a message instance
+      # Note: This method is no longer used with transport-based serialization
+      # Transports handle decoding and create message instances directly
       # @param serialized_message [String] The serialized message content
       # @return [SmartMessage::Base] The decoded message instance
       def decode(serialized_message)
         begin
           (self.logger || SmartMessage::Logger.default).info { "[SmartMessage] Received: #{self.name} (#{serialized_message.bytesize} bytes)" }
 
-          # Use the class's configured serializer to decode the message
-          serializer = self.serializer || SmartMessage::Serializer.default
-          
-          # Deserialize the complete message
-          deserialized_data = serializer.decode(serialized_message)
+          # This method is deprecated - transports now handle serialization
+          # For backward compatibility, try to decode as JSON
+          require 'json'
+          deserialized_data = JSON.parse(serialized_message)
 
           # Create new message instance with the complete deserialized data
           if deserialized_data.is_a?(Hash)
             # Convert string keys to symbols for compatibility with keyword arguments
             symbol_props = deserialized_data.transform_keys(&:to_sym)
             
-            # With single-tier serialization, use the complete deserialized message structure
             message = self.new(**symbol_props)
 
             (self.logger || SmartMessage::Logger.default).debug { "[SmartMessage] Deserialized message: #{self.name}" }

data/lib/smart_message/configuration.rb

@@ -53,7 +53,6 @@ module SmartMessage
   #   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:
@@ -71,17 +70,16 @@ module SmartMessage
   #   class SpecialMessage < SmartMessage::Base
   #     config do
   #       logger MyApp::SpecialLogger.new  # Override just the logger
-  #       # transport and serializer still use global defaults
+  #       # transport still uses 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_accessor :transport, :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
@@ -101,7 +99,6 @@ module SmartMessage
     def reset!
       @logger = nil
       @transport = nil
-      @serializer = nil
       @logger_explicitly_set_to_nil = false
       @log_level = nil
       @log_format = nil
@@ -121,11 +118,6 @@ module SmartMessage
       !@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
@@ -156,11 +148,6 @@ module SmartMessage
       @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)
@@ -187,13 +174,5 @@ module SmartMessage
     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
-      # Fallback if JSON serializer is not available
-      nil
-    end
   end
 end

data/lib/smart_message/dead_letter_queue.rb

@@ -48,7 +48,7 @@ module SmartMessage
     # @param error_info [Hash] Error details including :error, :retry_count, :transport, etc.
     def enqueue(message, error_info = {})
       message_header = message._sm_header
-      message_payload = message.encode
+      message_payload = JSON.generate(message.to_hash)
 
       entry = {
         timestamp: Time.now.iso8601,

data/lib/smart_message/errors.rb

@@ -28,5 +28,8 @@ module SmartMessage
     # A property validation failed
     class ValidationError < RuntimeError; end
 
+    # Publishing failed on all configured transports
+    class PublishError < RuntimeError; end
+
   end
 end

data/lib/smart_message/header.rb

@@ -58,7 +58,7 @@ module SmartMessage
       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
+    # Serialization tracking for message 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"

data/lib/smart_message/logger/default.rb

@@ -10,7 +10,7 @@ module SmartMessage
   module Logger
     # Default logger implementation for SmartMessage
     #
-    # This logger provides a simple Ruby Logger wrapper with enhanced formatting.
+    # This logger provides a simple Ruby Logger message with enhanced formatting.
     # Applications can easily configure Rails.logger or other loggers through
     # the global configuration system instead.
     #

data/lib/smart_message/messaging.rb

@@ -4,34 +4,8 @@
 
 module SmartMessage
   # Messaging module for SmartMessage::Base
-  # Handles message encoding and publishing operations
+  # Handles message publishing operations
   module Messaging
-    # SMELL: How does the transport know how to decode a message before
-    #        it knows the message class?  We need a wrapper around
-    #        the entire message in a known serialization.  That
-    #        wrapper would contain two properties: _sm_header and
-    #        _sm_payload
-
-    # NOTE: to publish a message it must first be encoded using a
-    #       serializer.  The receive a subscribed to message it must
-    #       be decoded via a serializer from the transport to be processed.
-    def encode
-      raise Errors::SerializerNotConfigured if serializer_missing?
-
-      serializer.encode(self)
-    end
-
-    # Convert message to hash with _sm_header and _sm_payload structure
-    # This is the foundation for wrapper architecture
-    def to_h
-      # Update header with serializer info before converting
-      _sm_header.serializer = serializer.class.to_s if serializer_configured?
-      
-      {
-        :_sm_header => header_hash_with_symbols,
-        :_sm_payload => payload_hash_with_symbols
-      }
-    end
 
 
     # NOTE: you publish instances; but, you subscribe/unsubscribe at
@@ -44,20 +18,46 @@ module SmartMessage
         # Update header with current publication info
         _sm_header.published_at   = Time.now
         _sm_header.publisher_pid  = Process.pid
-        _sm_header.serializer     = serializer.class.to_s if serializer_configured?
-
-        # Single-tier serialization: serialize entire message with designated serializer
-        serialized_message = encode
         
         raise Errors::TransportNotConfigured if transport_missing?
         
-        # Transport receives the message class name (for channel routing) and serialized message
-        (self.class.logger || SmartMessage::Logger.default).debug { "[SmartMessage::Messaging] About to call transport.publish" }
-        transport.publish(_sm_header.message_class, serialized_message)
-        (self.class.logger || SmartMessage::Logger.default).debug { "[SmartMessage::Messaging] transport.publish completed" }
+        # Get all configured transports (supports both single and multiple)
+        transport_list = transports
+        logger = self.class.logger || SmartMessage::Logger.default
+        
+        # Track publication results for each transport
+        successful_transports = []
+        failed_transports = []
+        
+        # Publish to each configured transport
+        transport_list.each do |transport_instance|
+          begin
+            # Transport handles serialization - just pass the message instance
+            logger.debug { "[SmartMessage::Messaging] About to call transport.publish on #{transport_instance.class.name.split('::').last}" }
+            transport_instance.publish(self)
+            logger.debug { "[SmartMessage::Messaging] transport.publish completed on #{transport_instance.class.name.split('::').last}" }
+            
+            successful_transports << transport_instance.class.name.split('::').last
+          rescue => transport_error
+            logger.error { "[SmartMessage] Transport #{transport_instance.class.name.split('::').last} failed: #{transport_error.class.name} - #{transport_error.message}" }
+            failed_transports << { transport: transport_instance.class.name.split('::').last, error: transport_error }
+          end
+        end
+        
+        # Log overall publication results
+        if successful_transports.any?
+          logger.info { "[SmartMessage] Published: #{self.class.name} via #{successful_transports.join(', ')}" }
+        end
         
-        # Log the message publish
-        (self.class.logger || SmartMessage::Logger.default).info { "[SmartMessage] Published: #{self.class.name} via #{transport.class.name.split('::').last}" }
+        if failed_transports.any?
+          logger.warn { "[SmartMessage] Failed transports for #{self.class.name}: #{failed_transports.map { |ft| ft[:transport] }.join(', ')}" }
+        end
+        
+        # Raise error only if ALL transports failed
+        if successful_transports.empty? && failed_transports.any?
+          error_messages = failed_transports.map { |ft| "#{ft[:transport]}: #{ft[:error].message}" }.join('; ')
+          raise Errors::PublishError, "All transports failed: #{error_messages}"
+        end
 
         SS.add(_sm_header.message_class, 'publish')
         SS.get(_sm_header.message_class, 'publish')
@@ -67,34 +67,5 @@ module SmartMessage
       end
     end # def publish
 
-    private
-
-    # Convert header to hash with symbol keys
-    def header_hash_with_symbols
-      _sm_header.to_hash.transform_keys(&:to_sym)
-    end
-    
-    # Extract all non-header properties into a hash with symbol keys
-    # Performs deep symbolization on nested structures
-    def payload_hash_with_symbols
-      self.class.properties.each_with_object({}) do |prop, hash|
-        next if prop == :_sm_header
-        hash[prop.to_sym] = deep_symbolize_keys(self[prop])
-      end
-    end
-
-    # Recursively convert all string keys to symbols in nested hashes and arrays
-    def deep_symbolize_keys(obj)
-      case obj
-      when Hash
-        obj.each_with_object({}) do |(key, value), result|
-          result[key.to_sym] = deep_symbolize_keys(value)
-        end
-      when Array
-        obj.map { |item| deep_symbolize_keys(item) }
-      else
-        obj
-      end
-    end
   end
 end

data/lib/smart_message/plugins.rb

@@ -4,7 +4,7 @@
 
 module SmartMessage
   # Plugin configuration module for SmartMessage::Base
-  # Handles transport, serializer, and logger configuration at both
+  # Handles transport and logger configuration at both
   # class and instance levels
   module Plugins
     def self.included(base)
@@ -12,7 +12,6 @@ module SmartMessage
       base.class_eval do
         # Class-level plugin storage
         class_variable_set(:@@transport, nil) unless class_variable_defined?(:@@transport)
-        class_variable_set(:@@serializer, nil) unless class_variable_defined?(:@@serializer)
         class_variable_set(:@@logger, nil) unless class_variable_defined?(:@@logger)
       end
     end
@@ -31,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
 
@@ -45,26 +49,21 @@ 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
 
-    #########################################################
-    ## instance-level serializer configuration
-
-    def serializer(klass_or_instance = nil)
-      if klass_or_instance.nil?
-        # Return instance serializer, class serializer, or global configuration
-        @serializer || self.class.class_variable_get(:@@serializer) || SmartMessage::Serializer.default
-      else
-        @serializer = klass_or_instance
-      end
+    def single_transport?
+      transports.length == 1
     end
 
-    def serializer_configured?; !serializer_missing?;   end
-    def serializer_missing?
-      # Check if serializer is explicitly configured (without fallback to defaults)
-      @serializer.nil? && 
-        (self.class.class_variable_get(:@@serializer) rescue nil).nil?
+    def multiple_transports?
+      transports.length > 1
     end
-    def reset_serializer;       @serializer = nil;  end
 
     module ClassMethods
       #########################################################
@@ -80,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
 
@@ -93,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
 
@@ -111,25 +131,6 @@ module SmartMessage
         (class_variable_get(:@@logger) rescue nil).nil?
       end
       def reset_logger;          class_variable_set(:@@logger, nil);  end
-
-      #########################################################
-      ## class-level serializer configuration
-
-      def serializer(klass_or_instance = nil)
-        if klass_or_instance.nil?
-          # Return class-level serializer or fall back to global configuration
-          class_variable_get(:@@serializer) || SmartMessage::Serializer.default
-        else
-          class_variable_set(:@@serializer, klass_or_instance)
-        end
-      end
-
-      def serializer_configured?; !serializer_missing?;   end
-      def serializer_missing?
-        # Check if class-level serializer is explicitly configured (without fallback to defaults)
-        (class_variable_get(:@@serializer) rescue nil).nil?
-      end
-      def reset_serializer;      class_variable_set(:@@serializer, nil);  end
     end
   end
 end

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