smart_message 0.0.7 → 0.0.9

data/lib/smart_message/serializer/base.rb

@@ -2,6 +2,7 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require 'json'  # STDLIB
 require_relative '../circuit_breaker'
 
 module SmartMessage::Serializer
@@ -12,7 +13,20 @@ module SmartMessage::Serializer
     # provide basic configuration
     def initialize
       configure_serializer_circuit_breakers
+      
+      logger.debug { "[SmartMessage::Serializer::#{self.class.name.split('::').last}] Initialized" }
+    rescue => e
+      logger&.error { "[SmartMessage] Error in serializer initialization: #{e.class.name} - #{e.message}" }
+      raise
+    end
+    
+    private
+    
+    def logger
+      @logger ||= SmartMessage::Logger.default
     end
+    
+    public
 
     def encode(message_instance)
       circuit(:serializer).wrap do
@@ -39,10 +53,16 @@ module SmartMessage::Serializer
         raise
       end
     end
+    
+    private
 
     # Template methods for actual serialization (implement in subclasses)
     def do_encode(message_instance)
-      raise ::SmartMessage::Errors::NotImplemented
+      # Default implementation: serialize only the payload portion for wrapper architecture
+      # Subclasses can override this for specific serialization formats
+      message_hash = message_instance.to_h
+      payload_portion = message_hash[:_sm_payload]
+      ::JSON.generate(payload_portion)
     end
 
     def do_decode(payload)
@@ -81,13 +101,10 @@ module SmartMessage::Serializer
 
     # Handle serializer circuit breaker fallback
     def handle_serializer_fallback(fallback_result, operation, data)
-      if $DEBUG
-        puts "Serializer circuit breaker activated: #{self.class.name}"
-        puts "Operation: #{operation}"
-        puts "Error: #{fallback_result[:circuit_breaker][:error]}"
-      end
-      
-      # TODO: Integrate with structured logging when implemented
+      # Integrate with structured logging
+      logger.error { "[SmartMessage::Serializer] Circuit breaker activated: #{self.class.name}" }
+      logger.error { "[SmartMessage::Serializer] Operation: #{operation}" }
+      logger.error { "[SmartMessage::Serializer] Error: #{fallback_result[:circuit_breaker][:error]}" }
       
       # Return the fallback result
       fallback_result

data/lib/smart_message/serializer/json.rb

@@ -5,11 +5,12 @@
 require 'json'  # STDLIB
 
 module SmartMessage::Serializer
-  class JSON < Base
+  class Json < Base
     def do_encode(message_instance)
-      # TODO: is this the right place to insert an automated-invisible
-      #       message header?
-      message_instance.to_json
+      # Single-tier serialization: serialize the complete message structure
+      # This includes both header and payload for full message reconstruction
+      message_hash = message_instance.to_h
+      ::JSON.generate(message_hash)
     end
 
     def do_decode(payload)

data/lib/smart_message/subscription.rb

@@ -0,0 +1,193 @@
+# lib/smart_message/subscription.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'securerandom'   # STDLIB
+
+module SmartMessage
+  # Subscription management module for SmartMessage::Base
+  # Handles subscribe/unsubscribe operations and proc handler management
+  module Subscription
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        # Registry for proc-based message handlers
+        class_variable_set(:@@proc_handlers, {}) unless class_variable_defined?(:@@proc_handlers)
+      end
+    end
+
+    module ClassMethods
+      #########################################################
+      ## proc handler management
+
+      # Register a proc handler and return a unique identifier for it
+      # @param message_class [String] The message class name
+      # @param handler_proc [Proc] The proc to register
+      # @return [String] Unique identifier for this handler
+      def register_proc_handler(message_class, handler_proc)
+        handler_id = "#{message_class}.proc_#{SecureRandom.hex(8)}"
+        class_variable_get(:@@proc_handlers)[handler_id] = handler_proc
+        handler_id
+      end
+
+      # 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)
+        handler_proc = class_variable_get(:@@proc_handlers)[handler_id]
+        return unless handler_proc
+
+        handler_proc.call(wrapper)
+      end
+
+      # Remove a proc handler from the registry
+      # @param handler_id [String] The handler identifier to remove
+      def unregister_proc_handler(handler_id)
+        class_variable_get(:@@proc_handlers).delete(handler_id)
+      end
+
+      # Check if a handler ID refers to a proc handler
+      # @param handler_id [String] The handler identifier
+      # @return [Boolean] True if this is a proc handler
+      def proc_handler?(handler_id)
+        class_variable_get(:@@proc_handlers).key?(handler_id)
+      end
+
+      #########################################################
+      ## class-level subscription management via the transport
+
+      # Add this message class to the transport's catalog of
+      # subscribed messages.  If the transport is missing, raise
+      # 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)
+      #   - 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
+      # @param from [String, Array, nil] Filter for messages from specific entities
+      # @param block [Proc] Alternative way to pass a processing block
+      # @return [String] The identifier used for this subscription
+      #
+      # @example Using default handler (all messages)
+      #   MyMessage.subscribe
+      #
+      # @example Using custom method name with filtering
+      #   MyMessage.subscribe("MyService.handle_message", to: 'my-service')
+      #
+      # @example Using a block with broadcast filtering
+      #   MyMessage.subscribe(broadcast: true) do |header, payload|
+      #     data = JSON.parse(payload)
+      #     puts "Received broadcast: #{data}"
+      #   end
+      #
+      # @example Entity-specific filtering
+      #   MyMessage.subscribe(to: 'order-service', from: ['payment', 'user'])
+      #
+      # @example Broadcast + directed messages
+      #   MyMessage.subscribe(to: 'my-service', broadcast: true)
+      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
+          handler_proc = block
+          process_method = register_proc_handler(message_class, handler_proc)
+        elsif process_method.respond_to?(:call)
+          # Proc/lambda was passed as first parameter
+          handler_proc = process_method
+          process_method = register_proc_handler(message_class, handler_proc)
+        elsif process_method.nil?
+          # Use default handler
+          process_method = message_class + '.process'
+        end
+        # If process_method is a String, use it as-is
+
+        # Normalize string filters to arrays
+        to_filter = normalize_filter_value(to)
+        from_filter = normalize_filter_value(from)
+        
+        # Create filter options
+        filter_options = {
+          broadcast: broadcast,
+          to: to_filter,
+          from: from_filter
+        }
+
+        # 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}" }
+          raise
+        end
+      end
+
+      # Remove this process_method for this message class from the
+      # subscribers list.
+      # @param process_method [String, nil] The processing method identifier to remove
+      #   - String: Method name like "MyService.handle_message" or proc handler ID
+      #   - nil: Uses default "MessageClass.process" method
+      def unsubscribe(process_method = nil)
+        message_class   = whoami
+        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}" }
+          end
+        rescue => e
+          logger.error { "[SmartMessage] Error in message unsubscription: #{e.class.name} - #{e.message}" }
+          raise
+        end
+      end
+
+      # Remove this message class and all of its processing methods
+      # from the subscribers list.
+      def unsubscribe!
+        message_class   = whoami
+
+        # TODO: Add proper logging here
+
+        transport.unsubscribe!(message_class) if transport_configured?
+      end
+
+      ###################################################
+      ## Business Logic resides in the #process method.
+
+      # When a transport receives a subscribed to message it
+      # creates an instance of the message and then calls
+      # the process method on that instance.
+      #
+      # It is expected that SmartMessage classes over ride
+      # the SmartMessage::Base#process method with appropriate
+      # business logic to handle the received message content.
+      def process(message_instance)
+        raise Errors::NotImplemented
+      end
+    end
+  end
+end

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,54 +151,59 @@ 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
-          fallback do |exception|
-            {
-              circuit_breaker: {
-                circuit: :transport_publish,
-                transport_type: self.class.name,
-                state: 'open',
-                error: exception.message,
-                error_class: exception.class.name,
-                timestamp: Time.now.iso8601,
-                fallback_triggered: true
-              }
-            }
-          end
+
+          # 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
+
+          # Fallback for subscribe failures - log and return error info
           fallback do |exception|
             {
               circuit_breaker: {
@@ -201,22 +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}"
+        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_class,
+              serialized_message,
+              error: fallback_result.dig(:circuit_breaker, :error) || 'Circuit breaker activated',
+              transport: self.class.name
+            )
+          rescue => dlq_error
+            logger.warn { "[SmartMessage] Warning: Failed to store message in DLQ: #{dlq_error.message}" }
+          end
         end
-        
-        # TODO: Integrate with structured logging when implemented
-        # TODO: Queue for retry or send to dead letter queue
-        
+
         # 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