lumberjack 1.2.4 → 1.2.8

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 :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

@@ -71,7 +71,7 @@ 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
 
@@ -133,14 +133,10 @@ module Lumberjack
       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
 
@@ -149,10 +145,10 @@ module Lumberjack
         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 +166,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/formatter.rb

@@ -12,15 +12,15 @@ module Lumberjack
   #
   # Enumerable objects (including Hash and Array) will call the formatter recursively for each element.
   class Formatter
-    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/strip_formatter.rb"
-    require_relative "formatter/structured_formatter.rb"
+    require_relative "formatter/date_time_formatter"
+    require_relative "formatter/exception_formatter"
+    require_relative "formatter/id_formatter"
+    require_relative "formatter/inspect_formatter"
+    require_relative "formatter/object_formatter"
+    require_relative "formatter/pretty_print_formatter"
+    require_relative "formatter/string_formatter"
+    require_relative "formatter/strip_formatter"
+    require_relative "formatter/structured_formatter"
 
     class << self
       # Returns a new empty formatter with no mapping. For historical reasons, a formatter
@@ -30,7 +30,7 @@ module Lumberjack
         new.clear
       end
     end
-    
+
     def initialize
       @class_formatters = {}
       @module_formatters = {}
@@ -72,10 +72,10 @@ module Lumberjack
         remove(klass)
       else
         if formatter.is_a?(Symbol)
-          formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/){|m| $~[2].upcase}}Formatter"
+          formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/) { |m| $~[2].upcase }}Formatter"
           formatter = Formatter.const_get(formatter_class_name).new
         end
-        
+
         Array(klass).each do |k|
           if k.class == Module
             @module_formatters[k] = formatter
@@ -106,7 +106,7 @@ module Lumberjack
       end
       self
     end
-    
+
     # Remove all formatters including the default formatter. Can be chained to add method calls.
     def clear
       @class_formatters.clear
@@ -117,7 +117,7 @@ module Lumberjack
     # Format a message object as a string.
     def format(message)
       formatter = formatter_for(message.class)
-      if formatter && formatter.respond_to?(:call)
+      if formatter&.respond_to?(:call)
         formatter.call(message)
       else
         message
@@ -135,7 +135,7 @@ module Lumberjack
     # 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
+      until klass.nil?
         formatter = @class_formatters[klass.name]
         return formatter if formatter
 

data/lib/lumberjack/formatter/date_time_formatter.rb

@@ -5,13 +5,12 @@ module Lumberjack
     # 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
-      
+
       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)

data/lib/lumberjack/formatter/exception_formatter.rb

@@ -7,7 +7,6 @@ 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
 
       def initialize(backtrace_cleaner = nil)
@@ -33,7 +32,6 @@ module Lumberjack
           trace
         end
       end
-
     end
   end
 end

data/lib/lumberjack/formatter/id_formatter.rb

@@ -9,11 +9,11 @@ module Lumberjack
       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/pretty_print_formatter.rb

@@ -1,20 +1,20 @@
 # frozen_string_literals: 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).
       def initialize(width = 79)
         @width = width
       end
-      
+
       def call(obj)
         s = StringIO.new
         PP.pp(obj, s)

data/lib/lumberjack/formatter/structured_formatter.rb

@@ -6,6 +6,9 @@ module Lumberjack
   class Formatter
     # Dereference arrays and hashes and recursively call formatters on each element.
     class StructuredFormatter
+      class RecusiveReferenceError < StandardError
+      end
+
       def initialize(formatter = nil)
         @formatter = formatter
       end
@@ -18,31 +21,43 @@ module Lumberjack
 
       def call_with_references(obj, references)
         if obj.is_a?(Hash)
-          hash = {}
-          references << obj.object_id
-          obj.each do |name, value|
-            next if references.include?(value.object_id)
-            references << value
-            hash[name.to_s] = call_with_references(value, references)
+          with_object_reference(obj, references) do
+            hash = {}
+            obj.each do |name, value|
+              value = call_with_references(value, references)
+              hash[name.to_s] = value unless value.is_a?(RecusiveReferenceError)
+            end
+            hash
           end
-          references.delete(obj.object_id)
-          hash
         elsif obj.is_a?(Enumerable) && obj.respond_to?(:size) && obj.size != Float::INFINITY
-          array = []
-          references << obj.object_id
-          obj.each do |value|
-            next if references.include?(value.object_id)
-            references << value
-            array << call_with_references(value, references)
+          with_object_reference(obj, references) do
+            array = []
+            obj.each do |value|
+              value = call_with_references(value, references)
+              array << value unless value.is_a?(RecusiveReferenceError)
+            end
+            array
           end
-          references.delete(obj.object_id)
-          array
         elsif @formatter
           @formatter.format(obj)
         else
           obj
         end
       end
+
+      def with_object_reference(obj, references)
+        if obj.is_a?(Enumerable)
+          return RecusiveReferenceError.new if references.include?(obj.object_id)
+          references << obj.object_id
+          begin
+            yield
+          ensure
+            references.delete(obj.object_id)
+          end
+        else
+          yield
+        end
+      end
     end
   end
 end

data/lib/lumberjack/log_entry.rb

@@ -17,10 +17,10 @@ module Lumberjack
       @progname = progname
       @pid = pid
       # backward compatibility with 1.0 API where the last argument was the unit of work id
-      if tags.nil? || tags.is_a?(Hash)
-        @tags = tags
+      @tags = if tags.nil? || tags.is_a?(Hash)
+        tags
       else
-        @tags = { UNIT_OF_WORK_ID => tags }
+        {UNIT_OF_WORK_ID => tags}
       end
     end
 
@@ -29,7 +29,7 @@ module Lumberjack
     end
 
     def to_s
-      "[#{time.strftime(TIME_FORMAT)}.#{(time.usec / 1000.0).round.to_s.rjust(3, '0')} #{severity_label} #{progname}(#{pid})#{tags_to_s}] #{message}"
+      "[#{time.strftime(TIME_FORMAT)}.#{(time.usec / 1000.0).round.to_s.rjust(3, "0")} #{severity_label} #{progname}(#{pid})#{tags_to_s}] #{message}"
     end
 
     def inspect
@@ -46,10 +46,10 @@ module Lumberjack
       if tags
         tags[UNIT_OF_WORK_ID] = value
       else
-        @tags = { UNIT_OF_WORK_ID => value }
+        @tags = {UNIT_OF_WORK_ID => value}
       end
     end
-    
+
     # Return the tag with the specified name.
     def tag(name)
       tags[name.to_s] if tags
@@ -58,10 +58,8 @@ module Lumberjack
     private
 
     def tags_to_s
-      tags_string = String.new
-      if tags
-        tags.each { |name, value| tags_string << " #{name}:#{value.inspect}" }
-      end
+      tags_string = ""
+      tags&.each { |name, value| tags_string << " #{name}:#{value.inspect}" }
       tags_string
     end
   end

data/lib/lumberjack/logger.rb

@@ -63,7 +63,7 @@ module Lumberjack
     # * :max_size - If the log device is a file path, it will be a Device::SizeRollingLogFile if this is set.
     #
     # All other options are passed to the device constuctor.
-    def initialize(device = STDOUT, options = {})
+    def initialize(device = $stdout, options = {})
       options = options.dup
       self.level = options.delete(:level) || INFO
       self.progname = options.delete(:progname)
@@ -100,19 +100,19 @@ module Lumberjack
       thread_local_value(:lumberjack_logger_level) || @level
     end
 
-    alias_method :sev_threshold, :level
+    alias sev_threshold level
 
     # Set the log level using either an integer level like Logger::INFO or a label like
     # :info or "info"
     def level=(value)
-      if value.is_a?(Integer)
-        @level = value
+      @level = if value.is_a?(Integer)
+        value
       else
-        @level = Severity::label_to_level(value)
+        Severity.label_to_level(value)
       end
     end
 
-    alias_method :sev_threshold=, :level=
+    alias sev_threshold= level=
 
     # Set the Lumberjack::Formatter used to format objects for logging as messages.
     def formatter=(value)
@@ -137,7 +137,7 @@ module Lumberjack
     # in an array under the "tagged" tag. So calling `logger.tagged("foo", "bar")` will result
     # in tags `{"tagged" => ["foo", "bar"]}`.
     def tagged_logger!
-      self.extend(TaggedLoggerSupport)
+      extend(TaggedLoggerSupport)
       self
     end
 
@@ -156,10 +156,10 @@ module Lumberjack
     #   logger.add_entry(:warn, "Request took a long time")
     #   logger.add_entry(Logger::DEBUG){"Start processing with options #{options.inspect}"}
     def add_entry(severity, message, progname = nil, tags = nil)
-      begin        
+      begin
         severity = Severity.label_to_level(severity) unless severity.is_a?(Integer)
         return true unless device && severity && severity >= level
-        
+
         return true if Thread.current[:lumberjack_logging]
         Thread.current[:lumberjack_logging] = true
 
@@ -173,10 +173,10 @@ module Lumberjack
         if current_tags.empty?
           tags = Tags.stringify_keys(tags) unless tags.nil?
         else
-          if tags.nil?
-            tags = current_tags.dup
+          tags = if tags.nil?
+            current_tags.dup
           else
-            tags = current_tags.merge(Tags.stringify_keys(tags))
+            current_tags.merge(Tags.stringify_keys(tags))
           end
         end
         tags = Tags.expand_runtime_values(tags)
@@ -203,7 +203,7 @@ module Lumberjack
       add_entry(severity, message, progname)
     end
 
-    alias_method :log, :add
+    alias log add
 
     # Flush the logging device. Messages are not guaranteed to be written until this method is called.
     def flush
@@ -238,6 +238,11 @@ module Lumberjack
       level <= FATAL
     end
 
+    # Set the log level to fatal.
+    def fatal!
+      self.level = FATAL
+    end
+
     # Log an +ERROR+ message. The message can be passed in either the +message+ argument or in a block.
     def error(message_or_progname_or_tags = nil, progname_or_tags = nil, &block)
       call_add_entry(ERROR, message_or_progname_or_tags, progname_or_tags, &block)
@@ -248,6 +253,11 @@ module Lumberjack
       level <= ERROR
     end
 
+    # Set the log level to error.
+    def error!
+      self.level = ERROR
+    end
+
     # Log a +WARN+ message. The message can be passed in either the +message+ argument or in a block.
     def warn(message_or_progname_or_tags = nil, progname_or_tags = nil, &block)
       call_add_entry(WARN, message_or_progname_or_tags, progname_or_tags, &block)
@@ -258,6 +268,11 @@ module Lumberjack
       level <= WARN
     end
 
+    # Set the log level to warn.
+    def warn!
+      self.level = WARN
+    end
+
     # Log an +INFO+ message. The message can be passed in either the +message+ argument or in a block.
     def info(message_or_progname_or_tags = nil, progname_or_tags = nil, &block)
       call_add_entry(INFO, message_or_progname_or_tags, progname_or_tags, &block)
@@ -268,6 +283,11 @@ module Lumberjack
       level <= INFO
     end
 
+    # Set the log level to info.
+    def info!
+      self.level = INFO
+    end
+
     # Log a +DEBUG+ message. The message can be passed in either the +message+ argument or in a block.
     def debug(message_or_progname_or_tags = nil, progname_or_tags = nil, &block)
       call_add_entry(DEBUG, message_or_progname_or_tags, progname_or_tags, &block)
@@ -278,6 +298,11 @@ module Lumberjack
       level <= DEBUG
     end
 
+    # Set the log level to debug.
+    def debug!
+      self.level = DEBUG
+    end
+
     # Log a message when the severity is not known. Unknown messages will always appear in the log.
     # The message can be passed in either the +message+ argument or in a block.
     def unknown(message_or_progname_or_tags = nil, progname_or_tags = nil, &block)
@@ -300,7 +325,7 @@ module Lumberjack
     def silence(temporary_level = ERROR, &block)
       if silencer
         unless temporary_level.is_a?(Integer)
-          temporary_level = Severity::label_to_level(temporary_level)
+          temporary_level = Severity.label_to_level(temporary_level)
         end
         push_thread_local_value(:lumberjack_logger_level, temporary_level, &block)
       else
@@ -324,30 +349,67 @@ module Lumberjack
     end
 
     # Set a hash of tags on logger. If a block is given, the tags will only be set
-    # for the duration of the block.
+    # for the duration of the block. If this method is called inside such a block,
+    # the tags will only be defined on the tags in that block. When the parent block
+    # exits, all the tags will be reverted. If there is no block, then the tags will
+    # be defined as global and apply to all log statements.
     def tag(tags, &block)
       tags = Tags.stringify_keys(tags)
+      thread_tags = thread_local_value(:lumberjack_logger_tags)
       if block
-        thread_tags = thread_local_value(:lumberjack_logger_tags)
-        value = (thread_tags ? thread_tags.merge(tags) : tags)
-        push_thread_local_value(:lumberjack_logger_tags, value, &block)
+        merged_tags = (thread_tags ? thread_tags.merge(tags) : tags.dup)
+        push_thread_local_value(:lumberjack_logger_tags, merged_tags, &block)
+      elsif thread_tags
+        thread_tags.merge!(tags)
+        nil
       else
         @tags.merge!(tags)
+        nil
+      end
+    end
+
+    # Remove a tag from the current tag context. If this is called inside a block to a
+    # call to `tag`, the tags will only be removed for the duration of that block. Otherwise
+    # they will be removed from the global tags.
+    def remove_tag(*tag_names)
+      thread_tags = thread_local_value(:lumberjack_logger_tags)
+      if thread_tags
+        tag_names.each { |name| thread_tags.delete(name.to_s) }
+      else
+        tag_names.each { |name| @tags.delete(name.to_s) }
       end
     end
 
     # Return all tags in scope on the logger including global tags set on the Lumberjack
-    # context, tags set on the logger, and tags set on the current block for the logger
+    # context, tags set on the logger, and tags set on the current block for the logger.
     def tags
       tags = {}
       context_tags = Lumberjack.context_tags
       tags.merge!(context_tags) if context_tags && !context_tags.empty?
-      tags.merge!(@tags) if !@tags.empty?
+      tags.merge!(@tags) if !@tags.empty? && !thread_local_value(:lumberjack_logger_untagged)
       scope_tags = thread_local_value(:lumberjack_logger_tags)
       tags.merge!(scope_tags) if scope_tags && !scope_tags.empty?
       tags
     end
 
+    # Remove all tags on the current logger and logging context within a block.
+    # You can still set new block scoped tags within theuntagged block and provide
+    # tags on individual log methods.
+    def untagged(&block)
+      Lumberjack.use_context(nil) do
+        scope_tags = thread_local_value(:lumberjack_logger_tags)
+        untagged = thread_local_value(:lumberjack_logger_untagged)
+        begin
+          set_thread_local_value(:lumberjack_logger_untagged, true)
+          set_thread_local_value(:lumberjack_logger_tags, nil)
+          tag({}, &block)
+        ensure
+          set_thread_local_value(:lumberjack_logger_untagged, untagged)
+          set_thread_local_value(:lumberjack_logger_tags, scope_tags)
+        end
+      end
+    end
+
     private
 
     # Dereference arguments to log calls so we can have methods with compatibility with ::Logger
@@ -430,12 +492,12 @@ module Lumberjack
     end
 
     def write_to_device(entry) #:nodoc:
-      begin
-        device.write(entry)
-      rescue => e
-        $stderr.puts("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
-        $stderr.puts(entry.to_s)
-      end
+      device.write(entry)
+    rescue => e
+      # rubocop:disable Style/StderrPuts
+      $stderr.puts("#{e.class.name}: #{e.message}#{" at " + e.backtrace.first if e.backtrace}")
+      $stderr.puts(entry.to_s)
+      # rubocop:enable Style/StderrPuts
     end
 
     # Create a thread that will periodically call flush.
@@ -444,12 +506,12 @@ module Lumberjack
         begin
           logger = self
           Thread.new do
-            while !closed?
+            until closed?
               begin
                 sleep(flush_seconds)
                 logger.flush if Time.now - logger.last_flushed_at >= flush_seconds
               rescue => e
-                STDERR.puts("Error flushing log: #{e.inspect}")
+                warn("Error flushing log: #{e.inspect}")
               end
             end
           end