lumberjack 1.2.2 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12dffa9034387deb6cfc49976ce1bf2c90b35e9a255ac2f4c1a4730cd3de2a24
-  data.tar.gz: 1c7d4f246228a9b1d0f35e1618afc245e202d496617590d3d876e1b99b67e6c2
+  metadata.gz: 0ba28430c423311445a80559e0bd6fdfbfdfed90edcd4dda89d9e5d635d75ec9
+  data.tar.gz: 5507d016ad2b7dcf13e38616496e2b9e5c18e456eb1ad6bdfeceb66386eae403
 SHA512:
-  metadata.gz: 24d8eb348cfea7edeba9469e8d7d4c77717aa0b1045050dbce5ecc52f4e53e4c510bb1f8ecf23ea1e3886a7b8bbf0f21870fa1d2f0e964ec4e3dbb0d8af2f8f5
-  data.tar.gz: cbae4aede2f52a4abf45d3a92729aedbba25a1ef9c58020ab1d120f83bea610e1b83ee10cdc0b35a3ad698685cad6b92925cdaf9009ae1b47cc80f3985e9c4e8
+  metadata.gz: 7bf2c9640012487f994d8e4eaabf85e9b4a3fbae828d0a0bccab71cfa7af8820da199b72d04764db4b6d9e7439ac620f49578b0a20b8c77c01f4ea496616ff4c
+  data.tar.gz: fb7d9b44ca1bbbd1a2727252c5b9f8885f8a374cd24e0fa34f38b9fca2cfa0444d603d15ccdec743c247251c0622d9153ecbe1b0d9c609da24b38511957ba190

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 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.
+
 ## 1.2.2
 
 * Prevent infinite loops in the structured formatter where objects have backreferences to each other.

data/README.md

@@ -59,8 +59,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 +87,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.2
+1.2.7

data/lib/lumberjack.rb

@@ -19,6 +19,7 @@ module Lumberjack
   require_relative "lumberjack/tags.rb"
   require_relative "lumberjack/tag_formatter.rb"
   require_relative "lumberjack/tagged_logger_support.rb"
+  require_relative "lumberjack/tagged_logging.rb"
   require_relative "lumberjack/template.rb"
   require_relative "lumberjack/rack.rb"
 
@@ -66,6 +67,11 @@ module Lumberjack
         current_context || Context.new
       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

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
@@ -17,29 +20,44 @@ module Lumberjack
       private
 
       def call_with_references(obj, references)
-        references << obj
         if obj.is_a?(Hash)
-          hash = {}
-          obj.each do |name, value|
-            next if references.include?(value)
-            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
-          hash
         elsif obj.is_a?(Enumerable) && obj.respond_to?(:size) && obj.size != Float::INFINITY
-          array = []
-          obj.each do |value|
-            next if references.include?(value)
-            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
-          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/logger.rb

@@ -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
 
@@ -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)
@@ -324,16 +349,34 @@ 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)
       else
         @tags.merge!(tags)
       end
+      nil
+    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
@@ -449,7 +492,7 @@ module Lumberjack
                 sleep(flush_seconds)
                 logger.flush if Time.now - logger.last_flushed_at >= flush_seconds
               rescue => e
-                STDERR.puts("Error flushing log: #{e.inspect}")
+                $stderr.puts("Error flushing log: #{e.inspect}")
               end
             end
           end

data/lib/lumberjack/tagged_logging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  # Monkey patch for ActiveSupport::TaggedLogger so it doesn't blow up when
+  # a Lumberjack logger is trying to be wrapped. This module will be automatically
+  # included in ActiveSupport::TaggedLogger if activesupport is already loaded.
+  module TaggedLogging
+    class << self
+      def included(base)
+        base.singleton_class.send(:prepend, ClassMethods)
+      end
+    end
+    
+    module ClassMethods
+      def new(logger)
+        if logger.is_a?(Lumberjack::Logger)
+          logger = logger.tagged_logger! unless logger.respond_to?(:tagged)
+          logger
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActiveSupport::TaggedLogging)
+  ActiveSupport::TaggedLogging.include(Lumberjack::TaggedLogging)
+end

data/lumberjack.gemspec

@@ -11,8 +11,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w(
-    .gitignore
-    .travis.yml
+    .
     Appraisals
     Gemfile
     Gemfile.lock

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.7
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-05 00:00:00.000000000 Z
+date: 2020-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -74,7 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- MIT_LICENSE
+- MIT_LICENSE.txt
 - README.md
 - VERSION
 - lib/lumberjack.rb
@@ -106,6 +106,7 @@ files:
 - lib/lumberjack/severity.rb
 - lib/lumberjack/tag_formatter.rb
 - lib/lumberjack/tagged_logger_support.rb
+- lib/lumberjack/tagged_logging.rb
 - lib/lumberjack/tags.rb
 - lib/lumberjack/template.rb
 - lumberjack.gemspec