smart_message 0.0.7 → 0.0.9

data/lib/smart_message/logger/lumberjack.rb

@@ -0,0 +1,324 @@
+# lib/smart_message/logger/lumberjack.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'lumberjack'
+require 'fileutils'
+require 'colorize'
+
+module SmartMessage
+  module Logger
+    # Lumberjack-based logger implementation for SmartMessage
+    #
+    # This logger uses the Lumberjack gem to provide enhanced structured logging
+    # with automatic source location tracking, structured data support, and
+    # better performance characteristics.
+    #
+    # Features:
+    # - Automatic source location tracking (file:line) for every log entry
+    # - Structured data logging for message headers and payloads
+    # - Better performance than standard Ruby Logger
+    # - JSON output support for machine-readable logs
+    # - Customizable formatters and devices
+    #
+    # Usage:
+    #   # Basic usage with file logging
+    #   config do
+    #     logger SmartMessage::Logger::Lumberjack.new
+    #   end
+    #
+    #   # Custom configuration
+    #   config do
+    #     logger SmartMessage::Logger::Lumberjack.new(
+    #       log_file: 'custom/smart_message.log',
+    #       level: :debug,
+    #       format: :json,                      # :text or :json
+    #       include_source: true,               # Include source location
+    #       structured_data: true,              # Log structured message data
+    #       colorize: true,                     # Enable colorized output (console only)
+    #       roll_by_date: true,                 # Enable date-based log rolling
+    #       max_file_size: 50 * 1024 * 1024     # Max file size before rolling (50 MB)
+    #     )
+    #   end
+    #
+    #   # Log to STDOUT with colorized JSON format
+    #   config do
+    #     logger SmartMessage::Logger::Lumberjack.new(
+    #       log_file: STDOUT,
+    #       format: :json,
+    #       colorize: true
+    #     )
+    #   end
+    class Lumberjack < Base
+      attr_reader :logger, :log_file, :level, :format, :include_source, :structured_data, :colorize
+
+      def initialize(log_file: nil, level: nil, format: :text, include_source: true, structured_data: true, colorize: false, **options)
+        @log_file = log_file || default_log_file
+        @level = level || default_log_level
+        @format = format
+        @include_source = include_source
+        @structured_data = structured_data
+        @options = options
+        
+        # Set colorize after @log_file is set so console_output? works correctly
+        @colorize = colorize && console_output?
+
+        @logger = setup_lumberjack_logger
+      end
+
+
+      # General purpose logging methods matching Ruby's Logger interface
+      # These methods capture caller information and add structured data
+
+      def debug(message = nil, **structured_data, &block)
+        return unless message || block_given?
+        structured_data[:message] = message if message
+        log_with_caller(:debug, 1, structured_data, &block)
+      end
+
+      def info(message = nil, **structured_data, &block)
+        return unless message || block_given?
+        structured_data[:message] = message if message
+        log_with_caller(:info, 1, structured_data, &block)
+      end
+
+      def warn(message = nil, **structured_data, &block)
+        return unless message || block_given?
+        structured_data[:message] = message if message
+        log_with_caller(:warn, 1, structured_data, &block)
+      end
+
+      def error(message = nil, **structured_data, &block)
+        return unless message || block_given?
+        structured_data[:message] = message if message
+        log_with_caller(:error, 1, structured_data, &block)
+      end
+
+      def fatal(message = nil, **structured_data, &block)
+        return unless message || block_given?
+        structured_data[:message] = message if message
+        log_with_caller(:fatal, 1, structured_data, &block)
+      end
+
+      # Check if output is going to console (STDOUT/STDERR)
+      def console_output?
+        @log_file == STDOUT || @log_file == STDERR
+      end
+
+      private
+
+      def setup_lumberjack_logger
+        # Create log directory if needed
+        if @log_file.is_a?(String) && !@log_file.start_with?('/dev/')
+          log_dir = File.dirname(@log_file)
+          FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+        end
+
+        # For STDOUT/STDERR, use Device::Writer with template for colorization
+        if console_output?
+          device = ::Lumberjack::Device::Writer.new(@log_file, template: create_template)
+          ::Lumberjack::Logger.new(device, level: normalize_level(@level))
+        else
+          # Build Lumberjack options for file-based logging
+          lumberjack_options = {
+            level: normalize_level(@level),
+            formatter: create_formatter,
+            buffer_size: 0  # Disable buffering for immediate output
+          }
+          
+          # Add log rolling options if specified
+          if @options[:roll_by_date]
+            lumberjack_options[:date_pattern] = @options[:date_pattern] || '%Y-%m-%d'
+          end
+          
+          if @options[:roll_by_size]
+            lumberjack_options[:max_size] = @options[:max_file_size] || (10 * 1024 * 1024) # 10 MB
+            lumberjack_options[:keep] = @options[:keep_files] || 5
+          end
+
+          # Configure the Lumberjack logger
+          ::Lumberjack::Logger.new(@log_file, lumberjack_options)
+        end
+      end
+
+      def create_template
+        # Template for Device::Writer (used for console output)
+        colorize_enabled = @colorize
+        include_source = @include_source
+        
+        case @format
+        when :json
+          # JSON template - return lambda that formats as JSON
+          lambda do |entry|
+            data = {
+              timestamp: entry.time.strftime('%Y-%m-%d %H:%M:%S.%3N'),
+              level: entry.severity_label,
+              message: entry.message
+            }
+
+            # Add source location if available
+            if include_source && entry.tags[:source]
+              data[:source] = entry.tags[:source]
+            end
+
+            # Add any structured data
+            entry.tags.each do |key, value|
+              next if key == :source
+              data[key] = value
+            end
+
+            data.to_json + "\n"
+          end
+        else
+          # Text template with optional colorization
+          lambda do |entry|
+            require 'colorize' if colorize_enabled
+            
+            timestamp = entry.time.strftime('%Y-%m-%d %H:%M:%S.%3N')
+            level = entry.severity_label.ljust(5)
+            source_info = include_source && entry.tags[:source] ? " #{entry.tags[:source]}" : ""
+
+            line = "[#{timestamp}] #{level} --#{source_info} : #{entry.message}"
+            
+            if colorize_enabled
+              # Apply colorization with custom color scheme
+              case entry.severity_label.downcase.to_sym
+              when :debug
+                # Debug: dark green background, white foreground, bold
+                line.white.bold.on_green
+              when :info
+                # Info: bright white foreground (no background)
+                line.light_white
+              when :warn
+                # Warn: yellow background, white foreground, bold
+                line.white.bold.on_yellow
+              when :error
+                # Error: red background, white foreground, bold
+                line.white.bold.on_red
+              when :fatal
+                # Fatal: bright red background, yellow foreground, bold
+                line.yellow.bold.on_light_red
+              else
+                line
+              end
+            else
+              line
+            end
+          end
+        end
+      end
+
+      def create_formatter
+        case @format
+        when :json
+          # JSON formatter with structured data support
+          ::Lumberjack::Formatter.new do |entry|
+            data = {
+              timestamp: entry.time.strftime('%Y-%m-%d %H:%M:%S.%3N'),
+              level: entry.severity_label,
+              message: entry.message
+            }
+
+            # Add source location if available
+            if @include_source && entry.tags[:source]
+              data[:source] = entry.tags[:source]
+            end
+
+            # Add any structured data
+            entry.tags.each do |key, value|
+              next if key == :source
+              data[key] = value
+            end
+
+            data.to_json + "\n"
+          end
+        else
+          # Text formatter for file output (no colorization)
+          ::Lumberjack::Formatter.new do |entry|
+            timestamp = entry.time.strftime('%Y-%m-%d %H:%M:%S.%3N')
+            level = entry.severity_label.ljust(5)
+            source_info = @include_source && entry.tags[:source] ? " #{entry.tags[:source]}" : ""
+
+            "[#{timestamp}] #{level} --#{source_info} : #{entry.message}\n"
+          end
+        end
+      end
+
+      def log_with_caller(level, caller_depth, structured_data = {}, &block)
+        return unless @logger.send("#{level}?")
+
+        caller_info = get_caller_info(caller_depth + 1)
+        tags = structured_data.dup
+        tags[:source] = caller_info if @include_source && caller_info
+
+        if block_given?
+          message = block.call(caller_info)
+        else
+          message = structured_data.delete(:message) || ""
+        end
+
+        if tags.empty?
+          @logger.send(level, message)
+        else
+          @logger.tag(tags) do
+            @logger.send(level, message)
+          end
+        end
+      end
+
+
+      def get_caller_info(depth)
+        return nil unless @include_source
+
+        caller_location = caller_locations(depth + 1, 1).first
+        return nil unless caller_location
+
+        filename = File.basename(caller_location.path)
+        line_number = caller_location.lineno
+        "#{filename}:#{line_number}"
+      end
+
+      def normalize_level(level)
+        case level
+        when Symbol
+          case level
+          when :debug then ::Lumberjack::Severity::DEBUG
+          when :info then ::Lumberjack::Severity::INFO
+          when :warn then ::Lumberjack::Severity::WARN
+          when :error then ::Lumberjack::Severity::ERROR
+          when :fatal then ::Lumberjack::Severity::FATAL
+          else ::Lumberjack::Severity::INFO
+          end
+        when Integer
+          level
+        else
+          ::Lumberjack::Severity::INFO
+        end
+      end
+
+      def default_log_file
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.join('log', 'smart_message.log').to_s
+        else
+          'log/smart_message.log'
+        end
+      end
+
+      def default_log_level
+        if defined?(Rails) && Rails.respond_to?(:env)
+          case Rails.env
+          when 'development', 'test'
+            :info
+          when 'production'
+            :info
+          else
+            :info
+          end
+        else
+          :info
+        end
+      end
+      
+    end
+  end
+end

data/lib/smart_message/logger/null.rb

@@ -0,0 +1,81 @@
+# lib/smart_message/logger/null.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module Logger
+    # Null logger implementation that discards all log messages
+    #
+    # This logger provides a no-op implementation of the standard logging
+    # interface. All log messages are silently discarded, making it useful
+    # for applications that want to completely disable SmartMessage logging.
+    #
+    # Usage:
+    #   # Disable all SmartMessage logging
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Null.new
+    #   end
+    #
+    #   # Or set logger to nil (framework will use Null logger automatically)
+    #   SmartMessage.configure do |config|
+    #     config.logger = nil
+    #   end
+    class Null < Base
+      def initialize
+        # No setup needed for null logger
+      end
+
+      # All logging methods are no-ops that accept any arguments
+      # and return nil immediately without processing
+
+      def debug(*args, &block)
+        # Silently discard
+        nil
+      end
+
+      def info(*args, &block)
+        # Silently discard
+        nil
+      end
+
+      def warn(*args, &block)
+        # Silently discard
+        nil
+      end
+
+      def error(*args, &block)
+        # Silently discard
+        nil
+      end
+
+      def fatal(*args, &block)
+        # Silently discard
+        nil
+      end
+
+      # Additional methods that might be called on loggers
+
+      def level
+        ::Logger::FATAL + 1  # Higher than FATAL to ensure nothing logs
+      end
+
+      def level=(value)
+        # Ignore level changes
+      end
+
+      def close
+        # Nothing to close
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        # Pretend to respond to any logging method
+        true
+      end
+
+      def method_missing(method_name, *args, &block)
+        # Silently handle any other logging calls
+        nil
+      end
+    end
+  end
+end

data/lib/smart_message/logger.rb

@@ -2,14 +2,22 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
-module SmartMessage::Logger
-  # Logger module provides logging capabilities for SmartMessage
-  # The Default logger automatically uses Rails.logger if available,
-  # otherwise falls back to a standard Ruby Logger
-end # module SmartMessage::Logger
-
-# Load the base class first
 require_relative 'logger/base'
-
-# Load the default logger implementation
 require_relative 'logger/default'
+require_relative 'logger/lumberjack'
+
+module SmartMessage
+  module Logger
+    class << self
+      # Global default logger instance
+      def default
+        @default ||= Lumberjack.new
+      end
+
+      # Set the default logger
+      def default=(logger)
+        @default = logger
+      end
+    end
+  end
+end

data/lib/smart_message/messaging.rb

@@ -0,0 +1,100 @@
+# lib/smart_message/messaging.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  # Messaging module for SmartMessage::Base
+  # Handles message encoding and 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
+    #       the class-level
+    def publish
+      begin
+        # Validate the complete message before publishing (now uses overridden validate!)
+        validate!
+        
+        # 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" }
+        
+        # Log the message publish
+        (self.class.logger || SmartMessage::Logger.default).info { "[SmartMessage] Published: #{self.class.name} via #{transport.class.name.split('::').last}" }
+
+        SS.add(_sm_header.message_class, 'publish')
+        SS.get(_sm_header.message_class, 'publish')
+      rescue => e
+        (self.class.logger || SmartMessage::Logger.default).error { "[SmartMessage] Error in message publishing: #{e.class.name} - #{e.message}" }
+        raise
+      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

@@ -0,0 +1,132 @@
+# lib/smart_message/plugins.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  # Plugin configuration module for SmartMessage::Base
+  # Handles transport, serializer, and logger configuration at both
+  # class and instance levels
+  module Plugins
+    def self.included(base)
+      base.extend(ClassMethods)
+      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
+
+    #########################################################
+    ## instance-level configuration
+
+    # Configure the plugins for transport, serializer and logger
+    def config(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    #########################################################
+    ## instance-level transport configuration
+
+    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
+      else
+        @transport = klass_or_instance
+      end
+    end
+
+    def transport_configured?;  !transport_missing?;   end
+    def transport_missing?
+      # Check if transport is explicitly configured (without fallback to defaults)
+      @transport.nil? && 
+        (self.class.class_variable_get(:@@transport) rescue nil).nil?
+    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
+
+      def config(&block)
+        class_eval(&block) if block_given?
+      end
+
+      #########################################################
+      ## class-level transport configuration
+
+      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
+        else
+          class_variable_set(:@@transport, klass_or_instance)
+        end
+      end
+
+      def transport_configured?;  !transport_missing?;   end
+      def transport_missing?
+        # Check if class-level transport is explicitly configured (without fallback to defaults)
+        (class_variable_get(:@@transport) rescue nil).nil?
+      end
+      def reset_transport;       class_variable_set(:@@transport, nil);  end
+
+      #########################################################
+      ## class-level logger configuration
+
+      def logger(klass_or_instance = nil)
+        if klass_or_instance.nil?
+          # Return class-level logger or fall back to global configuration
+          class_variable_get(:@@logger) || SmartMessage::Logger.default
+        else
+          class_variable_set(:@@logger, klass_or_instance)
+        end
+      end
+
+      def logger_configured?;     !logger.nil?;   end
+      def logger_missing?;         logger.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