lumberjack 1.2.3 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55a35b3e0ea957e0a08049bd7a6b7b6e7373d79983e96a6459f1448b1d3d3dbe
-  data.tar.gz: 4cd9386b842c1686af145ef3f369219d78846aa4f5fd1223b3234b4ae91f63ef
+  metadata.gz: c7912cf1bfe32dcaa911a6a65a0b755fb3051eebc2a7e4a65ff5d422f2f61ad7
+  data.tar.gz: b4077d2ef97be7169ed0e7bca7d107ec3f42372dde45cae1e7cdcedae1fb4e61
 SHA512:
-  metadata.gz: 81108d71edd9c6ebd0653d5d8e13587bf0a88796f5682d2b9c602c8977c2ade0f343b9fc3086658c3764cd8d8dd3b8f8ccc8b5cf5bf460225f1719a1116e8742
-  data.tar.gz: b7c8f80a651358bb763811d9068c113b72a6948a9e513394a4f456192076e0b654ea101c1c0ce723d14f94f9b574b749ce5f9f9580b3051a8f2cd84d8c1c7a7a
+  metadata.gz: a092775aec0c7670eda8ff4959a7cc928a57b0934ecc8a1190efe395b437bc0a681bdbd2f3455b98f3cf757904f5f39b31c96e24e9c8bcd7a481b806027e92c8
+  data.tar.gz: 885f76da2738f3f6236a363d9a7dea68f83a80a03e123a3c52c578984f963e959de6fd60d0fd222d9a9933c22ed959181538abb4118163c8fd6528292e88673c

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 1.2.8
+
+* Add `Logger#untagged` to remove previously set logging tags from a block.
+* Return result of the block when a block is passed to `Logger#tag`.
+
+## 1.2.7
+
+* Allow passing frozen hashes to `Logger#tag`. Tags passed to this method are now duplicated so the logger maintains it's own copy of the hash.
+
+## 1.2.6
+
+* Fix `Logger#tag` so it only ads to the current block's logger tags instead of the global tags if called inside a `Logger#tag` block.
+* Add Logger#remove_tag
+
+## 1.2.5
+
+* Fix logic with recursive reference guard in StructuredFormatter so it only suppresses Enumerable references.
+* Add support for bang methods (error!) for setting the log level.
+
+## 1.2.4
+
+* Enhance `ActiveSupport::TaggedLogging` support so code that Lumberjack loggers can be wrapped with a tagged logger.
+
 ## 1.2.3
 
 * Fix structured formatter so no-recursive, duplicate references are allowed.
@@ -12,7 +35,7 @@
 
 ## 1.2.0
 
-* Enable compatibility with ActiveSupport::TaggedLogger by calling `tagged_logger!` on a logger.
+* Enable compatibility with `ActiveSupport::TaggedLogger` by calling `tagged_logger!` on a logger.
 * Add `tag_formatter` to logger to specify formatting of tags for output.
 * Allow adding and removing classes by name to formatters.
 * Allow adding and removing multiple classes in a single call to a formatter.
@@ -31,7 +54,7 @@
 
 ## 1.1.0
 
-* Change Lumberjack::Logger to inherit from ::Logger
+* Change `Lumberjack::Logger` to inherit from ::Logger
 * Add support for tags on log messages
 * Add global tag context for all loggers
 * Add per logger tags and tag contexts
@@ -39,8 +62,8 @@
 * Add support for setting datetime format on log devices
 * Performance optimizations
 * Add Multi device to output to multiple devices
-* Add DateTimeFormatter, IdFormatter, ObjectFormatter, and StructuredFormatter
-* Add rack Context middleware for setting thread global context
+* Add `DateTimeFormatter`, `IdFormatter`, `ObjectFormatter`, and `StructuredFormatter`
+* Add rack `Context` middleware for setting thread global context
 * End support for ruby versions < 2.3
 * Add support for modules in formatters
 
@@ -52,7 +75,7 @@
 
 ## 1.0.12
 
-* Add support for ActionDispatch request id for better Rails compatibility.
+* Add support for `ActionDispatch` request id for better Rails compatibility.
 
 ## 1.0.11
 
@@ -66,11 +89,11 @@
 
 ## 1.0.9
 
-* Add method so Formatter is compatible with ActiveSupport logging extensions.
+* Add method so Formatter is compatible with `ActiveSupport` logging extensions.
 
 ## 1.0.8
 
-* Fix another internal variable name conflict with ActiveSupport logging extensions.
+* Fix another internal variable name conflict with `ActiveSupport` logging extensions.
 
 ## 1.0.7
 
@@ -78,7 +101,7 @@
 
 ## 1.0.6
 
-* Fix internal variable name conflict with ActiveSupport logging extensions.
+* Fix internal variable name conflict with `ActiveSupport` logging extensions.
 
 ## 1.0.5
 

data/README.md

@@ -1,7 +1,8 @@
-# Lumberjack
-
-[![Build Status](https://travis-ci.org/bdurand/lumberjack.svg?branch=master)](https://travis-ci.org/bdurand/lumberjack)
+![Continuous Integration](https://github.com/bdurand/lumberjack/workflows/Continuous%20Integration/badge.svg)
 [![Maintainability](https://api.codeclimate.com/v1/badges/a0abc03721fff9b0cde1/maintainability)](https://codeclimate.com/github/bdurand/lumberjack/maintainability)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
+# Lumberjack
 
 Lumberjack is a simple, powerful, and fast logging implementation in Ruby. It uses nearly the same API as the Logger class in the Ruby standard library and as ActiveSupport::BufferedLogger in Rails.
 
@@ -59,8 +60,10 @@ You can specify tags that will only be applied to the logger in a block as well.
 ```ruby
 logger.tag(thread_id: Thread.current.object_id) do
   logger.info("here") # Will include the `thread_id` tag
+  logger.tag(count: 15)
+  logger.info("with count") # Will include the `count` tag
 end
-logger.info("there") # Will not include the `thread_id` tag
+logger.info("there") # Will not include the `thread_id` or `count` tag
 ```
 
 You can also set tags to `Proc` objects that will be evaluated when creating a log entry.
@@ -85,13 +88,13 @@ logger.info("no requests") # Will not include the `request_id` tag
 
 Tag keys are always converted to strings. Tags are inherited so that message tags take precedence over block tags which take precedence over global tags.
 
-#### Compatibility with ActiveSupport::TaggedLogger
+#### Compatibility with ActiveSupport::TaggedLogging
 
-`Lumberjack::Logger` version 1.1.2 or greater is compatible with `ActiveSupport::TaggedLogger`. This is so that other code that expect to have a logger that responds to the `tagged` method will work. Any tags added with the `tagged` method will be appended to an array in the the "tagged" tag. However, if a tagged value has a colon or equals sign in it, it will be parsed to a name value pair.
+`Lumberjack::Logger` version 1.1.2 or greater is compatible with `ActiveSupport::TaggedLogging`. This is so that other code that expect to have a logger that responds to the `tagged` method will work. Any tags added with the `tagged` method will be appended to an array in the the "tagged" tag.
 
 ```ruby
-logger.tagged("foo", "bar=1", "baz:2", "other") do
-  logger.info("here") # will include tags: {"tagged" => ["foo", "other"], "bar" => "1", "baz" => "2"}
+logger.tagged("foo", "bar=1", "other") do
+  logger.info("here") # will include tags: {"tagged" => ["foo", "bar=1", "other"]}
 end
 ```
 

data/VERSION

@@ -1 +1 @@
-1.2.3
+1.2.8

data/lib/lumberjack.rb

@@ -1,26 +1,26 @@
 # frozen_string_literals: true
 
-require 'rbconfig'
-require 'time'
-require 'thread'
-require 'securerandom'
-require 'logger'
+require "rbconfig"
+require "time"
+require "securerandom"
+require "logger"
 
 module Lumberjack
-  LINE_SEPARATOR = (RbConfig::CONFIG['host_os'].match(/mswin/i) ? "\r\n" : "\n")
+  LINE_SEPARATOR = (RbConfig::CONFIG["host_os"] =~ /mswin/i ? "\r\n" : "\n")
 
-  require_relative "lumberjack/severity.rb"
-  require_relative "lumberjack/formatter.rb"
+  require_relative "lumberjack/severity"
+  require_relative "lumberjack/formatter"
 
-  require_relative "lumberjack/context.rb"
-  require_relative "lumberjack/log_entry.rb"
-  require_relative "lumberjack/device.rb"
-  require_relative "lumberjack/logger.rb"
-  require_relative "lumberjack/tags.rb"
-  require_relative "lumberjack/tag_formatter.rb"
-  require_relative "lumberjack/tagged_logger_support.rb"
-  require_relative "lumberjack/template.rb"
-  require_relative "lumberjack/rack.rb"
+  require_relative "lumberjack/context"
+  require_relative "lumberjack/log_entry"
+  require_relative "lumberjack/device"
+  require_relative "lumberjack/logger"
+  require_relative "lumberjack/tags"
+  require_relative "lumberjack/tag_formatter"
+  require_relative "lumberjack/tagged_logger_support"
+  require_relative "lumberjack/tagged_logging"
+  require_relative "lumberjack/template"
+  require_relative "lumberjack/rack"
 
   class << self
     # Define a unit of work within a block. Within the block supplied to this
@@ -53,31 +53,41 @@ module Lumberjack
     #
     # Otherwise, it will return the current context. If one doesn't exist, it will return a new one
     # but that context will not be in any scope.
-    def context
+    def context(&block)
       current_context = Thread.current[:lumberjack_context]
-      if block_given?
-        Thread.current[:lumberjack_context] = Context.new(current_context)
-        begin
-          yield
-        ensure
-          Thread.current[:lumberjack_context] = current_context
-        end
+      if block
+        use_context(Context.new(current_context), &block)
       else
         current_context || Context.new
       end
     end
 
+    # Set the context to use within a block.
+    def use_context(context, &block)
+      current_context = Thread.current[:lumberjack_context]
+      begin
+        Thread.current[:lumberjack_context] = (context || Context.new)
+        yield
+      ensure
+        Thread.current[:lumberjack_context] = current_context
+      end
+    end
+
+    # Return true if inside a context block.
+    def context?
+      !!Thread.current[:lumberjack_context]
+    end
+
     # Return the tags from the current context or nil if there are no tags.
     def context_tags
       context = Thread.current[:lumberjack_context]
-      context.tags if context
+      context&.tags
     end
 
     # Set tags on the current context
     def tag(tags)
       context = Thread.current[:lumberjack_context]
-      context.tag(tags) if context
+      context&.tag(tags)
     end
-
   end
 end

data/lib/lumberjack/device.rb

@@ -4,37 +4,37 @@ 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.
     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

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
@@ -16,7 +16,7 @@ module Lumberjack
       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,23 +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_stream, options)
       end
-      
+
       def reopen(logdev = nil)
         close
         @stream = file_stream
       end
-      
+
       private
-      
+
       def file_stream
-        File.new(@path, 'a', :encoding => EXTERNAL_ENCODING)
+        File.new(@path, "a", encoding: EXTERNAL_ENCODING)
       end
     end
   end

data/lib/lumberjack/device/multi.rb

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

data/lib/lumberjack/device/null.rb

@@ -7,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

@@ -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
+        @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