lumberjack 1.2.1 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72793f91350cf3b30baede6fb2463d4c3456767445997ea9575a9914e81b5064
-  data.tar.gz: e26eb87f8ce64b37010728c650a3c152ca8e79f068af057f37053aabfdff7e5a
+  metadata.gz: bb579edefef20d72b221b245b502657e3e7b60b61fd2037e6d97ff50577b0d6d
+  data.tar.gz: a38ac097040fd058346f2329d2b014d98e465e1f842ca466e52ede4bd5303463
 SHA512:
-  metadata.gz: d432507622e800253e8533f2effa884c00cb890acc4fe94031b5b65c811737f544c1cf6174b90d7dc328e62654a6258e6ebd327a7e5e64a8958484579977c2d3
-  data.tar.gz: af4aee97287aa70c9af2a655ac55ccf38d39a9469d5aedffab3452365b26c89b184fad05a483611b3a500e1af89f1c33b2a23343d70112694f735ae02927189c
+  metadata.gz: 196113e296216a6cf5e5b5914ecc041b9bdb2be71d0847d1bf7bc15cd14aca05a8e2d62f6c2ff397a5323b18a67e714aa19bf3f3eb837c88753254dc5d4226ee
+  data.tar.gz: d4ee3d9b4d90464517ce7b8546304b8dfdcb4e709e839d9d828af2b409199bea5d9943860b238156a4c291e1d7cdd12a502dfe365350bce001a6d231d53bd058

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 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.
+
 ## 1.2.1
 
 * Prevent infinite loops where logging a statement triggers the logger.

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.1
+1.2.6

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,26 +6,58 @@ 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
 
       def call(obj)
+        call_with_references(obj, Set.new)
+      end
+
+      private
+
+      def call_with_references(obj, references)
         if obj.is_a?(Hash)
-          hash = {}
-          references ||= Set.new
-          obj.each do |name, value|
-            hash[name.to_s] = call(value)
+          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
-          obj.collect { |element| call(element) }
+          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
         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)
+        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.1
+  version: 1.2.6
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-27 00:00:00.000000000 Z
+date: 2020-06-20 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