lumberjack 1.0.13 → 1.2.8

data/lib/lumberjack/context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  # A context is used to store tags that are then added to all log entries within a block.
+  class Context
+    attr_reader :tags
+
+    def initialize(parent_context = nil)
+      @tags = {}
+      @tags.merge!(parent_context.tags) if parent_context
+    end
+
+    # Set tags on the context.
+    def tag(tags)
+      tags.each do |key, value|
+        @tags[key.to_s] = value
+      end
+    end
+
+    # Get a context tag.
+    def [](key)
+      @tags[key.to_s]
+    end
+
+    # Set a context tag.
+    def []=(key, value)
+      @tags[key.to_s] = value
+    end
+
+    # Clear all the context data.
+    def reset
+      @tags.clear
+    end
+  end
+end

data/lib/lumberjack/device.rb

@@ -4,25 +4,39 @@ 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 File.expand_path("../device/writer.rb", __FILE__)
-    require File.expand_path("../device/log_file.rb", __FILE__)
-    require File.expand_path("../device/rolling_log_file.rb", __FILE__)
-    require File.expand_path("../device/date_rolling_log_file.rb", __FILE__)
-    require File.expand_path("../device/size_rolling_log_file.rb", __FILE__)
-    require File.expand_path("../device/null.rb", __FILE__)
+    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.
     def write(entry)
       raise NotImplementedError
     end
-    
+
     # Subclasses may implement this method to close the device.
     def close
       flush
     end
-    
+
+    # Subclasses may implement this method to reopen the device.
+    def reopen(logdev = nil)
+      flush
+    end
+
     # Subclasses may implement this method to flush any buffers used by the device.
     def flush
     end
+
+    # Subclasses may implement this method to get the format for log timestamps.
+    def datetime_format
+    end
+
+    # Subclasses may implement this method to set a format for log timestamps.
+    def datetime_format=(format)
+    end
   end
 end

data/lib/lumberjack/device/date_rolling_log_file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literals: true
 
-require 'date'
+require "date"
 
 module Lumberjack
   class Device
@@ -11,12 +11,12 @@ module Lumberjack
     # roll period as buffered entries will always be written to the same file.
     class DateRollingLogFile < RollingLogFile
       # Create a new logging device to the specified file. The period to roll the file is specified
-      # with the <tt>:roll</tt> option which may contain a value of <tt>:daily</tt>, <tt>:weekly</tt>,
-      # or <tt>:monthly</tt>.
+      # with the :roll option which may contain a value of :daily, :weekly,
+      # or :monthly.
       def initialize(path, options = {})
         @manual = options[:manual]
         @file_date = Date.today
-        if options[:roll] && options[:roll].to_s.match(/(daily)|(weekly)|(monthly)/i)
+        if options[:roll]&.to_s&.match(/(daily)|(weekly)|(monthly)/i)
           @roll_period = $~[0].downcase.to_sym
           options.delete(:roll)
         else
@@ -28,11 +28,11 @@ module Lumberjack
       def archive_file_suffix
         case @roll_period
         when :weekly
-          "#{@file_date.strftime('week-of-%Y-%m-%d')}"
+          @file_date.strftime("week-of-%Y-%m-%d").to_s
         when :monthly
-          "#{@file_date.strftime('%Y-%m')}"
+          @file_date.strftime("%Y-%m").to_s
         else
-          "#{@file_date.strftime('%Y-%m-%d')}"
+          @file_date.strftime("%Y-%m-%d").to_s
         end
       end
 
@@ -54,9 +54,9 @@ module Lumberjack
           end
         end
       end
-      
+
       protected
-      
+
       def after_roll
         @file_date = Date.today
       end

data/lib/lumberjack/device/log_file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literals: true
 
-require 'fileutils'
+require "fileutils"
 
 module Lumberjack
   class Device
@@ -10,12 +10,23 @@ module Lumberjack
 
       # The absolute path of the file being logged to.
       attr_reader :path
-      
+
       # Create a logger to the file at +path+. Options are passed through to the Writer constructor.
       def initialize(path, options = {})
         @path = File.expand_path(path)
         FileUtils.mkdir_p(File.dirname(@path))
-        super(File.new(@path, 'a', :encoding => EXTERNAL_ENCODING), options)
+        super(file_stream, options)
+      end
+
+      def reopen(logdev = nil)
+        close
+        @stream = file_stream
+      end
+
+      private
+
+      def file_stream
+        File.new(@path, "a", encoding: EXTERNAL_ENCODING)
       end
     end
   end

data/lib/lumberjack/device/multi.rb

@@ -0,0 +1,46 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Device
+    # This is a logging device that forward log entries to multiple other devices.
+    class Multi < Device
+      def initialize(*devices)
+        @devices = devices.flatten
+      end
+
+      def write(entry)
+        @devices.each do |device|
+          device.write(entry)
+        end
+      end
+
+      def flush
+        @devices.each do |device|
+          device.flush
+        end
+      end
+
+      def close
+        @devices.each do |device|
+          device.close
+        end
+      end
+
+      def reopen(logdev = nil)
+        @devices.each do |device|
+          device.reopen(logdev = nil)
+        end
+      end
+
+      def datetime_format
+        @devices.detect(&:datetime_format).datetime_format
+      end
+
+      def datetime_format=(format)
+        @devices.each do |device|
+          device.datetime_format = format
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/device/null.rb

@@ -1,7 +1,5 @@
 # frozen_string_literals: true
 
-require 'date'
-
 module Lumberjack
   class Device
     # This is a logging device that produces no output. It can be useful in
@@ -9,7 +7,7 @@ module Lumberjack
     class Null < Device
       def initialize(*args)
       end
-      
+
       def write(entry)
       end
     end

data/lib/lumberjack/device/rolling_log_file.rb

@@ -6,43 +6,51 @@ module Lumberjack
     # the existing file and starts a one. Subclasses must implement the roll_file? and archive_file_suffix
     # methods.
     #
-    # The <tt>:keep</tt> option can be used to specify a maximum number of rolled log files to keep.
+    # The :keep option can be used to specify a maximum number of rolled log files to keep.
     # Older files will be deleted based on the time they were created. The default is to keep all files.
     #
-    # The <tt>:min_roll_check</tt> option can be used to specify the number of seconds between checking
+    # The :min_roll_check option can be used to specify the number of seconds between checking
     # the file to determine if it needs to be rolled. The default is to check at most once per second.
     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
+        @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:
         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

@@ -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 <tt>:max_size</tt> option. The unit can also be specified: "32K", "100M", "2G" are all valid.
+      # 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

@@ -4,58 +4,62 @@ module Lumberjack
   class Device
     # This logging device writes log entries as strings to an IO stream. By default, messages will be buffered
     # and written to the stream in a batch when the buffer is full or when +flush+ is called.
+    #
+    # Subclasses can implement a +before_flush+ method if they have logic to execute before flushing the log.
+    # If it is implemented, it will be called before every flush inside a mutex lock.
     class Writer < Device
-      DEFAULT_FIRST_LINE_TEMPLATE = "[:time :severity :progname(:pid) #:unit_of_work_id] :message".freeze
-      DEFAULT_ADDITIONAL_LINES_TEMPLATE = "#{Lumberjack::LINE_SEPARATOR}> [#:unit_of_work_id] :message".freeze
+      DEFAULT_FIRST_LINE_TEMPLATE = "[:time :severity :progname(:pid) #:unit_of_work_id] :message :tags"
+      DEFAULT_ADDITIONAL_LINES_TEMPLATE = "#{Lumberjack::LINE_SEPARATOR}> [#:unit_of_work_id] :message"
 
       # The size of the internal buffer. Defaults to 32K.
       attr_reader :buffer_size
-      
+
       # Internal buffer to batch writes to the stream.
       class Buffer # :nodoc:
         attr_reader :size
-        
+
         def initialize
           @values = []
           @size = 0
         end
-        
+
         def <<(string)
           @values << string
           @size += string.size
         end
-        
+
         def empty?
           @values.empty?
         end
-        
+
         def pop!
+          return nil if @values.empty?
           popped = @values
           clear
           popped
         end
-        
+
         def clear
           @values = []
           @size = 0
         end
       end
-      
+
       # Create a new device to write log entries to a stream. Entries are converted to strings
-      # using a Template. The template can be specified using the <tt>:template</tt> option. This can
+      # using a Template. The template can be specified using the :template option. This can
       # either be a Proc or a string that will compile into a Template object.
       #
       # If the template is a Proc, it should accept an LogEntry as its only argument and output a string.
       #
       # If the template is a template string, it will be used to create a Template. The
-      # <tt>:additional_lines</tt> and <tt>:time_format</tt> options will be passed through to the
+      # :additional_lines and :time_format options will be passed through to the
       # Template constuctor.
       #
-      # The default template is <tt>"[:time :severity :progname(:pid) #:unit_of_work_id] :message"</tt>
-      # with additional lines formatted as <tt>"\n [#:unit_of_work_id] :message"</tt>. The unit of
+      # 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 size of the internal buffer in bytes can be set by providing <tt>:buffer_size</tt> (defaults to 32K).
+      # The size of the internal buffer in bytes can be set by providing :buffer_size (defaults to 32K).
       def initialize(stream, options = {})
         @lock = Mutex.new
         @stream = stream
@@ -67,84 +71,111 @@ module Lumberjack
           @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])
+          @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.
       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.
       def write(entry)
-        string = @template.call(entry)
-        unless string.nil?
-          string = string.encode("UTF-8".freeze, invalid: :replace, undef: :replace)
+        string = (entry.is_a?(LogEntry) ? @template.call(entry) : entry)
+        return if string.nil?
+        string = string.strip
+        return if string.length == 0
+
+        unless string.encoding == Encoding::UTF_8
+          string = string.encode("UTF-8", invalid: :replace, undef: :replace)
+        end
+
+        if buffer_size > 1
           @lock.synchronize do
             @buffer << string
           end
+          flush if @buffer.size >= buffer_size
+        else
+          flush if respond_to?(:before_flush, true)
+          write_to_stream(string)
         end
-        flush if @buffer.size >= buffer_size
       end
-      
+
       # Close the underlying stream.
       def close
         flush
         stream.close
       end
-      
+
       # Flush the underlying stream.
       def flush
         lines = nil
         @lock.synchronize do
-          before_flush
+          before_flush if respond_to?(:before_flush, true)
           lines = @buffer.pop!
         end
-        
-        unless lines.empty?
-          out = "#{lines.join(Lumberjack::LINE_SEPARATOR)}#{Lumberjack::LINE_SEPARATOR}"
-          begin
-            begin
-              stream.write(out)
-            rescue IOError => e
-              # This condition can happen if another thread closed the stream in the `before_flush` call.
-              # Synchronizing will handle the race condition, but since it's an exceptional case we don't
-              # to lock the thread on every stream write call.
-              @lock.synchronize do
-                if stream.closed?
-                  raise e
-                else
-                  stream.write(out)
-                end
-              end
-            end
-            stream.flush rescue nil
-          rescue => e
-            $stderr.write("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
-            $stderr.write(out)
-            $stderr.flush
-          end
+        write_to_stream(lines) if lines
+      end
+
+      def datetime_format
+        @template.datetime_format if @template.respond_to?(:datetime_format)
+      end
+
+      def datetime_format=(format)
+        if @template.respond_to?(:datetime_format=)
+          @template.datetime_format = format
         end
       end
-      
+
       protected
-      
-      # Callback method that will be executed before data is written to the stream. Subclasses
-      # can override this method if needed. This method will be called in a mutex lock.
-      def before_flush
-      end
-      
+
       # Set the underlying stream.
-      def stream=(stream)
-        @stream = stream
-      end
-      
+      attr_writer :stream
+
       # Get the underlying stream.
-      def stream
-        @stream
+      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
+        out = if lines.is_a?(Array)
+          "#{lines.join(Lumberjack::LINE_SEPARATOR)}#{Lumberjack::LINE_SEPARATOR}"
+        else
+          "#{lines}#{Lumberjack::LINE_SEPARATOR}"
+        end
+
+        begin
+          begin
+            stream.write(out)
+          rescue IOError => e
+            # This condition can happen if another thread closed the stream in the `before_flush` call.
+            # Synchronizing will handle the race condition, but since it's an exceptional case we don't
+            # want to lock the thread on every stream write call.
+            @lock.synchronize do
+              if stream.closed?
+                raise e
+              else
+                stream.write(out)
+              end
+            end
+          end
+          begin
+            stream.flush
+          rescue
+            nil
+          end
+        rescue => e
+          $stderr.write("#{e.class.name}: #{e.message}#{" at " + e.backtrace.first if e.backtrace}")
+          $stderr.write(out)
+          $stderr.flush
+        end
       end
     end
   end