lumberjack 1.2.7 → 1.4.2

data/lib/lumberjack/device/rolling_log_file.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device
@@ -14,35 +14,43 @@ module Lumberjack
     class RollingLogFile < LogFile
       attr_reader :path
       attr_accessor :keep
-      
+
       def initialize(path, options = {})
         @path = File.expand_path(path)
         @keep = options[:keep]
-        super(path, options)
-        @file_inode = stream.lstat.ino rescue nil
+        super
+        @file_inode = begin
+          stream.lstat.ino
+        rescue
+          nil
+        end
         @@rolls = []
         @next_stat_check = Time.now.to_f
         @min_roll_check = (options[:min_roll_check] || 1.0).to_f
       end
-      
+
       # Returns a suffix that will be appended to the file name when it is archived.. The suffix should
       # change after it is time to roll the file. The log file will be renamed when it is rolled.
       def archive_file_suffix
         raise NotImplementedError
       end
-      
+
       # Return +true+ if the file should be rolled.
       def roll_file?
         raise NotImplementedError
       end
-      
+
       # Roll the log file by renaming it to the archive file name and then re-opening a stream to the log
       # file path. Rolling a file is safe in multi-threaded or multi-process environments.
-      def roll_file! #:nodoc:
+      def roll_file! # :nodoc:
         do_once(stream) do
           archive_file = "#{path}.#{archive_file_suffix}"
           stream.flush
-          current_inode = File.stat(path).ino rescue nil
+          current_inode = begin
+            File.stat(path).ino
+          rescue
+            nil
+          end
           if @file_inode && current_inode == @file_inode && !File.exist?(archive_file) && File.exist?(path)
             begin
               File.rename(path, archive_file)
@@ -59,41 +67,49 @@ module Lumberjack
       end
 
       protected
-      
+
       # This method will be called after a file has been rolled. Subclasses can
       # implement code to reset the state of the device. This method is thread safe.
       def after_roll
       end
-      
+
       # Handle rolling the file before flushing.
       def before_flush # :nodoc:
         if @min_roll_check <= 0.0 || Time.now.to_f >= @next_stat_check
           @next_stat_check += @min_roll_check
-          path_inode = File.lstat(path).ino rescue nil
+          path_inode = begin
+            File.lstat(path).ino
+          rescue
+            nil
+          end
           if path_inode != @file_inode
             @file_inode = path_inode
             reopen_file
-          else
-            roll_file! if roll_file?
+          elsif roll_file?
+            roll_file!
           end
         end
       end
-      
+
       private
 
       def reopen_file
         old_stream = stream
-        new_stream = File.open(path, 'a', encoding: EXTERNAL_ENCODING)
+        new_stream = File.open(path, "a", encoding: EXTERNAL_ENCODING)
         new_stream.sync = true if buffer_size > 0
-        @file_inode = new_stream.lstat.ino rescue nil
+        @file_inode = begin
+          new_stream.lstat.ino
+        rescue
+          nil
+        end
         self.stream = new_stream
         old_stream.close
       end
     end
-    
+
     def cleanup_files!
       if keep
-        files = Dir.glob("#{path}.*").collect{|f| [f, File.ctime(f)]}.sort{|a,b| b.last <=> a.last}.collect{|a| a.first}
+        files = Dir.glob("#{path}.*").collect { |f| [f, File.ctime(f)] }.sort { |a, b| b.last <=> a.last }.collect { |a| a.first }
         if files.size > keep
           files[keep, files.length].each do |f|
             File.delete(f)
@@ -101,7 +117,7 @@ module Lumberjack
         end
       end
     end
-    
+
     def do_once(file)
       begin
         file.flock(File::LOCK_EX)
@@ -110,11 +126,19 @@ module Lumberjack
         return
       end
       begin
-        verify = file.lstat rescue nil
+        verify = begin
+          file.lstat
+        rescue
+          nil
+        end
         # Execute only if the file we locked is still the same one that needed to be rolled
         yield if verify && verify.ino == @file_inode && verify.size > 0
       ensure
-        file.flock(File::LOCK_UN) rescue nil
+        begin
+          file.flock(File::LOCK_UN)
+        rescue
+          nil
+        end
       end
     end
   end

data/lib/lumberjack/device/size_rolling_log_file.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device
@@ -8,30 +8,30 @@ module Lumberjack
     # production.log.1, then production.log.2, etc.
     class SizeRollingLogFile < RollingLogFile
       attr_reader :max_size
-      
+
       # Create an new log device to the specified file. The maximum size of the log file is specified with
       # the :max_size option. The unit can also be specified: "32K", "100M", "2G" are all valid.
       def initialize(path, options = {})
         @manual = options[:manual]
         @max_size = options[:max_size]
         if @max_size.is_a?(String)
-          if @max_size.match(/^(\d+(\.\d+)?)([KMG])?$/i)
+          if @max_size =~ /^(\d+(\.\d+)?)([KMG])?$/i
             @max_size = $~[1].to_f
             units = $~[3].to_s.upcase
             case units
             when "K"
               @max_size *= 1024
             when "M"
-              @max_size *= 1024 ** 2
+              @max_size *= 1024**2
             when "G"
-              @max_size *= 1024 ** 3
+              @max_size *= 1024**3
             end
             @max_size = @max_size.round
           else
             raise ArgumentError.new("illegal value for :max_size (#{@max_size})")
           end
         end
-        
+
         super
       end
 
@@ -44,15 +44,15 @@ module Lumberjack
       rescue SystemCallError
         false
       end
-      
+
       protected
-      
+
       # Calculate the next archive file name extension.
       def next_archive_number # :nodoc:
         max = 0
         Dir.glob("#{path}.*").each do |filename|
-          if filename.match(/\.\d+$/)
-            suffix = filename.split('.').last.to_i
+          if /\.\d+\z/ =~ filename
+            suffix = filename.split(".").last.to_i
             max = suffix if suffix > max
           end
         end

data/lib/lumberjack/device/writer.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Device
@@ -55,34 +55,42 @@ module Lumberjack
       # :additional_lines and :time_format options will be passed through to the
       # Template constuctor.
       #
-      # The default template is "[:time :severity :progname(:pid) #:unit_of_work_id] :message"
-      # with additional lines formatted as "\n [#:unit_of_work_id] :message". The unit of
-      # work id will only appear if it is present.
+      # The default template is "[:time :severity :progname(:pid)] :message"
+      # with additional lines formatted as "\n  :message".
       #
       # The size of the internal buffer in bytes can be set by providing :buffer_size (defaults to 32K).
+      #
+      # @param [IO] stream The stream to write log entries to.
+      # @param [Hash] options The options for the device.
       def initialize(stream, options = {})
         @lock = Mutex.new
         @stream = stream
         @stream.sync = true if @stream.respond_to?(:sync=)
         @buffer = Buffer.new
-        @buffer_size = (options[:buffer_size] || 0)
-        template = (options[:template] || DEFAULT_FIRST_LINE_TEMPLATE)
+        @buffer_size = options[:buffer_size] || 0
+        template = options[:template] || DEFAULT_FIRST_LINE_TEMPLATE
         if template.respond_to?(:call)
           @template = template
         else
-          additional_lines = (options[:additional_lines] || DEFAULT_ADDITIONAL_LINES_TEMPLATE)
-          @template = Template.new(template, :additional_lines => additional_lines, :time_format => options[:time_format])
+          additional_lines = options[:additional_lines] || DEFAULT_ADDITIONAL_LINES_TEMPLATE
+          @template = Template.new(template, additional_lines: additional_lines, time_format: options[:time_format])
         end
       end
 
       # Set the buffer size in bytes. The device will only be physically written to when the buffer size
       # is exceeded.
+      #
+      # @param [Integer] value The size of the buffer in bytes.
+      # @return [void]
       def buffer_size=(value)
         @buffer_size = value
         flush
       end
 
       # Write an entry to the stream. The entry will be converted into a string using the defined template.
+      #
+      # @param [LogEntry, String] entry The entry to write to the stream.
+      # @return [void]
       def write(entry)
         string = (entry.is_a?(LogEntry) ? @template.call(entry) : entry)
         return if string.nil?
@@ -105,12 +113,16 @@ module Lumberjack
       end
 
       # Close the underlying stream.
+      #
+      # @return [void]
       def close
         flush
         stream.close
       end
 
       # Flush the underlying stream.
+      #
+      # @return [void]
       def flush
         lines = nil
         @lock.synchronize do
@@ -120,39 +132,47 @@ module Lumberjack
         write_to_stream(lines) if lines
       end
 
+      # Get the datetime format.
+      #
+      # @return [String] The datetime format.
       def datetime_format
         @template.datetime_format if @template.respond_to?(:datetime_format)
       end
 
+      # Set the datetime format.
+      #
+      # @param [String] format The datetime format.
+      # @return [void]
       def datetime_format=(format)
         if @template.respond_to?(:datetime_format=)
           @template.datetime_format = format
         end
       end
 
+      # Return the underlying stream. Provided for API compatibility with Logger devices.
+      #
+      # @return [IO] The underlying stream.
+      def dev
+        @stream
+      end
+
       protected
 
       # Set the underlying stream.
-      def stream=(stream)
-        @stream = stream
-      end
+      attr_writer :stream
 
       # Get the underlying stream.
-      def stream
-        @stream
-      end
+      attr_reader :stream
 
       private
 
       def write_to_stream(lines)
         return if lines.empty?
         lines = lines.first if lines.is_a?(Array) && lines.size == 1
-
-        out = nil
-        if lines.is_a?(Array)
-          out = "#{lines.join(Lumberjack::LINE_SEPARATOR)}#{Lumberjack::LINE_SEPARATOR}"
+        out = if lines.is_a?(Array)
+          "#{lines.join(Lumberjack::LINE_SEPARATOR)}#{Lumberjack::LINE_SEPARATOR}"
         else
-          out = "#{lines}#{Lumberjack::LINE_SEPARATOR}"
+          "#{lines}#{Lumberjack::LINE_SEPARATOR}"
         end
 
         begin
@@ -170,9 +190,13 @@ module Lumberjack
               end
             end
           end
-          stream.flush rescue nil
+          begin
+            stream.flush
+          rescue
+            nil
+          end
         rescue => e
-          $stderr.write("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
+          $stderr.write("#{e.class.name}: #{e.message}#{" at " + e.backtrace.first if e.backtrace}")
           $stderr.write(out)
           $stderr.flush
         end

data/lib/lumberjack/device.rb

@@ -1,41 +1,56 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   # This is an abstract class for logging devices. Subclasses must implement the +write+ method and
   # may implement the +close+ and +flush+ methods if applicable.
   class Device
-    require_relative "device/writer.rb"
-    require_relative "device/log_file.rb"
-    require_relative "device/rolling_log_file.rb"
-    require_relative "device/date_rolling_log_file.rb"
-    require_relative "device/size_rolling_log_file.rb"
-    require_relative "device/multi.rb"
-    require_relative "device/null.rb"
+    require_relative "device/writer"
+    require_relative "device/log_file"
+    require_relative "device/rolling_log_file"
+    require_relative "device/date_rolling_log_file"
+    require_relative "device/size_rolling_log_file"
+    require_relative "device/multi"
+    require_relative "device/null"
 
     # Subclasses must implement this method to write a LogEntry.
+    #
+    # @param [Lumberjack::LogEntry] entry The entry to write.
+    # @return [void]
     def write(entry)
       raise NotImplementedError
     end
-    
+
     # Subclasses may implement this method to close the device.
+    #
+    # @return [void]
     def close
       flush
     end
-    
+
     # Subclasses may implement this method to reopen the device.
+    #
+    # @param [Object] logdev The log device to use.
+    # @return [void]
     def reopen(logdev = nil)
       flush
     end
-    
+
     # Subclasses may implement this method to flush any buffers used by the device.
+    #
+    # @return [void]
     def flush
     end
-    
+
     # Subclasses may implement this method to get the format for log timestamps.
+    #
+    # @return [String] The format for log timestamps.
     def datetime_format
     end
-    
+
     # Subclasses may implement this method to set a format for log timestamps.
+    #
+    # @param [String] format The format for log timestamps.
+    # @return [void]
     def datetime_format=(format)
     end
   end

data/lib/lumberjack/formatter/date_time_formatter.rb

@@ -1,22 +1,22 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter
     # Format a Date, Time, or DateTime object. If you don't specify a format in the constructor,
     # it will use the ISO-8601 format.
     class DateTimeFormatter
-            
       attr_reader :format
-      
+
+      # @param [String] format The format to use when formatting the date/time object.
       def initialize(format = nil)
         @format = format.dup.to_s.freeze unless format.nil?
       end
-      
+
       def call(obj)
         if @format && obj.respond_to?(:strftime)
           obj.strftime(@format)
         elsif obj.respond_to?(:iso8601)
-          obj.iso8601
+          obj.iso8601(6)
         else
           obj.to_s
         end

data/lib/lumberjack/formatter/exception_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter
@@ -7,15 +7,16 @@ module Lumberjack
     # passed to this object and the returned array is what will be logged. You can
     # use this to clean out superfluous lines.
     class ExceptionFormatter
-
       attr_accessor :backtrace_cleaner
 
+      # @param [#call] backtrace_cleaner An object that responds to `call` and takes
+      #   an array of strings (the backtrace) and returns an array of strings (the
       def initialize(backtrace_cleaner = nil)
         self.backtrace_cleaner = backtrace_cleaner
       end
 
       def call(exception)
-        message = "#{exception.class.name}: #{exception.message}"
+        message = +"#{exception.class.name}: #{exception.message}"
         trace = exception.backtrace
         if trace
           trace = clean_backtrace(trace)
@@ -33,7 +34,6 @@ module Lumberjack
           trace
         end
       end
-
     end
   end
 end

data/lib/lumberjack/formatter/id_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter
@@ -6,14 +6,15 @@ module Lumberjack
     # as a default formatter for objects pulled from a data store. By default it will use :id as the
     # id attribute.
     class IdFormatter
+      # @param [Symbol, String] id_attribute The attribute to use as the id.
       def initialize(id_attribute = :id)
         @id_attribute = id_attribute
       end
-      
+
       def call(obj)
         if obj.respond_to?(@id_attribute)
           id = obj.send(@id_attribute)
-          { "class" => obj.class.name, "id" => id }
+          {"class" => obj.class.name, "id" => id}
         else
           obj.to_s
         end

data/lib/lumberjack/formatter/inspect_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/lib/lumberjack/formatter/multiply_formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  class Formatter
+    # This formatter can be used to multiply a numeric value by a specified multiplier and
+    # optionally round to a specified number of decimal places.
+    class MultiplyFormatter
+      # @param multiplier [Numeric] The multiplier to apply to the value.
+      # @param decimals [Integer, nil] The number of decimal places to round the result to.
+      #   If nil, no rounding is applied.
+      def initialize(multiplier, decimals = nil)
+        @multiplier = multiplier
+        @decimals = decimals
+      end
+
+      def call(value)
+        return value unless value.is_a?(Numeric)
+
+        value *= @multiplier
+        value = value.round(@decimals) if @decimals
+        value
+      end
+    end
+  end
+end

data/lib/lumberjack/formatter/object_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/lib/lumberjack/formatter/pretty_print_formatter.rb

@@ -1,20 +1,22 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
-require 'pp'
-require 'stringio'
+require "pp"
+require "stringio"
 
 module Lumberjack
   class Formatter
     # Format an object with it's pretty print method.
     class PrettyPrintFormatter
       attr_accessor :width
-      
+
       # Create a new formatter. The maximum width of the message can be specified with the width
       # parameter (defaults to 79 characters).
+      #
+      # @param [Integer] width The maximum width of the message.
       def initialize(width = 79)
         @width = width
       end
-      
+
       def call(obj)
         s = StringIO.new
         PP.pp(obj, s)

data/lib/lumberjack/formatter/redact_formatter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  class Formatter
+    # Log sensitive information in a redacted format showing the firat and last
+    # characters of the value, with the rest replaced by asterisks. The number of
+    # characters shown is dependent onthe length of the value; short values will
+    # not show any characters in order to avoid revealing too much information.
+    class RedactFormatter
+      def call(obj)
+        return obj unless obj.is_a?(String)
+
+        if obj.length > 8
+          "#{obj[0..1]}#{"*" * (obj.length - 4)}#{obj[-2..-1]}"
+        elsif obj.length > 5
+          "#{obj[0]}#{"*" * (obj.length - 2)}#{obj[-1]}"
+        else
+          "*****"
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/formatter/round_formatter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  class Formatter
+    # Round numeric values to a set number of decimal places. This is useful when logging
+    # floating point numbers to reduce noise and rounding errors in the logs.
+    class RoundFormatter
+      def initialize(precision = 3)
+        @precision = precision
+      end
+
+      def call(obj)
+        if obj.is_a?(Numeric)
+          obj.round(@precision)
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/formatter/string_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/lib/lumberjack/formatter/strip_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 module Lumberjack
   class Formatter

data/lib/lumberjack/formatter/structured_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literals: true
+# frozen_string_literal: true
 
 require "set"
 
@@ -9,6 +9,8 @@ module Lumberjack
       class RecusiveReferenceError < StandardError
       end
 
+      # @param [Formatter] formatter The formatter to call on each element
+      #   in the structure.
       def initialize(formatter = nil)
         @formatter = formatter
       end