quiet_logger 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ae7192146de8bb704c786f4c129dc33b3eece9d1c0b6e0fdb417274c70eb25d
-  data.tar.gz: c7c8971f79e92aede026a7e36ebfea13ff329062c85598e999017c60e5978ef2
+  metadata.gz: 84ec629d6e25d5aef93d890ceab63b5a387c35203709a126f240b68cdea0d779
+  data.tar.gz: 8c16d362965905b66dc9cfebe7b73402c325e3119ae6d3dd5c247b061841c072
 SHA512:
-  metadata.gz: 7f5057c20db5903f1f97c620e892074ab1cfcf3dc4aa53f88b62c514a41c722593f0fd36205350c62e5e86eadac606d632629d1c62a91e297a300138e2cb8593
-  data.tar.gz: a2e71f9d7c810866e316f93c0b0dec3f88e95fddaa78be5b80891e627eab4f0989a7908697fe8f7aee6edaca12b354e7b1dcff61b15ac33cd854ad8dfb85a048
+  metadata.gz: e9f56d02878ef5d4bc1d50b625e7ac61026d8a81901e63898ed7eecda4a6bf071b5bbee8690a2d205c215cdceda49b634b6c9432dbe932186b7b65943517c1e2
+  data.tar.gz: 3c09b747fce326ddb9040c8c4d3fc38c6c6d6688a57fa5c4d03d4d1109772ece4c2f9fdab88c28a1553f6201e5730003f4570f5fa8aee470cce04238b5ff70b4

data/CHANGELOG.md

@@ -1,10 +1,31 @@
 # Changelog
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.0.1
+
+### Added
+
+- Add explicit dependency on the `logger` gem since it is no longer a default gem as of Ruby 3.5.
+- Add support for the tagged logging API (`tagged`, `push_tags`, `pop_tags`, `clear_tags!`) when the wrapped logger supports it (i.e. `ActiveSupport::TaggedLogging`). Tags are stored on the wrapped logger, so they apply to messages logged with either logger. These methods are only defined when the wrapped logger implements them so that `respond_to?(:tagged)` still reflects what the wrapped logger can do.
+- Add `silence` to temporarily raise the severity level for the duration of a block for compatibility with ActiveSupport loggers.
+- Raise an `ArgumentError` when constructing a `QuietLogger` with an object that does not implement the `Logger` interface instead of failing later when a message is logged.
+
+### Changed
+
+- `formatter` now returns the formatter of the wrapped logger, and setting it sets it on the wrapped logger, since that is the logger that formats the messages.
+
+### Fixed
+
+- Fix `sev_threshold` returning the level set on the `QuietLogger` rather than the effective level, so it could report a lower level than `level` did.
+- Fix `NoMethodError` when calling `datetime_format=` caused by the `Logger` initializer never being called.
+- Fix `with_level` being silently ignored; the level set for the block is now honored (still limited by the level of the wrapped logger).
+
 ## 1.0.0
 
 ### Added
+
 - Add QuietLogger class to wrap other loggers but with a higher severity level to quiet their output.

data/README.md

@@ -1,7 +1,8 @@
+# QuietLogger
+
 [![Continuous Integration](https://github.com/bdurand/quiet_logger/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/quiet_logger/actions/workflows/continuous_integration.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
-
-# QuietLogger
+[![Gem Version](https://badge.fury.io/rb/quiet_logger.svg)](https://badge.fury.io/rb/quiet_logger)
 
 This gem provides a mechanism for wrapping a instance of `Logger` with one that produces a less verbose output.
 
@@ -30,6 +31,19 @@ quiet_logger.warn("one more time")  # This is logged since the level is warn
 even_quieter_logger = QuietLogger.new(verbose_logger, level: :error)
 ```
 
+The severity level is the only thing a `QuietLogger` controls. Messages are written by the logger being wrapped, so they are sent to the same output device and rendered with the same formatter.
+
+If the wrapped logger supports tagged logging (i.e. `ActiveSupport::TaggedLogging`), then the tagging methods are available on the `QuietLogger` as well. Tags are stored on the wrapped logger, so they apply to messages logged with either logger.
+
+```ruby
+quiet_logger = QuietLogger.new(Rails.logger, level: :warn)
+
+quiet_logger.tagged("ActionCable") do
+  quiet_logger.info("hello")  # This is not logged
+  quiet_logger.warn("hello")  # This is logged as "[ActionCable] hello"
+end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/lib/quiet_logger.rb

@@ -24,16 +24,102 @@ require "logger"
 # The log level on the `QuietLogger` can only be made more restrictive than the level on the
 # underlying logger. So, if the underlying logger has a level of "info", you cannot set the
 # `QuietLogger` to "debug".
+#
+# The severity level is the only thing a `QuietLogger` controls. Messages are written by the
+# underlying logger, so the output device and the formatter used to render messages are the ones
+# on that logger. Reading or setting `formatter` therefore reads or sets it on the wrapped logger.
+# The progname and datetime format used for output are the wrapped logger's as well, but setting
+# them on the `QuietLogger` has no effect on the output.
+#
+# If the wrapped logger supports tagged logging (i.e. `ActiveSupport::TaggedLogging`), then the
+# tagging methods are available on the `QuietLogger` as well. Tags are stored on the wrapped
+# logger, so they apply to messages logged with either logger.
+#
+# ```
+# quiet_logger = QuietLogger.new(Rails.logger)
+# quiet_logger.tagged("ActionCable") { quiet_logger.warn("Other stuff") }
+# ```
 class QuietLogger < Logger
+  # Delegates the tagged logging API to the wrapped logger. This is only mixed into instances
+  # that wrap a logger which supports tagging so that `respond_to?(:tagged)` continues to
+  # advertise what the wrapped logger can actually do.
+  #
+  # @api private
+  module Tagging
+    # Add tags to the messages logged inside the block. Tags are stored on the wrapped logger,
+    # so they are applied to messages logged with either logger.
+    def tagged(*tags)
+      if block_given?
+        @logger.tagged(*tags) { yield self }
+      else
+        self.class.new(@logger.tagged(*tags), level: @level)
+      end
+    end
+
+    def push_tags(*tags)
+      @logger.push_tags(*tags)
+    end
+
+    def pop_tags(count = 1)
+      @logger.pop_tags(count)
+    end
+
+    def clear_tags!
+      @logger.clear_tags!
+    end
+  end
+
   # Wrap a logger to have a higher log level.
+  #
+  # @raise [ArgumentError] If the logger does not implement the `Logger` interface used to
+  #   filter and forward messages.
   def initialize(logger, level: Logger::WARN)
+    unless logger.respond_to?(:add) && logger.respond_to?(:level)
+      raise ArgumentError, "logger must respond to :add and :level; got #{logger.inspect}"
+    end
+
+    # Passing a nil log device sets up the rest of the Logger internals without opening one of
+    # our own; messages are always written by the wrapped logger. The wrapped logger is not
+    # set until after this call so that the attributes the constructor initializes cannot be
+    # written through to it.
+    super(nil, level: level)
+
     @logger = logger
-    self.level = level
+    extend(Tagging) if defined?(ActiveSupport::TaggedLogging) && logger.is_a?(ActiveSupport::TaggedLogging)
   end
 
   # @return [Integer] Returns the log level
   def level
-    [@level, @logger.level].max
+    [super, @logger.level].max
+  end
+
+  # Logger aliases this to its own implementation of `level`, so it has to be re-aliased here
+  # to pick up the level from the wrapped logger.
+  alias_method :sev_threshold, :level
+
+  # A `QuietLogger` never formats messages itself; the wrapped logger does. The tagged logging
+  # API is built on top of the formatter, so this has to report the wrapped logger's formatter.
+  #
+  # @return [Logger::Formatter] The formatter of the wrapped logger.
+  def formatter
+    @logger.formatter
+  end
+
+  # Set the formatter on the wrapped logger since that is the logger that formats the messages.
+  def formatter=(value)
+    # The wrapped logger is not set yet when this is called from the Logger constructor.
+    @logger.formatter = value if @logger
+  end
+
+  if Logger.method_defined?(:with_level)
+    # Silence the logger for the duration of the block by temporarily raising the severity
+    # level. Provided for compatibility with ActiveSupport loggers. The level is still
+    # constrained by the level of the wrapped logger.
+    #
+    # Only defined if the logger gem supports `with_level` (logger >= 1.5).
+    def silence(severity = Logger::ERROR)
+      with_level(severity) { yield self }
+    end
   end
 
   # @api private

data/quiet_logger.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler"
+  spec.add_dependency "logger"
 
-  spec.required_ruby_version = ">= 2.5"
+  spec.required_ruby_version = ">= 2.6"
 end

metadata

@@ -1,30 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: quiet_logger
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Brian Durand
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
 email:
 - bbdurand@gmail.com
 executables: []
@@ -32,7 +30,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- MIT-LICENSE
+- MIT-LICENSE.txt
 - README.md
 - VERSION
 - lib/quiet_logger.rb
@@ -41,7 +39,6 @@ homepage: https://github.com/bdurand/quiet_logger
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -49,15 +46,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A logger implementation that can wrap another logger to increase the log
   level to reduce noise in the logs.