rails_semantic_logger 5.1.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0d257eeb6faedaba38caba805893dc4c269dfaf0b1b0f5cc496d54e3bc3f6ad
-  data.tar.gz: 5ae1af5ac5514a6fd84f70f4b0d13232791f942b3fead595a082ae15c1258893
+  metadata.gz: '08056406dee88f7c5eb0d29107d9d82b95487cf913ace9a6dd292c49641f58c4'
+  data.tar.gz: 5dfdb7970f4baf88676218aa9a0778245957c094dc1ee7103e7940c456a54e06
 SHA512:
-  metadata.gz: 7a79e69e2a466f8a0f414b21e3890118eac262c7bb2983a91cfac547fc04f3cb91535bde3aa1ff611d57a1b5a6e56d7ba885f8177f3d0a0777682de844ba2b9e
-  data.tar.gz: cc0fb18514ef84ee7e3ec270a70bf155aa54e6f71e0fffe59f0492fb712d5dab64ec27c42ab69afaccde1259aeb75913319d1fbc07f70bea7938e3fe231ef8aa
+  metadata.gz: e138fdae60edf8a40b1e0b57d4b351bc0069b48550f0ecd0ee443ef8bbb154984c8923a07632d441cf154b39f7777e266073254f6cd57bd6bf83c26dd59c5b63
+  data.tar.gz: 5e7e1e27aded0d3a1731cab0f756dfada2d11dcf1f2a756bd41ecfa912c44f9931649df0a2e56f32d21328a64f22db1a9f97c02c6ac939f17974342f4805c7d8

data/README.md

@@ -1,7 +1,7 @@
 # Rails Semantic Logger
 [![Gem Version](https://img.shields.io/gem/v/rails_semantic_logger.svg)](https://rubygems.org/gems/rails_semantic_logger) [![Build Status](https://github.com/reidmorrison/rails_semantic_logger/workflows/build/badge.svg)](https://github.com/reidmorrison/rails_semantic_logger/actions?query=workflow%3Abuild) [![Downloads](https://img.shields.io/gem/dt/rails_semantic_logger.svg)](https://rubygems.org/gems/rails_semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg)
 
-Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](https://logger.rocketjob.io/), so that Rails, your application code, and many common gems all log through structured logging instead of plain text.
+Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](https://logger.reidmorrison.com/), so that Rails, your application code, and many common gems all log through structured logging instead of plain text.
 
 When any large Rails application is deployed to production one of the first steps is to move to centralized logging, so that logs can be viewed and searched from a central location. That quickly falls apart when consuming human readable text logs:
 
@@ -67,17 +67,17 @@ end
 
 Because declaring an appender replaces the default file appender, JSON to stdout becomes the only destination, exactly what a container platform wants. Once logs are emitted as structured JSON, a centralized logging system can parse each field, including the nested `payload` and any `metric` data, into a searchable hierarchy, so you can build searches, alerts, and dashboards against well-defined fields instead of brittle text matching.
 
-See [Configuring appenders](https://logger.rocketjob.io/rails#configuring-where-logs-go-the-appenders-block) for the full guide, including formatters, third-party destinations, the [container platform recipe](https://logger.rocketjob.io/rails#production-on-a-container-platform-docker-kubernetes-heroku), tuning what Rails logs, and worked examples of querying the JSON.
+See [Configuring appenders](https://logger.reidmorrison.com/rails#configuring-where-logs-go-the-appenders-block) for the full guide, including formatters, third-party destinations, the [container platform recipe](https://logger.reidmorrison.com/rails#production-on-a-container-platform-docker-kubernetes-heroku), tuning what Rails logs, and worked examples of querying the JSON.
 
 ## Documentation
 
-For complete documentation see: https://logger.rocketjob.io/rails
+For complete documentation see: https://logger.reidmorrison.com/rails
 
 ## Upgrading
 
 The way appenders (log destinations) are configured changed in v5. See the
-[v4 to v5 migration guide](https://logger.rocketjob.io/rails#migrating-from-v4-to-v5) for the
-before/after mapping, and [Migrating from earlier versions](https://logger.rocketjob.io/rails#migrating-from-earlier-versions)
+[v4 to v5 migration guide](https://logger.reidmorrison.com/rails#migrating-from-v4-to-v5) for the
+before/after mapping, and [Migrating from earlier versions](https://logger.reidmorrison.com/rails#migrating-from-earlier-versions)
 for older releases.
 
 ## New Versions of Rails, etc.

data/lib/rails_semantic_logger/engine.rb

@@ -25,6 +25,27 @@ module RailsSemanticLogger
     # insert itself above the configured rails logger to add support for its
     # additional features
 
+    # Register this gem's deprecator with the application so that the standard Rails
+    # deprecation settings govern it: `config.active_support.report_deprecations`,
+    # `config.active_support.deprecation`, and
+    # `Rails.application.deprecators[:rails_semantic_logger]`. Rails' own
+    # `active_support.deprecation_behavior` initializer only reaches deprecators in
+    # that collection.
+    #
+    # Runs before the environment file is read so that an application can also reach
+    # the deprecator by name from `config/environments/*.rb`.
+    initializer "rails_semantic_logger.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:rails_semantic_logger] = RailsSemanticLogger.deprecator
+    end
+
+    # The deprecated appender options are set from `config/application.rb` and
+    # `config/environments/*.rb`, which Rails reads before it applies the deprecation
+    # settings above, so their warnings are recorded rather than emitted. Now that
+    # the settings are in place, emit them.
+    initializer "rails_semantic_logger.flush_deprecations", after: "active_support.deprecation_behavior" do |app|
+      app.config.rails_semantic_logger.flush_deprecations!
+    end
+
     # Replace Rails logger initializer
     Rails::Application::Bootstrap.initializers.delete_if { |i| i.name == :initialize_logger }
 

data/lib/rails_semantic_logger/extensions/action_cable/tagged_logger_proxy.rb

@@ -1,70 +1,81 @@
-require "action_cable/connection/tagged_logger_proxy"
-
-# Upstream source (identical across supported versions):
+# Upstream source (identical across supported versions, only the namespace differs):
 #   https://github.com/rails/rails/blob/v7.2.2/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
 #   https://github.com/rails/rails/blob/v8.0.2/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
 #   https://github.com/rails/rails/blob/v8.1.3/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
-module ActionCable
-  module Connection
-    class TaggedLoggerProxy
-      # Mirrors upstream #tag, including the `respond_to?(:tagged)` guard so a
-      # target logger without tagging support (e.g. when handed a non-tagged
-      # ActiveRecord::Base.logger by the worker pool) simply yields. Diverges in
-      # one place: upstream reads the already-applied tags via
-      # `logger.formatter.current_tags` (ActiveSupport::TaggedLogging), but
-      # Semantic Logger exposes them via `#tags`, so resolve from whichever the
-      # target logger supports. See #220.
-      def tag(logger, &)
-        if logger.respond_to?(:tagged)
-          current_tags = tags - applied_tags_for(logger)
-          logger.tagged(*current_tags, &)
-        else
-          yield
-        end
+#   https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/server/tagged_logger_proxy.rb
+module RailsSemanticLogger
+  module ActionCable
+    # Rails 8.2 moved the proxy from ActionCable::Connection to ActionCable::Server, as part of
+    # the ActionCable::Server::Socket refactor, without leaving a back-compat alias behind.
+    # Resolve whichever constant this version of ActionCable ships rather than hard-coding a
+    # namespace, so that a `require` of the old path cannot fail the app's boot. See #326.
+    TaggedLoggerProxy =
+      if defined?(::ActionCable::Server::TaggedLoggerProxy)
+        ::ActionCable::Server::TaggedLoggerProxy
+      else
+        require "action_cable/connection/tagged_logger_proxy"
+        ::ActionCable::Connection::TaggedLoggerProxy
       end
+  end
+end
 
-      # Upstream defines the severity methods with a single-arg signature
-      # (`message = nil`), which discards Semantic Logger's richer payload and
-      # exception arguments and raises ArgumentError when they are supplied.
-      # Redefine them to forward the full Semantic Logger signature down to the
-      # wrapped logger, while still applying the connection's tags. See #220.
-      %i[debug info warn error fatal unknown].each do |severity|
-        define_method(severity) do |message = nil, payload = nil, exception = nil, &block|
-          tag(@logger) { forward(severity, message, payload, exception, &block) }
-        end
-      end
+RailsSemanticLogger::ActionCable::TaggedLoggerProxy.class_eval do
+  # Mirrors upstream #tag, including the `respond_to?(:tagged)` guard so a
+  # target logger without tagging support (e.g. when handed a non-tagged
+  # ActiveRecord::Base.logger by the worker pool) simply yields. Diverges in
+  # one place: upstream reads the already-applied tags via
+  # `logger.formatter.current_tags` (ActiveSupport::TaggedLogging), but
+  # Semantic Logger exposes them via `#tags`, so resolve from whichever the
+  # target logger supports. See #220.
+  def tag(logger, &)
+    if logger.respond_to?(:tagged)
+      current_tags = tags - applied_tags_for(logger)
+      logger.tagged(*current_tags, &)
+    else
+      yield
+    end
+  end
 
-      private
+  # Upstream defines the severity methods with a single-arg signature
+  # (`message = nil`), which discards Semantic Logger's richer payload and
+  # exception arguments and raises ArgumentError when they are supplied.
+  # Redefine them to forward the full Semantic Logger signature down to the
+  # wrapped logger, while still applying the connection's tags. See #220.
+  %i[debug info warn error fatal unknown].each do |severity|
+    define_method(severity) do |message = nil, payload = nil, exception = nil, &block|
+      tag(@logger) { forward(severity, message, payload, exception, &block) }
+    end
+  end
 
-      # Only forward the extra payload/exception arguments when the wrapped logger's
-      # method can accept them. A standard Ruby Logger (e.g. the one wrapped by
-      # ActionCable::Connection::TestCase) only accepts a single `progname` argument
-      # and raises ArgumentError given more, so fall back to the single-arg call. See #317.
-      def forward(severity, message, payload, exception, &)
-        if extended_signature?(@logger, severity)
-          @logger.public_send(severity, message, payload, exception, &)
-        else
-          @logger.public_send(severity, message, &)
-        end
-      end
+  private
 
-      def extended_signature?(logger, severity)
-        params = logger.method(severity).parameters
-        params.any? { |type, _| type == :rest } || params.count { |type, _| %i[req opt].include?(type) } >= 3
-      end
+  # Only forward the extra payload/exception arguments when the wrapped logger's
+  # method can accept them. A standard Ruby Logger (e.g. the one wrapped by
+  # ActionCable::Connection::TestCase) only accepts a single `progname` argument
+  # and raises ArgumentError given more, so fall back to the single-arg call. See #317.
+  def forward(severity, message, payload, exception, &)
+    if extended_signature?(@logger, severity)
+      @logger.public_send(severity, message, payload, exception, &)
+    else
+      @logger.public_send(severity, message, &)
+    end
+  end
 
-      # Tags already applied to the target logger, so they are not duplicated.
-      # Semantic Logger exposes them via `#tags`; ActiveSupport::TaggedLogging
-      # via `formatter.current_tags`. Fall back to none when neither is present.
-      def applied_tags_for(logger)
-        if logger.respond_to?(:tags)
-          Array(logger.tags)
-        elsif logger.respond_to?(:formatter) && logger.formatter.respond_to?(:current_tags)
-          logger.formatter.current_tags
-        else
-          []
-        end
-      end
+  def extended_signature?(logger, severity)
+    params = logger.method(severity).parameters
+    params.any? { |type, _| type == :rest } || params.count { |type, _| %i[req opt].include?(type) } >= 3
+  end
+
+  # Tags already applied to the target logger, so they are not duplicated.
+  # Semantic Logger exposes them via `#tags`; ActiveSupport::TaggedLogging
+  # via `formatter.current_tags`. Fall back to none when neither is present.
+  def applied_tags_for(logger)
+    if logger.respond_to?(:tags)
+      Array(logger.tags)
+    elsif logger.respond_to?(:formatter) && logger.formatter.respond_to?(:current_tags)
+      logger.formatter.current_tags
+    else
+      []
     end
   end
 end

data/lib/rails_semantic_logger/options.rb

@@ -256,14 +256,56 @@ module RailsSemanticLogger
       @add_file_appender = value
     end
 
+    # Emit the deprecation warnings recorded by the deprecated appender option
+    # setters, and warn immediately from any later call. Called by the engine once
+    # Rails has applied the application's deprecation configuration.
+    #
+    # The deprecated options are documented to be set in `config/application.rb` or
+    # `config/environments/*.rb`, which Rails reads in `load_environment_config`,
+    # long before `active_support.deprecation_behavior` applies
+    # `config.active_support.report_deprecations`, `config.active_support.deprecation`,
+    # and any per-deprecator settings. Warning from the setter itself would therefore
+    # land in a window where nothing the application configures can reach it. The
+    # setters record instead, and this flushes once the settings are in place.
+    #
+    # Each option is reported once, attributed to the first place it was set, so an
+    # application setting several deprecated options gets one warning per option
+    # rather than one per assignment.
+    def flush_deprecations!
+      @deprecations_flushed = true
+      pending = pending_deprecations
+      @pending_deprecations = {}
+      pending.each_value { |message, callstack| RailsSemanticLogger.deprecator.warn(message, callstack) }
+      nil
+    end
+
     private
 
     def deprecate_appender_option(option, via: "appenders.add(...)")
-      RailsSemanticLogger.deprecator.warn(
+      message =
         "`config.rails_semantic_logger.#{option}=` is deprecated and will be removed in a future release. " \
         "Declare the destination and formatting directly instead, via " \
         "`config.rails_semantic_logger.appenders { |appenders| #{via} }`."
-      )
+
+      # Skip this method and the setter that called it, so the warning is attributed
+      # to the application code that set the option, whether it is emitted now or
+      # flushed later by #flush_deprecations!.
+      callstack = caller_locations(2)
+
+      return RailsSemanticLogger.deprecator.warn(message, callstack) if deprecations_flushed?
+
+      pending_deprecations[option] ||= [message, callstack]
+      nil
+    end
+
+    # Deprecations recorded before Rails applied its deprecation configuration,
+    # keyed by option so that each is reported only once. See #flush_deprecations!.
+    def pending_deprecations
+      @pending_deprecations ||= {}
+    end
+
+    def deprecations_flushed?
+      defined?(@deprecations_flushed) && @deprecations_flushed
     end
 
     # Warn when an init-time setting is changed after the logger and its

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "5.1.0".freeze
+  VERSION = "5.2.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Reid Morrison
@@ -83,13 +83,13 @@ files:
 - lib/rails_semantic_logger/sidekiq/loggable.rb
 - lib/rails_semantic_logger/solid_queue/log_subscriber.rb
 - lib/rails_semantic_logger/version.rb
-homepage: https://logger.rocketjob.io
+homepage: https://logger.reidmorrison.com
 licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/reidmorrison/rails_semantic_logger/issues
-  documentation_uri: https://logger.rocketjob.io
-  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v5.1.0
+  documentation_uri: https://logger.reidmorrison.com
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v5.2.0
   changelog_uri: https://github.com/reidmorrison/rails_semantic_logger/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []