lumberjack 1.0.13 → 1.1.0

data/lib/lumberjack/device/date_rolling_log_file.rb

@@ -11,8 +11,8 @@ 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

data/lib/lumberjack/device/log_file.rb

@@ -15,7 +15,18 @@ module Lumberjack
       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
+      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

data/lib/lumberjack/device/rolling_log_file.rb

@@ -6,10 +6,10 @@ 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

data/lib/lumberjack/device/size_rolling_log_file.rb

@@ -10,7 +10,7 @@ module Lumberjack
       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]

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
@@ -70,82 +74,109 @@ module Lumberjack
           @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
-      
+
       # Get the underlying stream.
       def stream
         @stream
       end
+
+      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}"
+        else
+          out = "#{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
+          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
+      end
     end
   end
 end

data/lib/lumberjack/formatter.rb

@@ -1,33 +1,45 @@
 # frozen_string_literals: true
 
 module Lumberjack
-  # This class controls the conversion of log entry messages into strings. This allows you
-  # to log any object you want and have the logging system worry about converting it into a string.
+  # This class controls the conversion of log entry messages into a loggable format. This allows you
+  # to log any object you want and have the logging system deal with converting it into a string.
   #
   # Formats are added to a Formatter by associating them with a class using the +add+ method. Formats
   # are any object that responds to the +call+ method.
   #
   # By default, all object will be converted to strings using their inspect method except for Strings
   # and Exceptions. Strings are not converted and Exceptions are converted using the ExceptionFormatter.
+  #
+  # Enumerable objects (including Hash and Array) will call the formatter recursively for each element.
   class Formatter
-    require File.expand_path("../formatter/exception_formatter.rb", __FILE__)
-    require File.expand_path("../formatter/inspect_formatter.rb", __FILE__)
-    require File.expand_path("../formatter/pretty_print_formatter.rb", __FILE__)
-    require File.expand_path("../formatter/string_formatter.rb", __FILE__)
-    
+    require_relative "formatter/date_time_formatter.rb"
+    require_relative "formatter/exception_formatter.rb"
+    require_relative "formatter/id_formatter.rb"
+    require_relative "formatter/inspect_formatter.rb"
+    require_relative "formatter/object_formatter.rb"
+    require_relative "formatter/pretty_print_formatter.rb"
+    require_relative "formatter/string_formatter.rb"
+    require_relative "formatter/structured_formatter.rb"
+
     def initialize
       @class_formatters = {}
+      @module_formatters = {}
       @_default_formatter = InspectFormatter.new
+      structured_formatter = StructuredFormatter.new(self)
+      add(String, :object)
+      add(Numeric, :object)
+      add(TrueClass, :object)
+      add(FalseClass, :object)
       add(Object, @_default_formatter)
-      add(String, :string)
       add(Exception, :exception)
+      add(Enumerable, structured_formatter)
     end
-    
+
     # Add a formatter for a class. The formatter can be specified as either an object
     # that responds to the +call+ method or as a symbol representing one of the predefined
     # formatters, or as a block to the method call.
     #
-    # The predefined formatters are: <tt>:inspect</tt>, <tt>:string</tt>, <tt>:exception</tt>, and <tt>:pretty_print</tt>.
+    # The predefined formatters are: :inspect, :string, :exception, and :pretty_print.
     #
     # === Examples
     #
@@ -48,33 +60,57 @@ module Lumberjack
         formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/){|m| $~[2].upcase}}Formatter"
         formatter = Formatter.const_get(formatter_class_name).new
       end
-      @class_formatters[klass] = formatter
+      if klass.is_a?(Class)
+        @class_formatters[klass] = formatter
+      else
+        @module_formatters[klass] = formatter
+      end
       self
     end
-    
+
     # Remove the formatter associated with a class. Remove statements can be chained together.
     def remove(klass)
-      @class_formatters.delete(klass)
+      if klass.is_a?(Class)
+        @class_formatters.delete(klass)
+      else
+        @module_formatters.delete(klass)
+      end
       self
     end
     
+    # Remove all formatters including the default formatter. Can be chained to add method calls.
+    def clear
+      @class_formatters.clear
+      @module_formatters.clear
+      self
+    end
+
     # Format a message object as a string.
     def format(message)
       formatter_for(message.class).call(message)
     end
-    
-    # Hack for compatibility with Logger::Formatter
+
+    # Compatibility with the Logger::Formatter signature. This method will just convert the message
+    # object to a string and ignores the other parameters.
     def call(severity, timestamp, progname, msg)
-      "#{format(msg)}\n"
-    end    
+      "#{format(msg)}#{Lumberjack::LINE_SEPARATOR}"
+    end
 
     private
-    
+
     # Find the formatter for a class by looking it up using the class hierarchy.
     def formatter_for(klass) #:nodoc:
+      check_modules = true
       while klass != nil do
         formatter = @class_formatters[klass]
         return formatter if formatter
+
+        if check_modules
+          _, formatter = @module_formatters.detect { |mod, f| klass.include?(mod) }
+          check_modules = false
+          return formatter if formatter
+        end
+
         klass = klass.superclass
       end
       @_default_formatter