smart_message 0.0.12 → 0.0.13

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/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,16 +18,12 @@ 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
+        # Transport now handles serialization - just pass the message instance
         (self.class.logger || SmartMessage::Logger.default).debug { "[SmartMessage::Messaging] About to call transport.publish" }
-        transport.publish(_sm_header.message_class, serialized_message)
+        transport.publish(self)
         (self.class.logger || SmartMessage::Logger.default).debug { "[SmartMessage::Messaging] transport.publish completed" }
         
         # Log the message publish
@@ -67,34 +37,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
@@ -45,27 +44,6 @@ module SmartMessage
     end
     def reset_transport;        @transport = nil;  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
-    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?
-    end
-    def reset_serializer;       @serializer = nil;  end
-
     module ClassMethods
       #########################################################
       ## class-level configuration
@@ -111,25 +89,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/transport/base.rb

@@ -11,15 +11,17 @@ module SmartMessage
     class Base
       include BreakerMachines::DSL
 
-      attr_reader :options, :dispatcher
+      attr_reader :options, :dispatcher, :serializer
 
       def initialize(**options)
         @options = default_options.merge(options)
         @dispatcher = options[:dispatcher] || SmartMessage::Dispatcher.new
+        @serializer = options[:serializer] || default_serializer
         configure
         configure_transport_circuit_breakers
         
         logger.debug { "[SmartMessage::Transport::#{self.class.name.split('::').last}] Initialized with options: #{@options}" }
+        logger.debug { "[SmartMessage::Transport::#{self.class.name.split('::').last}] Using serializer: #{@serializer.class.name}" }
       rescue => e
         logger&.error { "[SmartMessage] Error in transport initialization: #{e.class.name} - #{e.message}" }
         raise
@@ -43,10 +45,20 @@ module SmartMessage
         {}
       end
 
+      # Default serializer for this transport (override in subclasses)
+      def default_serializer
+        SmartMessage::Serializer::Json.new
+      end
+
       # Publish a message with circuit breaker protection
-      # @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)
+      # @param message [SmartMessage::Base] The message instance to publish
+      def publish(message)
+        # Extract routing info from message header
+        message_class = message._sm_header.message_class
+        
+        # Serialize the entire message (flat structure with _sm_header)
+        serialized_message = encode_message(message)
+        
         circuit(:transport_publish).wrap do
           do_publish(message_class, serialized_message)
         end
@@ -58,7 +70,7 @@ module SmartMessage
         raise unless e.is_a?(Hash) && e[:circuit_breaker]
 
         # Handle circuit breaker fallback
-        handle_publish_fallback(e, message_class, serialized_message)
+        handle_publish_fallback(e, message._sm_header.message_class, serialized_message)
       end
 
       # Template method for actual publishing (implement in subclasses)
@@ -150,13 +162,32 @@ module SmartMessage
         end
       end
 
+      # Encode a message using the transport's serializer
+      # @param message [SmartMessage::Base] The message to encode
+      # @return [String] The serialized message
+      def encode_message(message)
+        # Update header with serializer info
+        message._sm_header.serializer = @serializer.class.to_s
+        
+        # Serialize the entire message as a flat structure
+        @serializer.encode(message.to_hash)
+      end
+
+      # Decode a message using the transport's serializer
+      # @param serialized_message [String] The serialized message
+      # @return [Hash] The decoded message data
+      def decode_message(serialized_message)
+        @serializer.decode(serialized_message)
+      end
+
       # Receive and route a message (called by transport implementations)
       # @param message_class [String] The message class name
       # @param serialized_message [String] The serialized message content
       protected
 
       def receive(message_class, serialized_message)
-        # Decode the message using the class's configured serializer
+        # Decode the message using transport's serializer
+        decoded_data = decode_message(serialized_message)
         
         # Add defensive check for message_class type
         unless message_class.respond_to?(:constantize)
@@ -165,10 +196,13 @@ module SmartMessage
           raise ArgumentError, "message_class must be a String, got #{message_class.class.name}"
         end
         
+        # Reconstruct the message instance from flat structure
         message_class_obj = message_class.constantize
-        decoded_message = message_class_obj.decode(serialized_message)
+        # Convert string keys to symbols for keyword arguments
+        symbol_data = decoded_data.transform_keys(&:to_sym)
+        message = message_class_obj.new(**symbol_data)
         
-        @dispatcher.route(decoded_message)
+        @dispatcher.route(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})" }

data/lib/smart_message/transport/memory_transport.rb

@@ -16,30 +16,49 @@ module SmartMessage
         }
       end
 
+      # Memory transport doesn't need serialization
+      def default_serializer
+        nil
+      end
+
       def configure
         @messages = []
         @message_mutex = Mutex.new
       end
 
-      # Publish message to memory queue
+      # Implement do_publish for memory transport (no serialization needed)
       def do_publish(message_class, serialized_message)
+        # For memory transport, serialized_message is actually the message object
+        message = serialized_message
+        
         @message_mutex.synchronize do
           # Prevent memory overflow
           @messages.shift if @messages.size >= @options[:max_messages]
           
+          # Store the actual message object, no serialization needed
           @messages << {
             message_class: message_class,
-            serialized_message: serialized_message,
+            message: message.dup,  # Store a copy to prevent mutation
             published_at: Time.now
           }
         end
 
         # Auto-process if enabled
         if @options[:auto_process]
-          receive(message_class, serialized_message)
+          # Route directly without serialization
+          @dispatcher.route(message)
         end
       end
 
+      # Override encode_message to return the message object directly
+      def encode_message(message)
+        # Update header with serializer info (even though we don't serialize)
+        message._sm_header.serializer = 'none'
+        
+        # Return the message object itself (no encoding needed)
+        message
+      end
+
       # Get all stored messages
       def all_messages
         @message_mutex.synchronize { @messages.dup }
@@ -59,7 +78,7 @@ module SmartMessage
       def process_all
         messages_to_process = @message_mutex.synchronize { @messages.dup }
         messages_to_process.each do |msg|
-          receive(msg[:message_class], msg[:serialized_message])
+          @dispatcher.route(msg[:message])
         end
       end
 

data/lib/smart_message/transport/redis_transport.rb

@@ -24,6 +24,17 @@ module SmartMessage
         }
       end
 
+      # Default to MessagePack for Redis (efficient binary format)
+      def default_serializer
+        # Try MessagePack first, fall back to JSON
+        begin
+          require 'smart_message/serializer/message_pack'
+          SmartMessage::Serializer::MessagePack.new
+        rescue LoadError
+          SmartMessage::Serializer::Json.new
+        end
+      end
+
       def configure
         @redis_pub = Redis.new(url: @options[:url], db: @options[:db])
         @redis_sub = Redis.new(url: @options[:url], db: @options[:db])

data/lib/smart_message/transport/registry.rb

@@ -54,7 +54,6 @@ module SmartMessage
         register(:stdout, SmartMessage::Transport::StdoutTransport)
         register(:memory, SmartMessage::Transport::MemoryTransport)
         register(:redis, SmartMessage::Transport::RedisTransport)
-        register(:redis_queue, SmartMessage::Transport::RedisQueueTransport)
       end
     end
   end

data/lib/smart_message/transport/stdout_transport.rb

@@ -10,10 +10,16 @@ module SmartMessage
       def default_options
         {
           loopback: false,
-          output: $stdout
+          output: $stdout,
+          format: :pretty  # :pretty or :json
         }
       end
 
+      # Default to JSON for readability in STDOUT
+      def default_serializer
+        SmartMessage::Serializer::Json.new
+      end
+
       def configure
         @output = @options[:output].is_a?(String) ? File.open(@options[:output], 'w') : @options[:output]
       end
@@ -27,7 +33,7 @@ module SmartMessage
         @options[:loopback]
       end
 
-      # Publish message to STDOUT (single-tier serialization)
+      # Publish message to STDOUT
       def do_publish(message_class, serialized_message)
         logger.debug { "[SmartMessage::StdoutTransport] do_publish called" }
         logger.debug { "[SmartMessage::StdoutTransport] message_class: #{message_class}" }
@@ -56,16 +62,28 @@ module SmartMessage
       private
 
       def format_message(message_class, serialized_message)
-        <<~MESSAGE
+        if @options[:format] == :json
+          # Output as JSON for machine parsing
+          {
+            transport: 'stdout',
+            message_class: message_class,
+            serialized_message: serialized_message,
+            timestamp: Time.now.iso8601
+          }.to_json
+        else
+          # Pretty format for human reading
+          <<~MESSAGE
 
-          ===================================================
-          == SmartMessage Published via STDOUT Transport
-          == Single-Tier Serialization:
-          == Message Class: #{message_class}
-          == Serialized Message: #{serialized_message}
-          ===================================================
+            ===================================================
+            == SmartMessage Published via STDOUT Transport
+            == Message Class: #{message_class}
+            == Serializer: #{@serializer.class.name}
+            == Serialized Message:
+            #{serialized_message}
+            ===================================================
 
-        MESSAGE
+          MESSAGE
+        end
       end
     end
   end

data/lib/smart_message/transport.rb

@@ -7,7 +7,6 @@ require_relative 'transport/registry'
 require_relative 'transport/stdout_transport'
 require_relative 'transport/memory_transport'
 require_relative 'transport/redis_transport'
-require_relative 'transport/redis_queue_transport'
 
 module SmartMessage
   module Transport

data/lib/smart_message/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_message
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -311,9 +311,6 @@ files:
 - docs/development/troubleshooting.md
 - docs/getting-started/examples.md
 - docs/getting-started/quick-start.md
-- docs/guides/redis-queue-getting-started.md
-- docs/guides/redis-queue-patterns.md
-- docs/guides/redis-queue-production.md
 - docs/index.md
 - docs/reference/dead-letter-queue.md
 - docs/reference/logging.md
@@ -322,8 +319,6 @@ files:
 - docs/reference/serializers.md
 - docs/reference/transports.md
 - docs/transports/memory-transport.md
-- docs/transports/redis-enhanced-transport.md
-- docs/transports/redis-queue-transport.md
 - docs/transports/redis-transport-comparison.md
 - docs/transports/redis-transport.md
 - examples/.gitignore
@@ -399,25 +394,6 @@ files:
 - examples/redis/redis_transport_architecture.svg
 - examples/redis/smart_home_iot_dataflow.md
 - examples/redis/smart_home_system_architecture.svg
-- examples/redis_enhanced/README.md
-- examples/redis_enhanced/enhanced_01_basic_patterns.rb
-- examples/redis_enhanced/enhanced_02_fluent_api.rb
-- examples/redis_enhanced/enhanced_03_dual_publishing.rb
-- examples/redis_enhanced/enhanced_04_advanced_routing.rb
-- examples/redis_queue/01_basic_messaging.rb
-- examples/redis_queue/01_comprehensive_examples.rb
-- examples/redis_queue/02_pattern_routing.rb
-- examples/redis_queue/03_fluent_api.rb
-- examples/redis_queue/04_load_balancing.rb
-- examples/redis_queue/05_microservices.rb
-- examples/redis_queue/06_emergency_alerts.rb
-- examples/redis_queue/07_queue_management.rb
-- examples/redis_queue/README.md
-- examples/redis_queue/enhanced_01_basic_patterns.rb
-- examples/redis_queue/enhanced_02_fluent_api.rb
-- examples/redis_queue/enhanced_03_dual_publishing.rb
-- examples/redis_queue/enhanced_04_advanced_routing.rb
-- examples/redis_queue/redis_queue_architecture.svg
 - ideas/README.md
 - ideas/agents.md
 - ideas/database_transport.md
@@ -463,8 +439,6 @@ files:
 - lib/smart_message/transport.rb
 - lib/smart_message/transport/base.rb
 - lib/smart_message/transport/memory_transport.rb
-- lib/smart_message/transport/redis_enhanced_transport.rb
-- lib/smart_message/transport/redis_queue_transport.rb
 - lib/smart_message/transport/redis_transport.rb
 - lib/smart_message/transport/registry.rb
 - lib/smart_message/transport/stdout_transport.rb
@@ -499,7 +473,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.7.2
 specification_version: 4
 summary: An abstraction to protect message content from the backend delivery transport.
 test_files: []