smart_message 0.0.8 → 0.0.9

data/lib/smart_message/transport/base.rb

@@ -10,7 +10,7 @@ module SmartMessage
     # This defines the standard interface that all transports must implement
     class Base
       include BreakerMachines::DSL
-      
+
       attr_reader :options, :dispatcher
 
       def initialize(**options)
@@ -18,7 +18,20 @@ module SmartMessage
         @dispatcher = options[:dispatcher] || SmartMessage::Dispatcher.new
         configure
         configure_transport_circuit_breakers
+        
+        logger.debug { "[SmartMessage::Transport::#{self.class.name.split('::').last}] Initialized with options: #{@options}" }
+      rescue => e
+        logger&.error { "[SmartMessage] Error in transport initialization: #{e.class.name} - #{e.message}" }
+        raise
       end
+      
+      private
+      
+      def logger
+        @logger ||= SmartMessage::Logger.default
+      end
+      
+      public
 
       # Transport-specific configuration
       def configure
@@ -31,24 +44,27 @@ module SmartMessage
       end
 
       # Publish a message with circuit breaker protection
-      # @param message_header [SmartMessage::Header] Message routing information
-      # @param message_payload [String] Serialized message content
-      def publish(message_header, message_payload)
+      # @param message_class [String] The message class name (used for channel routing)
+      # @param serialized_message [String] Complete serialized message content
+      def publish(message_class, serialized_message)
         circuit(:transport_publish).wrap do
-          do_publish(message_header, message_payload)
+          do_publish(message_class, serialized_message)
         end
       rescue => e
+        # Log the exception for debugging
+        logger.error { "[SmartMessage] Error in transport publish: #{e.class.name} - #{e.message}" }
+        
         # Re-raise if it's not a circuit breaker fallback
         raise unless e.is_a?(Hash) && e[:circuit_breaker]
-        
+
         # Handle circuit breaker fallback
-        handle_publish_fallback(e, message_header, message_payload)
+        handle_publish_fallback(e, message_class, serialized_message)
       end
 
       # Template method for actual publishing (implement in subclasses)
-      # @param message_header [SmartMessage::Header] Message routing information
-      # @param message_payload [String] Serialized message content
-      def do_publish(message_header, message_payload)
+      # @param message_class [String] The message class name (used for channel routing)
+      # @param serialized_message [String] Complete serialized message content
+      def do_publish(message_class, serialized_message)
         raise NotImplementedError, 'Transport must implement #do_publish'
       end
 
@@ -61,7 +77,7 @@ module SmartMessage
       end
 
       # Unsubscribe from a specific message class and process method
-      # @param message_class [String] The message class name  
+      # @param message_class [String] The message class name
       # @param process_method [String] The processing method identifier
       def unsubscribe(message_class, process_method)
         @dispatcher.drop(message_class, process_method)
@@ -88,7 +104,7 @@ module SmartMessage
         # Override in subclasses if connection setup is needed
       end
 
-      # Disconnect from transport (if applicable) 
+      # Disconnect from transport (if applicable)
       def disconnect
         # Override in subclasses if cleanup is needed
       end
@@ -97,7 +113,7 @@ module SmartMessage
       # @return [Hash] Circuit breaker statistics
       def transport_circuit_stats
         stats = {}
-        
+
         [:transport_publish, :transport_subscribe].each do |circuit_name|
           begin
             if respond_to?(:circuit)
@@ -118,7 +134,7 @@ module SmartMessage
             stats[circuit_name] = { error: "Failed to get stats: #{e.message}" }
           end
         end
-        
+
         stats
       end
 
@@ -135,41 +151,58 @@ module SmartMessage
       end
 
       # Receive and route a message (called by transport implementations)
-      # @param message_header [SmartMessage::Header] Message routing information
-      # @param message_payload [String] Serialized message content
+      # @param message_class [String] The message class name
+      # @param serialized_message [String] The serialized message content
       protected
 
-      def receive(message_header, message_payload)
-        @dispatcher.route(message_header, message_payload)
+      def receive(message_class, serialized_message)
+        # Decode the message using the class's configured serializer
+        
+        # Add defensive check for message_class type
+        unless message_class.respond_to?(:constantize)
+          logger.error { "[SmartMessage] Invalid message_class type: #{message_class.class.name} - #{message_class.inspect}" }
+          logger.error { "[SmartMessage] Expected String, got: #{message_class.class.name}" }
+          raise ArgumentError, "message_class must be a String, got #{message_class.class.name}"
+        end
+        
+        message_class_obj = message_class.constantize
+        decoded_message = message_class_obj.decode(serialized_message)
+        
+        @dispatcher.route(decoded_message)
+      rescue => e
+        logger.error { "[SmartMessage] Error in transport receive: #{e.class.name} - #{e.message}" }
+        logger.error { "[SmartMessage] message_class: #{message_class.inspect} (#{message_class.class.name})" }
+        logger.error { "[SmartMessage] serialized_message length: #{serialized_message&.length}" }
+        raise
       end
 
       # Configure circuit breakers for transport operations
       def configure_transport_circuit_breakers
         # Configure publish circuit breaker
         publish_config = SmartMessage::CircuitBreaker::DEFAULT_CONFIGS[:transport_publish]
-        
+
         self.class.circuit :transport_publish do
-          threshold failures: publish_config[:threshold][:failures], 
+          threshold failures: publish_config[:threshold][:failures],
                    within: publish_config[:threshold][:within].seconds
           reset_after publish_config[:reset_after].seconds
-          
+
           # Use memory storage by default for transport circuits
           storage BreakerMachines::Storage::Memory.new
-          
+
           # Fallback for publish failures - use DLQ fallback
           fallback SmartMessage::CircuitBreaker::Fallbacks.dead_letter_queue
         end
 
         # Configure subscribe circuit breaker
         subscribe_config = SmartMessage::CircuitBreaker::DEFAULT_CONFIGS[:transport_subscribe]
-        
+
         self.class.circuit :transport_subscribe do
-          threshold failures: subscribe_config[:threshold][:failures], 
+          threshold failures: subscribe_config[:threshold][:failures],
                    within: subscribe_config[:threshold][:within].seconds
           reset_after subscribe_config[:reset_after].seconds
-          
+
           storage BreakerMachines::Storage::Memory.new
-          
+
           # Fallback for subscribe failures - log and return error info
           fallback do |exception|
             {
@@ -189,34 +222,32 @@ module SmartMessage
 
       # Handle publish circuit breaker fallback
       # @param fallback_result [Hash] The circuit breaker fallback result
-      # @param message_header [SmartMessage::Header] The message header
-      # @param message_payload [String] The message payload
-      def handle_publish_fallback(fallback_result, message_header, message_payload)
+      # @param message_class [String] The message class name
+      # @param serialized_message [String] The serialized message
+      def handle_publish_fallback(fallback_result, message_class, serialized_message)
         # Log the circuit breaker activation
-        if $DEBUG
-          puts "Transport publish circuit breaker activated: #{self.class.name}"
-          puts "Error: #{fallback_result[:circuit_breaker][:error]}"
-          puts "Message: #{message_header.message_class}"
-          puts "Sent to DLQ: #{fallback_result[:circuit_breaker][:sent_to_dlq]}"
-        end
-        
+        logger.error { "[SmartMessage::Transport] Circuit breaker activated: #{self.class.name}" }
+        logger.error { "[SmartMessage::Transport] Error: #{fallback_result[:circuit_breaker][:error]}" }
+        logger.error { "[SmartMessage::Transport] Message: #{message_class}" }
+        logger.info { "[SmartMessage::Transport] Sent to DLQ: #{fallback_result[:circuit_breaker][:sent_to_dlq]}" }
+
         # If message wasn't sent to DLQ by circuit breaker, send it now
         unless fallback_result.dig(:circuit_breaker, :sent_to_dlq)
           begin
             SmartMessage::DeadLetterQueue.default.enqueue(
-              message_header, 
-              message_payload,
+              message_class,
+              serialized_message,
               error: fallback_result.dig(:circuit_breaker, :error) || 'Circuit breaker activated',
               transport: self.class.name
             )
           rescue => dlq_error
-            puts "Warning: Failed to store message in DLQ: #{dlq_error.message}" if $DEBUG
+            logger.warn { "[SmartMessage] Warning: Failed to store message in DLQ: #{dlq_error.message}" }
           end
         end
-        
+
         # Return the fallback result to indicate failure
         fallback_result
       end
     end
   end
-end
+end

data/lib/smart_message/transport/memory_transport.rb

@@ -22,20 +22,22 @@ module SmartMessage
       end
 
       # Publish message to memory queue
-      def do_publish(message_header, message_payload)
+      def do_publish(message_class, serialized_message)
         @message_mutex.synchronize do
           # Prevent memory overflow
           @messages.shift if @messages.size >= @options[:max_messages]
           
           @messages << {
-            header: message_header,
-            payload: message_payload,
+            message_class: message_class,
+            serialized_message: serialized_message,
             published_at: Time.now
           }
         end
 
         # Auto-process if enabled
-        receive(message_header, message_payload) if @options[:auto_process]
+        if @options[:auto_process]
+          receive(message_class, serialized_message)
+        end
       end
 
       # Get all stored messages
@@ -57,7 +59,7 @@ module SmartMessage
       def process_all
         messages_to_process = @message_mutex.synchronize { @messages.dup }
         messages_to_process.each do |msg|
-          receive(msg[:header], msg[:payload])
+          receive(msg[:message_class], msg[:serialized_message])
         end
       end
 

data/lib/smart_message/transport/redis_transport.rb

@@ -36,20 +36,13 @@ module SmartMessage
       end
 
       # Publish message to Redis channel using message class name
-      def do_publish(message_header, message_payload)
-        channel = message_header.message_class
-        
-        # Combine header and payload for Redis transport
-        # This ensures header information (from, to, reply_to, etc.) is preserved
-        redis_message = {
-          header: message_header.to_hash,
-          payload: message_payload
-        }.to_json
+      def do_publish(message_class, serialized_message)
+        channel = message_class
         
         begin
-          @redis_pub.publish(channel, redis_message)
+          @redis_pub.publish(channel, serialized_message)
         rescue Redis::ConnectionError
-          retry_with_reconnect('publish') { @redis_pub.publish(channel, redis_message) }
+          retry_with_reconnect('publish') { @redis_pub.publish(channel, serialized_message) }
         end
       end
 
@@ -117,7 +110,7 @@ module SmartMessage
             subscribe_to_channels
           rescue => e
             # Log error but don't crash the thread
-            puts "Redis subscriber error: #{e.message}" if @options[:debug]
+            logger.error { "[SmartMessage] Error in redis subscriber: #{e.class.name} - #{e.message}" }
             retry_subscriber
           end
         end
@@ -143,51 +136,28 @@ module SmartMessage
         
         begin
           @redis_sub.subscribe(*@subscribed_channels) do |on|
-            on.message do |channel, redis_message|
+            on.message do |channel, serialized_message|
               begin
-                # Parse the Redis message to extract header and payload
-                parsed_message = JSON.parse(redis_message)
-                
-                if parsed_message.is_a?(Hash) && parsed_message.has_key?('header') && parsed_message.has_key?('payload')
-                  # Reconstruct the original header from the parsed data
-                  header_data = parsed_message['header']
-                  message_header = SmartMessage::Header.new(header_data)
-                  message_payload = parsed_message['payload']
-                else
-                  # Fallback for messages that don't have header/payload structure (legacy support)
-                  message_header = SmartMessage::Header.new(
-                    message_class: channel,
-                    uuid: SecureRandom.uuid,
-                    published_at: Time.now,
-                    publisher_pid: 'redis_subscriber'
-                  )
-                  message_payload = redis_message
-                end
-                
-                receive(message_header, message_payload)
-              rescue JSON::ParserError
-                # Handle malformed JSON - fallback to legacy behavior
-                message_header = SmartMessage::Header.new(
-                  message_class: channel,
-                  uuid: SecureRandom.uuid,
-                  published_at: Time.now,
-                  publisher_pid: 'redis_subscriber'
-                )
-                receive(message_header, redis_message)
+                # Channel name is the message class name
+                # Serialized message contains the complete message
+                receive(channel, serialized_message)
+              rescue => e
+                logger.error { "[SmartMessage] Error in redis message processing: #{e.class.name} - #{e.message}" }
+                # Continue processing other messages
               end
             end
             
             on.subscribe do |channel, subscriptions|
-              puts "Subscribed to Redis channel: #{channel} (#{subscriptions} total)" if @options[:debug]
+              logger.debug { "[SmartMessage::RedisTransport] Subscribed to Redis channel: #{channel} (#{subscriptions} total)" }
             end
             
             on.unsubscribe do |channel, subscriptions|
-              puts "Unsubscribed from Redis channel: #{channel} (#{subscriptions} total)" if @options[:debug]
+              logger.debug { "[SmartMessage::RedisTransport] Unsubscribed from Redis channel: #{channel} (#{subscriptions} total)" }
             end
           end
         rescue => e
           # Silently handle connection errors during subscription
-          puts "Redis subscription error: #{e.class.name}" if @options[:debug]
+          logger.error { "[SmartMessage] Error in redis subscription: #{e.class.name} - #{e.message}" }
           retry_subscriber if @running
         end
       end

data/lib/smart_message/transport/stdout_transport.rb

@@ -27,13 +27,22 @@ module SmartMessage
         @options[:loopback]
       end
 
-      # Publish message to STDOUT
-      def do_publish(message_header, message_payload)
-        @output.puts format_message(message_header, message_payload)
+      # Publish message to STDOUT (single-tier serialization)
+      def do_publish(message_class, serialized_message)
+        logger.debug { "[SmartMessage::StdoutTransport] do_publish called" }
+        logger.debug { "[SmartMessage::StdoutTransport] message_class: #{message_class}" }
+        
+        @output.puts format_message(message_class, serialized_message)
         @output.flush
 
         # If loopback is enabled, route the message back through the dispatcher
-        receive(message_header, message_payload) if loopback?
+        if loopback?
+          logger.debug { "[SmartMessage::StdoutTransport] Loopback enabled, calling receive" }
+          receive(message_class, serialized_message)
+        end
+      rescue => e
+        logger.error { "[SmartMessage] Error in stdout transport do_publish: #{e.class.name} - #{e.message}" }
+        raise
       end
 
       def connected?
@@ -46,17 +55,18 @@ module SmartMessage
 
       private
 
-      def format_message(message_header, message_payload)
+      def format_message(message_class, serialized_message)
         <<~MESSAGE
 
           ===================================================
           == SmartMessage Published via STDOUT Transport
-          == Header: #{message_header.inspect}
-          == Payload: #{message_payload}
+          == Single-Tier Serialization:
+          == Message Class: #{message_class}
+          == Serialized Message: #{serialized_message}
           ===================================================
 
         MESSAGE
       end
     end
   end
-end
+end

data/lib/smart_message/transport.rb

@@ -6,37 +6,4 @@ require_relative 'transport/base'
 require_relative 'transport/registry'
 require_relative 'transport/stdout_transport'
 require_relative 'transport/memory_transport'
-require_relative 'transport/redis_transport'
-
-module SmartMessage
-  # Transport layer abstraction for SmartMessage
-  module Transport
-    class << self
-      # Get the transport registry instance
-      def registry
-        @registry ||= Registry.new
-      end
-
-      # Register a transport adapter
-      def register(name, transport_class)
-        registry.register(name, transport_class)
-      end
-
-      # Get a transport by name
-      def get(name)
-        registry.get(name)
-      end
-
-      # Create a transport instance with options
-      def create(name, **options)
-        transport_class = get(name)
-        transport_class&.new(**options)
-      end
-
-      # List all registered transports
-      def available
-        registry.list
-      end
-    end
-  end
-end
+require_relative 'transport/redis_transport'

data/lib/smart_message/utilities.rb

@@ -0,0 +1,142 @@
+# lib/smart_message/utilities.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'set'   # STDLIB
+
+module SmartMessage
+  # Utilities module for SmartMessage::Base
+  # Provides utility methods for message introspection and debugging
+  module Utilities
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #########################################################
+    ## instance-level utility methods
+
+    # return this class' name as a string
+    def whoami
+      self.class.to_s
+    end
+
+    # return this class' description
+    def description
+      self.class.description
+    end
+
+    # Clean accessor to the SmartMessage header object
+    # Provides more intuitive API than _sm_header
+    # Note: Renamed to avoid conflict with class-level header DSL
+    def message_header
+      _sm_header
+    end
+
+    # returns a collection of class Set that consists of
+    # the symbolized values of the property names of the message
+    # without the injected '_sm_' properties that support
+    # the behind-the-sceens operations of SmartMessage.
+    def fields
+      to_h.keys
+          .reject{|key| key.start_with?('_sm_')}
+          .map{|key| key.to_sym}
+          .to_set
+    end
+
+    # Pretty print the message content to STDOUT using amazing_print
+    # @param pp_or_include_header [PP, Boolean] Either a PP printer object (from Ruby's pp library) 
+    #                                           or include_header boolean (for our custom usage)
+    # @param include_header [Boolean] Whether to include the SmartMessage header (default: false)
+    def pretty_print(pp_or_include_header = nil, include_header: false)
+      # Handle Ruby's PP library calling convention: pretty_print(pp_object)
+      if pp_or_include_header.is_a?(Object) && pp_or_include_header.respond_to?(:text)
+        # This is Ruby's PP library calling us - delegate to standard object pretty printing
+        pp_or_include_header.text(self.inspect)
+        return
+      end
+      
+      # Handle our custom calling convention: pretty_print(include_header: true)
+      if pp_or_include_header.is_a?(TrueClass) || pp_or_include_header.is_a?(FalseClass)
+        include_header = pp_or_include_header
+      end
+      
+      require 'amazing_print'
+      
+      if include_header
+        # Show both header and content
+        puts "Header:"
+        puts "-" * 20
+        
+        # Get header data, converting to symbols and filtering out nils
+        header_data = _sm_header.to_h
+          .reject { |key, value| value.nil? }
+        header_data = deep_symbolize_keys(header_data)
+        ap header_data
+        
+        puts "\nContent:"
+        puts "-" * 20
+        
+        # Get payload data (message properties excluding header)
+        content_data = get_payload_data.reject { |key, value| value.nil? }
+        content_data = deep_symbolize_keys(content_data)
+        ap content_data
+      else
+        # Show only message content (excluding _sm_ properties and nil values)
+        content_data = get_payload_data.reject { |key, value| value.nil? }
+        content_data = deep_symbolize_keys(content_data)
+        ap content_data
+      end
+    end
+
+    private
+
+    # Extract payload data (all properties except _sm_header)
+    def get_payload_data
+      self.class.properties.each_with_object({}) do |prop, hash|
+        next if prop == :_sm_header
+        hash[prop.to_sym] = 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
+
+    module ClassMethods
+      #########################################################
+      ## class-level description
+      
+      def description(desc = nil)
+        if desc.nil?
+          @description || "#{self.name} is a SmartMessage"
+        else
+          @description = desc.to_s
+        end
+      end
+
+      #########################################################
+      ## class-level utility methods
+
+      # return this class' name as a string
+      def whoami
+        ancestors.first.to_s
+      end
+
+      # Return a Set of symbols representing each defined property of
+      # this message class.
+      def fields
+        @properties.dup.delete_if{|item| item.to_s.start_with?('_sm_')}
+      end
+    end
+  end
+end

data/lib/smart_message/version.rb

@@ -3,5 +3,5 @@
 # frozen_string_literal: true
 
 module SmartMessage
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/lib/smart_message/versioning.rb

@@ -0,0 +1,85 @@
+# lib/smart_message/versioning.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  # Versioning module for SmartMessage::Base
+  # Handles schema versioning and version validation
+  module Versioning
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Validate that the header version matches the expected version for this class
+    def validate_header_version!
+      expected = self.class.expected_header_version
+      actual = _sm_header.version
+      unless actual == expected
+        raise SmartMessage::Errors::ValidationError,
+          "#{self.class.name} expects version #{expected}, but header has version #{actual}"
+      end
+    end
+
+    # Override PropertyValidations validate! to include header and version validation
+    def validate!
+      # Validate message properties using PropertyValidations
+      super
+      
+      # Validate header properties
+      _sm_header.validate!
+      
+      # Validate header version matches expected class version  
+      validate_header_version!
+    end
+
+    # Override PropertyValidations validation_errors to include header errors
+    def validation_errors
+      errors = []
+      
+      # Get message property validation errors using PropertyValidations
+      errors.concat(super.map { |err| 
+        err.merge(source: 'message') 
+      })
+      
+      # Get header validation errors
+      errors.concat(_sm_header.validation_errors.map { |err| 
+        err.merge(source: 'header') 
+      })
+      
+      # Check version mismatch
+      expected = self.class.expected_header_version
+      actual = _sm_header.version
+      unless actual == expected
+        errors << {
+          property: :version,
+          value: actual,
+          message: "Expected version #{expected}, got: #{actual}",
+          source: 'version_mismatch'
+        }
+      end
+      
+      errors
+    end
+
+    module ClassMethods
+      # Class-level version setting
+      attr_accessor :_version
+      
+      def version(v = nil)
+        if v.nil?
+          @_version || 1  # Default to version 1 if not set
+        else
+          @_version = v
+          
+          # Set up version validation for the header
+          # This ensures that the header version matches the expected class version
+          @expected_header_version = v
+        end
+      end
+      
+      def expected_header_version
+        @expected_header_version || 1
+      end
+    end
+  end
+end