smart_message 0.0.8 → 0.0.10

data/lib/smart_message/logger/default.rb

@@ -9,170 +9,141 @@ require 'stringio'
 module SmartMessage
   module Logger
     # Default logger implementation for SmartMessage
-    # 
-    # This logger automatically detects and uses the best available logging option:
-    # - Rails.logger if running in a Rails application
-    # - Standard Ruby Logger writing to log/smart_message.log otherwise
+    #
+    # This logger provides a simple Ruby Logger wrapper with enhanced formatting.
+    # Applications can easily configure Rails.logger or other loggers through
+    # the global configuration system instead.
     #
     # Usage:
-    #   # In your message class
-    #   config do
-    #     logger SmartMessage::Logger::Default.new
+    #   # Use default file logging
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Default.new
     #   end
     #
-    #   # Or with custom options
-    #   config do
-    #     logger SmartMessage::Logger::Default.new(
-    #       log_file: 'custom/path.log',    # File path
+    #   # Use custom options
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Default.new(
+    #       log_file: 'custom/path.log',
     #       level: Logger::DEBUG
     #     )
     #   end
     #
-    #   # To log to STDOUT instead of a file
-    #   config do
-    #     logger SmartMessage::Logger::Default.new(
-    #       log_file: STDOUT,               # STDOUT or STDERR
+    #   # Log to STDOUT
+    #   SmartMessage.configure do |config|
+    #     config.logger = SmartMessage::Logger::Default.new(
+    #       log_file: STDOUT,
     #       level: Logger::INFO
     #     )
     #   end
+    #
+    #   # Use Rails logger instead
+    #   SmartMessage.configure do |config|
+    #     config.logger = Rails.logger
+    #   end
     class Default < Base
       attr_reader :logger, :log_file, :level
-      
+
       def initialize(log_file: nil, level: nil)
-        @log_file = log_file || default_log_file
-        @level = level || default_log_level
-        
+        @log_file = log_file || 'log/smart_message.log'
+        @level = level || ::Logger::INFO
+
         @logger = setup_logger
       end
-      
-      # Message lifecycle logging methods
-      
-      def log_message_created(message)
-        logger.debug { "[SmartMessage] Created: #{message.class.name} - #{message_summary(message)}" }
-      end
-      
-      def log_message_published(message, transport)
-        logger.info { "[SmartMessage] Published: #{message.class.name} via #{transport.class.name.split('::').last}" }
-      end
-      
-      def log_message_received(message_class, payload)
-        logger.info { "[SmartMessage] Received: #{message_class.name} (#{payload.bytesize} bytes)" }
-      end
-      
-      def log_message_processed(message_class, result)
-        logger.info { "[SmartMessage] Processed: #{message_class.name} - #{truncate(result.to_s, 100)}" }
-      end
-      
-      def log_message_subscribe(message_class, handler = nil)
-        handler_desc = handler ? " with handler: #{handler}" : ""
-        logger.info { "[SmartMessage] Subscribed: #{message_class.name}#{handler_desc}" }
-      end
-      
-      def log_message_unsubscribe(message_class)
-        logger.info { "[SmartMessage] Unsubscribed: #{message_class.name}" }
-      end
-      
-      # Error logging
-      
-      def log_error(context, error)
-        logger.error { "[SmartMessage] Error in #{context}: #{error.class.name} - #{error.message}" }
-        logger.debug { "[SmartMessage] Backtrace:\n#{error.backtrace.join("\n")}" } if error.backtrace
-      end
-      
-      def log_warning(message)
-        logger.warn { "[SmartMessage] Warning: #{message}" }
-      end
-      
+
+
       # General purpose logging methods matching Ruby's Logger interface
-      
+      # These methods capture caller information and embed it in the log message
+
       def debug(message = nil, &block)
-        logger.debug(message, &block)
+        enhanced_log(:debug, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def info(message = nil, &block)
-        logger.info(message, &block)
+        enhanced_log(:info, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def warn(message = nil, &block)
-        logger.warn(message, &block)
+        enhanced_log(:warn, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def error(message = nil, &block)
-        logger.error(message, &block)
+        enhanced_log(:error, message, caller_locations(1, 1).first, &block)
       end
-      
+
       def fatal(message = nil, &block)
-        logger.fatal(message, &block)
+        enhanced_log(:fatal, message, caller_locations(1, 1).first, &block)
       end
-      
+
       private
-      
-      def setup_logger
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          # Use Rails logger if available
-          setup_rails_logger
+
+      # Enhanced logging method that embeds caller information
+      def enhanced_log(level, message, caller_location, &block)
+        if caller_location
+          file_path = caller_location.path
+          line_number = caller_location.lineno
+          
+          # If a block is provided, call it to get the message
+          if block_given?
+            actual_message = block.call
+          else
+            actual_message = message
+          end
+          
+          # Embed caller info in the message
+          enhanced_message = "[#{file_path}:#{line_number}] #{actual_message}"
+          logger.send(level, enhanced_message)
         else
-          # Use standard Ruby logger
-          setup_ruby_logger
+          # Fallback if caller information is not available
+          if block_given?
+            logger.send(level, &block)
+          else
+            logger.send(level, message)
+          end
         end
       end
-      
-      def setup_rails_logger
-        # Wrap Rails.logger to ensure our messages are properly tagged
-        RailsLoggerWrapper.new(Rails.logger, level: @level)
-      end
-      
-      def setup_ruby_logger
+
+      def setup_logger
         # Handle IO objects (STDOUT, STDERR) vs file paths
         if @log_file.is_a?(IO) || @log_file.is_a?(StringIO)
           # For STDOUT/STDERR, don't use rotation
           ruby_logger = ::Logger.new(@log_file)
         else
           # For file paths, ensure directory exists and use rotation
-          FileUtils.mkdir_p(File.dirname(@log_file))
-          
+          log_dir = File.dirname(@log_file)
+          FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+
           ruby_logger = ::Logger.new(
             @log_file,
             10,           # Keep 10 old log files
             10_485_760    # Rotate when file reaches 10MB
           )
         end
-        
+
         ruby_logger.level = @level
-        
-        # Set a clean formatter
+
+        # Set a formatter that includes file and line number
         ruby_logger.formatter = proc do |severity, datetime, progname, msg|
           timestamp = datetime.strftime('%Y-%m-%d %H:%M:%S.%3N')
-          "[#{timestamp}] #{severity.ljust(5)} -- : #{msg}\n"
-        end
-        
-        ruby_logger
-      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 'production'
-            ::Logger::INFO
-          when 'test'
-            ::Logger::ERROR
+          
+          # Extract caller information if it's embedded in the message
+          if msg.is_a?(String) && msg.match(/\A\[(.+?):(\d+)\] (.+)\z/)
+            file_path = $1
+            line_number = $2
+            actual_msg = $3
+            
+            # Get just the filename from the full path
+            filename = File.basename(file_path)
+            
+            "[#{timestamp}] #{severity.ljust(5)} -- #{filename}:#{line_number} : #{actual_msg}\n"
           else
-            ::Logger::DEBUG
+            "[#{timestamp}] #{severity.ljust(5)} -- : #{msg}\n"
           end
-        else
-          # Default to INFO for non-Rails environments
-          ::Logger::INFO
         end
+
+        ruby_logger
       end
-      
+
+
       def message_summary(message)
         # Create a brief summary of the message for logging
         if message.respond_to?(:to_h)
@@ -185,33 +156,12 @@ module SmartMessage
           truncate(message.inspect, 200)
         end
       end
-      
+
       def truncate(string, max_length)
         return string if string.length <= max_length
         "#{string[0...max_length]}..."
       end
-      
-      # Internal wrapper for Rails.logger to handle tagged logging
-      class RailsLoggerWrapper
-        def initialize(rails_logger, level: nil)
-          @rails_logger = rails_logger
-          @rails_logger.level = level if level
-        end
-        
-        def method_missing(method, *args, &block)
-          if @rails_logger.respond_to?(:tagged)
-            @rails_logger.tagged('SmartMessage') do
-              @rails_logger.send(method, *args, &block)
-            end
-          else
-            @rails_logger.send(method, *args, &block)
-          end
-        end
-        
-        def respond_to_missing?(method, include_private = false)
-          @rails_logger.respond_to?(method, include_private)
-        end
-      end
+
     end
   end
-end
+end

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