logstash-logger 0.26.1 → 1.0.0

data/lib/logstash-logger/device.rb

@@ -20,6 +20,7 @@ module LogStashLogger
     autoload :Stderr, 'logstash-logger/device/stderr'
     autoload :Balancer, 'logstash-logger/device/balancer'
     autoload :MultiDelegator, 'logstash-logger/device/multi_delegator'
+    autoload :HTTP, 'logstash-logger/device/http'
 
     def self.new(opts)
       opts = opts.dup
@@ -27,7 +28,7 @@ module LogStashLogger
     end
 
     def self.build_device(opts)
-      if parsed_uri_opts = parse_uri_config(opts)
+      if (parsed_uri_opts = parse_uri_config(opts))
         opts.delete(:uri)
         opts.merge!(parsed_uri_opts)
       end
@@ -38,10 +39,30 @@ module LogStashLogger
     end
 
     def self.parse_uri_config(opts)
-      if uri = opts[:uri]
+      if (uri = opts[:uri])
         require 'uri'
         parsed = ::URI.parse(uri)
         {type: parsed.scheme, host: parsed.host, port: parsed.port, path: parsed.path}
+          .merge(parse_uri_query(parsed.query))
+      end
+    end
+
+    def self.parse_uri_query(query)
+      return {} unless query && !query.empty?
+      ::URI.decode_www_form(query).each_with_object({}) do |(key, value), acc|
+        next unless key
+        key = key.to_s.strip
+        next if key.empty?
+        acc[key.to_sym] = cast_uri_value(key, value)
+      end
+    end
+
+    def self.cast_uri_value(key, value)
+      case key
+      when 'buffer_max_items'
+        value.to_i
+      else
+        value
       end
     end
 
@@ -60,6 +81,7 @@ module LogStashLogger
         when :stderr then Stderr
         when :multi_delegator then MultiDelegator
         when :balancer then Balancer
+        when :http then HTTP
         else fail ArgumentError, 'Invalid device type'
       end
     end

data/lib/logstash-logger/formatter/base.rb

@@ -4,19 +4,28 @@ require 'time'
 
 module LogStashLogger
   module Formatter
-    HOST = ::Socket.gethostname
+    HOST = {
+      'hostname' => ::Socket.gethostname,
+      'ip' => Socket.ip_address_list.reject(&:ipv4_loopback?).reject(&:ipv6_loopback?).map(&:ip_address)
+  }.freeze
 
     class Base < ::Logger::Formatter
+      FAILED_TO_FORMAT_MSG = 'Failed to format log event'
+      attr_accessor :error_logger
       include ::LogStashLogger::TaggedLogging::Formatter
 
-      def initialize(customize_event: nil)
+      def initialize(customize_event: nil, error_logger: LogStashLogger.configuration.default_error_logger)
         @customize_event = customize_event
+        @error_logger = error_logger
         super()
       end
 
       def call(severity, time, _progname, message)
         event = build_event(message, severity, time)
         format_event(event) unless event.cancelled?
+      rescue StandardError => e
+        log_error(e)
+        FAILED_TO_FORMAT_MSG
       end
 
       private
@@ -31,15 +40,24 @@ module LogStashLogger
                   when LogStash::Event
                     data.clone
                   when Hash
-                    event_data = data.clone
-                    event_data['message'.freeze] = event_data.delete(:message) if event_data.key?(:message)
-                    event_data['tags'.freeze] = event_data.delete(:tags) if event_data.key?(:tags)
-                    event_data['source'.freeze] = event_data.delete(:source) if event_data.key?(:source)
-                    event_data['type'.freeze] = event_data.delete(:type) if event_data.key?(:type)
-                    event_data['@timestamp'.freeze] = time
+                    event_data = { '@timestamp'.freeze => time }
+                    data.each do |key, value|
+                      case key
+                      when :message, 'message'
+                        event_data['message'.freeze] = value
+                      when :tags, 'tags'
+                        event_data['tags'.freeze] = value
+                      when :source, 'source'
+                        event_data['source'.freeze] = value
+                      when :type, 'type'
+                        event_data['type'.freeze] = value
+                      else
+                        event_data[key] = value
+                      end
+                    end
                     LogStash::Event.new(event_data)
                   else
-                    LogStash::Event.new("message".freeze => msg2str(data), "@timestamp".freeze => time)
+                    LogStash::Event.new("@timestamp".freeze => time, "message".freeze => msg2str(data))
                 end
 
         event['severity'.freeze] ||= severity
@@ -68,6 +86,33 @@ module LogStashLogger
       def format_event(event)
         event
       end
+
+      def force_utf8_encoding(event)
+        original_message = event.instance_variable_get(:@data)['message']
+        event.message = original_message.dup.force_encoding(Encoding::UTF_8).scrub
+        event
+      end
+
+      # Check if the message has encoding issues that would cause JSON serialization problems.
+      # This is needed because some Ruby implementations (e.g., JRuby) may not raise
+      # exceptions during JSON encoding but produce malformed output instead.
+      def message_has_encoding_issue?(event)
+        message = event.instance_variable_get(:@data)['message']
+        return false unless message.is_a?(String)
+
+        # Check if already valid UTF-8
+        return false if message.encoding == Encoding::UTF_8 && message.valid_encoding?
+
+        # Try to encode to UTF-8 to detect issues
+        message.encode(Encoding::UTF_8)
+        false
+      rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+        true
+      end
+
+      def log_error(e)
+        error_logger.error "[#{self.class}] #{e.class} - #{e.message}"
+      end
     end
   end
 end

data/lib/logstash-logger/formatter/cee_syslog.rb

@@ -9,7 +9,7 @@ module LogStashLogger
       private
 
       def build_facility(host)
-        facility = host.dup
+        facility = host['hostname'.freeze].dup
         facility << " #{@progname}" if @progname
         facility
       end

data/lib/logstash-logger/formatter/json.rb

@@ -4,7 +4,20 @@ module LogStashLogger
       private
 
       def format_event(event)
+        # Proactively check for encoding issues to handle cross-platform differences.
+        # Some Ruby implementations (e.g., JRuby) may not raise exceptions during
+        # JSON encoding but produce malformed output instead.
+        if message_has_encoding_issue?(event)
+          log_error(Encoding::InvalidByteSequenceError.new("Invalid encoding in message"))
+          return force_utf8_encoding(event).to_json
+        end
+
         event.to_json
+      rescue Encoding::UndefinedConversionError,
+             Encoding::InvalidByteSequenceError,
+             JSON::GeneratorError => e
+        log_error(e)
+        force_utf8_encoding(event).to_json
       end
     end
   end

data/lib/logstash-logger/formatter/json_lines.rb

@@ -4,7 +4,20 @@ module LogStashLogger
       private
 
       def format_event(event)
+        # Proactively check for encoding issues to handle cross-platform differences.
+        # Some Ruby implementations (e.g., JRuby) may not raise exceptions during
+        # JSON encoding but produce malformed output instead.
+        if message_has_encoding_issue?(event)
+          log_error(Encoding::InvalidByteSequenceError.new("Invalid encoding in message"))
+          return "#{force_utf8_encoding(event).to_json}\n"
+        end
+
         "#{event.to_json}\n"
+      rescue Encoding::UndefinedConversionError,
+             Encoding::InvalidByteSequenceError,
+             JSON::GeneratorError => e
+        log_error(e)
+        "#{force_utf8_encoding(event).to_json}\n"
       end
     end
   end

data/lib/logstash-logger/formatter.rb

@@ -10,20 +10,20 @@ module LogStashLogger
     autoload :Cee, 'logstash-logger/formatter/cee'
     autoload :CeeSyslog, 'logstash-logger/formatter/cee_syslog'
 
-    def self.new(formatter_type, customize_event: nil)
-      build_formatter(formatter_type, customize_event)
+    def self.new(formatter_type, customize_event: nil, error_logger: LogStashLogger.configuration.default_error_logger)
+      build_formatter(formatter_type, customize_event, error_logger)
     end
 
-    def self.build_formatter(formatter_type, customize_event)
+    def self.build_formatter(formatter_type, customize_event, error_logger)
       formatter_type ||= DEFAULT_FORMATTER
 
       formatter = if custom_formatter_instance?(formatter_type)
         formatter_type
       elsif custom_formatter_class?(formatter_type)
-        formatter_type.new
+        initialize_custom_formatter_klass(formatter_type, customize_event)
       else
-        formatter_klass(formatter_type).new(customize_event: customize_event)
-      end
+        formatter_klass(formatter_type).new(customize_event: customize_event, error_logger: error_logger)
+                  end
 
       formatter.send(:extend, ::LogStashLogger::TaggedLogging::Formatter)
       formatter
@@ -47,5 +47,13 @@ module LogStashLogger
     def self.custom_formatter_class?(formatter_type)
       formatter_type.is_a?(Class) && formatter_type.method_defined?(:call)
     end
+
+    def self.initialize_custom_formatter_klass(formatter_klass, customize_event)
+      if formatter_klass.instance_method(:initialize).parameters.include?([:key, :customize_event])
+        formatter_klass.new(customize_event: customize_event)
+      else
+        formatter_klass.new
+      end
+    end
 	end
 end

data/lib/logstash-logger/logger.rb

@@ -26,31 +26,19 @@ module LogStashLogger
     end
   end
 
-  protected
 
   def self.extract_opts(*args)
-    args.flatten!
-
-    if args.length > 1
-      if args.all?{|arg| arg.is_a?(Hash)}
-        # Deprecated array of hashes
-        warn "[LogStashLogger] Passing an array of hashes to the constructor is deprecated. Please replace with an options hash: { type: :multi_delegator, outputs: [...] }"
-        { type: :multi_delegator, outputs: args }
-      else
-        # Deprecated host/port/type constructor
-        warn "[LogStashLogger] The (host, port, type) constructor is deprecated. Please use an options hash instead."
-        host, port, type = *args
-        { host: host, port: port, type: type }
-      end
-    elsif Hash === args[0]
+    if args.length == 1 && args[0].is_a?(Hash)
       args[0]
     else
-      fail ArgumentError, "Invalid LogStashLogger options"
+      fail ArgumentError, "Invalid LogStashLogger options. Expected a single options hash."
     end
   end
 
   def self.build_logger(opts)
-    formatter = Formatter.new(opts.delete(:formatter), customize_event: opts.delete(:customize_event))
+    formatter = Formatter.new(opts.delete(:formatter),
+                              customize_event: opts.delete(:customize_event),
+                              error_logger: opts.fetch(:error_logger, LogStashLogger.configuration.default_error_logger))
 
     logger_type = opts[:type].to_s.to_sym
     logger = case logger_type
@@ -60,13 +48,12 @@ module LogStashLogger
       build_syslog_logger(opts)
     else
       build_default_logger(opts)
-    end
+             end
 
     logger.formatter = formatter if formatter
     logger
   end
 
-  private
 
   def self.build_default_logger(opts)
     logger_class = opts.delete(:logger_class) || ::Logger

data/lib/logstash-logger/multi_logger.rb

@@ -70,7 +70,7 @@ module LogStashLogger
     def method_missing(name, *args, &block)
       @loggers.each do |logger|
         if logger.respond_to?(name)
-          logger.send(name, args, &block)
+          logger.send(name, *args, &block)
         end
       end
     end
@@ -101,6 +101,7 @@ module LogStashLogger
         logger.add(severity, message, progname, &block)
       end
     end
+    alias log add
 
     def <<(msg)
       @loggers.each do |logger|

data/lib/logstash-logger/railtie.rb

@@ -25,7 +25,7 @@ module LogStashLogger
     # Convert logger options to OrderedOptions if regular Hash
     logger_options = ActiveSupport::OrderedOptions.new.merge(logger_options)
 
-    if parsed_uri_options = LogStashLogger::Device.parse_uri_config(logger_options)
+    if (parsed_uri_options = LogStashLogger::Device.parse_uri_config(logger_options))
       logger_options.delete(:uri)
       logger_options.merge!(parsed_uri_options)
     end

data/lib/logstash-logger/tagged_logging.rb

@@ -19,7 +19,9 @@ module LogStashLogger
       end
 
       def push_tags(*tags)
-        tags.flatten.reject{ |t| t.nil? || t.empty? }.tap do |new_tags|
+        non_empty_tags = tags.flatten.compact.reject { |t| t.respond_to?(:empty?) && t.empty? }
+
+        non_empty_tags.tap do |new_tags|
           current_tags.concat new_tags
         end
       end

data/lib/logstash-logger/version.rb

@@ -1,3 +1,3 @@
 module LogStashLogger
-  VERSION = "0.26.1"
+  VERSION = "1.0.0"
 end

data/logstash-logger.gemspec

@@ -22,12 +22,14 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'rails'
   gem.add_development_dependency 'redis'
-  gem.add_development_dependency 'poseidon'
+  gem.add_development_dependency 'ruby-kafka'
   gem.add_development_dependency 'aws-sdk-kinesis'
   gem.add_development_dependency 'aws-sdk-firehose'
 
   if defined?(JRUBY_VERSION)
     gem.add_development_dependency 'SyslogLogger'
+  else
+    gem.add_development_dependency 'syslog'
   end
 
   gem.add_development_dependency 'rspec', '>= 3'
@@ -36,4 +38,10 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'wwtd'
   gem.add_development_dependency 'appraisal'
   gem.add_development_dependency 'rubocop'
+  gem.add_development_dependency 'rubocop-performance'
+  gem.add_development_dependency 'rubocop-rails'
+  gem.add_development_dependency 'rubocop-rake'
+  gem.add_development_dependency 'rubocop-rspec'
+
+  gem.required_ruby_version = '>= 3.2'
 end

data/spec/device/file_spec.rb

@@ -7,6 +7,71 @@ describe LogStashLogger::Device::File do
     expect(file_device.to_io).to be_a ::File
   end
 
+  context "with shift options" do
+    let(:shift_file) do
+      temp = Tempfile.new('logstash_shift')
+      temp.close
+      temp
+    end
+
+    let(:shift_device) do
+      LogStashLogger::Device.new(
+        type: :file,
+        path: shift_file.path,
+        shift_age: 1,
+        shift_size: 1
+      )
+    end
+
+    let(:period_file) do
+      temp = Tempfile.new('logstash_period_shift')
+      temp.close
+      temp
+    end
+
+    let(:period_device) do
+      LogStashLogger::Device.new(
+        type: :file,
+        path: period_file.path,
+        shift_age: 'daily',
+        shift_period_suffix: '%Y-%m-%d'
+      )
+    end
+
+    after do
+      shift_device.close
+      ::Dir.glob("#{shift_file.path}*").each do |path|
+        ::File.delete(path) if ::File.exist?(path)
+      end
+
+      period_device.close
+      ::Dir.glob("#{period_file.path}*").each do |path|
+        ::File.delete(path) if ::File.exist?(path)
+      end
+    end
+
+    it "wraps a Logger::LogDevice for rotation" do
+      expect(shift_device.io).to be_a ::Logger::LogDevice
+      expect(shift_device.to_io).to be_a ::File
+    end
+
+    it "rotates when shift_size is exceeded" do
+      shift_device.write("a" * 10)
+      shift_device.write("b" * 10)
+      shift_device.close
+
+      expect(::File.exist?("#{shift_file.path}.0")).to be(true)
+    end
+
+    it "uses shift_period_suffix for time-based rotation" do
+      period_device.write("a")
+      period_device.io.send(:shift_log_period, Time.new(2026, 1, 22))
+      period_device.close
+
+      expect(::File.exist?("#{period_file.path}.2026-01-22")).to be(true)
+    end
+  end
+
   context "when path is not specified" do
     it "raises an exception" do
       expect { described_class.new }.to raise_error(ArgumentError)

data/spec/device/http_spec.rb

@@ -0,0 +1,11 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::HTTP do
+  include_context 'device'
+
+  it "Post event to HTTP" do
+    expect(Net::HTTP).to receive(:post)
+    http_device.write('test')
+  end
+
+end