rails_semantic_logger 4.20.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8f7b94b3d6d4f231657586789b55ffe22c4a3d86e7f34c558b5c757a6e3d2af
-  data.tar.gz: 72a661f99dae0261b5cd6c6dffe972bfee3903ea48dd3b16832d40aa747bc9c1
+  metadata.gz: 213d85a11e285b1353549f41b8a8c28068a33d3913e270d72eed94f6ee1d861c
+  data.tar.gz: 8233c4128fdc790e3cefedd3efc8d8c6b274393604527cc162dff97842227fea
 SHA512:
-  metadata.gz: ae75985892a47040a291e94fed73756884aca9c74e21339b3d40fba964bad47b6ffa5237899cb34b05d7c8727e9a9ebe8967774b3693cc9d9371ef61d3696814
-  data.tar.gz: 1601458b40ab94c03244b44aed2522f1c0a72f06076f9df46f42793de77f10ccff63d7f851be38a984eae9615fe7ca977141b50f473a282d9e1adf15e864665d
+  metadata.gz: 52330aaea8cf48aa21a62b8c5654163ce481382fa67bd6935c02d3deecfcef3a83a32b30c563941eb49404d86063ff2056778692781bd14a96174b55d2372f9f
+  data.tar.gz: 5da348c363745f1e3b7a2fc73c36221658f86dafcad53d5078990d9d204fe5bf2224a319a156395597a7916bb2a950b1c27974114bbee37662f388295999758a

data/README.md

@@ -1,128 +1,85 @@
 # 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/)
+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.
 
-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.
+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:
 
-Centralized logging quickly falls apart when trying to consume the current human readable log files:
-- Log entries often span multiple lines, resulting in unrelated log lines in the centralized logging system. For example, stack traces.
-- Complex Regular Expressions are needed to parse the text lines and make them machine readable. For example to build queries, or alerts that are looking for specific elements in the message.
-- Writing searches, alerts, or dashboards based on text logs is incredibly brittle, since a small change to the text logged can often break the parsing of those logs.
-- Every log entry often has a completely different format, making it difficult to make consistent searches against the data.
+- Log entries often span multiple lines (for example, stack traces), so unrelated lines end up interleaved in the centralized system.
+- Complex regular expressions are needed to parse the text into machine readable fields for queries and alerts.
+- Searches, alerts, and dashboards built on text are brittle: a small change to the logged text breaks them.
+- Every log entry has a different format, making consistent searches difficult.
 
-For these and many other reasons switching to structured logging, or logs in JSON format, in testing and production makes centralized logging incredibly powerful.
+Switching to structured logging, or logs in JSON format, makes centralized logging in testing and production far more powerful. Rails Semantic Logger also collapses the several lines Rails normally logs per request into a single structured "Completed" line, while keeping every field (controller, action, status, durations, and so on) searchable.
 
-For example, adding these lines to `config/application.rb` and removing any other log overrides from other environments, will switch automatically to structured logging when running inside Kubernetes:
-~~~ruby
-    # Setup structured logging
-    config.semantic_logger.application = "my_application"
-    config.semantic_logger.environment = ENV["STACK_NAME"] || Rails.env
-    config.log_level = ENV["LOG_LEVEL"] || :info
-
-    # Switch to JSON Logging output to stdout when running on Kubernetes
-    if ENV["LOG_TO_CONSOLE"] || ENV["KUBERNETES_SERVICE_HOST"]
-      config.rails_semantic_logger.add_file_appender = false
-      config.semantic_logger.add_appender(io: $stdout, formatter: :json)
-    end
-~~~
+## Installation
 
-Then configure the centralized logging system to tell it that the data is in JSON format, so that it will parse it for you into a hierarchy.
+Add to your `Gemfile`:
 
-For example, the following will instruct [Observe](https://www.observeinc.com/) to parse the JSON data and create machine readable data from it:
 ~~~ruby
-interface "log", "log":log
-
-make_col event:parse_json(log)
-
-make_col
-   time:parse_isotime(event.timestamp),
-   application:string(event.application),
-   environment:string(event.environment),
-   duration:duration_ms(event.duration_ms),
-   level:string(event.level),
-   name:string(event.name),
-   message:string(event.message),
-   named_tags:event.named_tags,
-   payload:event.payload,
-   metric:string(event.metric),
-   metric_amount:float64(event.metric_amount),
-   tags:array(event.tags),
-   exception:event.exception,
-   host:string(event.host),
-   pid:int64(event.pid),
-   thread:string(event.thread),
-   file:string(event.file),
-   line:int64(event.line),
-   dimensions:event.dimensions,
-   backtrace:array(event.backtrace),
-   level_index:int64(event.level_index)
-
-set_valid_from(time)
-drop_col timestamp, log, event, stream
-rename_col timestamp:time
+gem "rails_semantic_logger"
+gem "amazing_print" # optional, colorizes the structured payload in development
 ~~~
 
-Now queries can be built to drill down into each of these fields, including `payload` which is a nested object.
+Then run `bundle install`. That is all that is required: Rails Semantic Logger automatically replaces the standard Rails logger and writes to the usual Rails log file.
 
-For example to find all failed Sidekiq job calls where the causing exception class name is `NoMethodError`:
-~~~ruby
-filter environment = "uat2"
-filter level = "error"
-filter metric = "sidekiq.job.perform"
-filter (string(exception.cause.name) = "NoMethodError")
-~~~
+Remove the following gems if present, they conflict with or duplicate what this gem already does: `lograge`, `rails_stdout_logging`, `rails_12factor`.
 
-Example: create a dashboard showing the duration of all successful Sidekiq jobs:
-~~~ruby
-filter environment = "production"
-filter level = "info"
-filter metric = "sidekiq.job.perform"
-timechart duration:avg(duration), group_by(name)
-~~~
+## Out of the box
 
-Example: create a dashboard showing the queue latency of all Sidekiq jobs. 
-The queue latency is the time between when the job was enqueued and when it was started:
-~~~ruby
-filter environment = "production"
-filter level = "info"
-filter metric = "sidekiq.queue.latency"
-timechart latency:avg(metric_amount/1000), group_by(string(named_tags.queue))
-~~~
+With no configuration at all, Rails Semantic Logger:
 
-* http://github.com/reidmorrison/rails_semantic_logger
+- Writes to `log/<environment>.log`, the same file Rails uses, colorized when Rails colorized logging is enabled.
+- Logs to **standard out** when you run `rails server`, so you see requests in your terminal.
+- Logs to **standard error** when you run `rails console`, so log lines do not get mixed up with command return values.
+- Replaces the multi-line Rails request log with a single structured "Completed" line.
 
-## Documentation
+## Configuring where logs go: the appenders block
 
-For complete documentation see: https://logger.rocketjob.io/rails
+An **appender** is a destination for log output: a file, standard out, a centralized log service, and so on. Declare the appenders you want in a single block. **The method name says _when_ the appender is created; the arguments say _where_ it writes and _how_ it is formatted.**
 
-## Upgrading to Semantic Logger V4.16 - Sidekiq Metrics Support
+| Method | Created when… | Default destination |
+|--------|---------------|---------------------|
+| `add` | Always, during Rails initialization | (you must specify one) |
+| `add_server` | Only when serving requests: `rails server`, a rack server, Sidekiq in server mode | `$stdout` |
+| `add_console` | Only inside a `rails console` session | `$stderr` |
 
-Rails Semantic Logger now supports Sidekiq metrics. 
-Below are the metrics that are now available when the JSON logging format is used:
-- `sidekiq.job.perform`
-  - The duration of each Sidekiq job.
-  - `duration` contains the time in milliseconds that the job took to run.
-- `sidekiq.queue.latency` 
-  - The time between when a Sidekiq job was enqueued and when it was started.
-  - `metric_amount` contains the time in milliseconds that the job was waiting in the queue.
+The arguments to all three are exactly the arguments to `SemanticLogger.add_appender`, so anything Semantic Logger can log to, any of these can declare.
 
-## Upgrading to Semantic Logger v4.15 & V4.16 - Sidekiq Support
+> **Important:** As soon as you declare **any** appender in this block, Rails Semantic Logger stops adding **all** of its automatic appenders (the default `log/<env>.log` file, the standard-out logger under `rails server`, and the standard-error logger in `rails console`). The block becomes the single source of truth for every destination.
 
-Rails Semantic Logger introduces direct support for Sidekiq v4, v5, v6, and v7. 
-Please remove any previous custom patches or configurations to make Sidekiq work with Semantic Logger.
-To see the complete list of patches being made, and to contribute your own changes, see: [Sidekiq Patches](https://github.com/reidmorrison/rails_semantic_logger/blob/master/lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb)
+A typical development setup, a color log file plus color to the screen while serving:
 
-## Upgrading to Semantic Logger v4.4
+~~~ruby
+config.rails_semantic_logger.appenders do |appenders|
+  appenders.add(file_name: "log/#{Rails.env}.log", formatter: :color)
+  appenders.add_server(formatter: :color) # → $stdout, only when serving
+end
+~~~
 
-With some forking frameworks it is necessary to call `reopen` after the fork. With v4.4 the
-workaround for Ruby 2.5 crashes is no longer needed. 
-I.e. Please remove the following line if being called anywhere:
+On a container platform (Docker, Kubernetes, Heroku), log JSON to standard out and let the platform collect it:
 
 ~~~ruby
-SemanticLogger::Processor.instance.instance_variable_set(:@queue, Queue.new)
+config.rails_semantic_logger.appenders do |appenders|
+  appenders.add(io: $stdout, formatter: :json)
+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.
+
+## Documentation
+
+For complete documentation see: https://logger.rocketjob.io/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)
+for older releases.
+
 ## New Versions of Rails, etc.
 
 The primary purpose of the Rails Semantic Logger gem is to patch other gems, primarily Rails, to make them support structured logging though Semantic Logger.
@@ -136,7 +93,7 @@ Additionally, when new popular gems come out, we rely only the community to supp
 
 ## Supported Platforms
 
-For the complete list of supported Ruby and Rails versions, see the [Testing file](https://github.com/reidmorrison/rails_semantic_logger/blob/master/.github/workflows/ci.yml).
+For the complete list of supported Ruby and Rails versions, see the [Testing file](https://github.com/reidmorrison/rails_semantic_logger/blob/main/.github/workflows/ci.yml).
 
 ## Author
 

data/Rakefile

@@ -10,8 +10,8 @@ task :gem do
 end
 
 task publish: :gem do
-  # system "git tag -a v#{RailsSemanticLogger::VERSION} -m 'Tagging #{RailsSemanticLogger::VERSION}'"
-  # system "git push --tags"
+  system "git tag -a v#{RailsSemanticLogger::VERSION} -m 'Tagging #{RailsSemanticLogger::VERSION}'"
+  system "git push --tags"
   system "gem push rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
   system "rm rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
 end
@@ -22,10 +22,13 @@ Rake::TestTask.new(:test) do |t|
   t.warning = false
 end
 
-# By default run tests against all appraisals
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+# By default lint once, then run tests against all appraisals
 if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
   require "appraisal"
-  task default: :appraisal
+  task default: %i[rubocop appraisal]
 else
   task default: :test
 end

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -1,19 +1,39 @@
+# This subscriber is a reimplementation of Rails' own ActionController::LogSubscriber that emits
+# structured (message + payload) log entries instead of formatted text. When Rails changes its
+# subscriber, those changes must be brought across here. Compare against the upstream source for
+# each supported Rails version:
+#
+#   Rails 8.1: https://github.com/rails/rails/blob/8-1-stable/actionpack/lib/action_controller/log_subscriber.rb
+#   Rails 8.0: https://github.com/rails/rails/blob/8-0-stable/actionpack/lib/action_controller/log_subscriber.rb
+#   Rails 7.2: https://github.com/rails/rails/blob/7-2-stable/actionpack/lib/action_controller/log_subscriber.rb
+#
 module RailsSemanticLogger
   module ActionController
     class LogSubscriber < ActiveSupport::LogSubscriber
       INTERNAL_PARAMS = %w[controller action format _method only_path].freeze
 
+      class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
       class << self
-        attr_accessor :action_message_format
+        attr_accessor :action_message_format, :processing_log_level
       end
 
-      # Log as debug to hide Processing messages in production
+      # Defaults to :debug so the Processing message is hidden in production. The engine raises it
+      # to :info when `config.rails_semantic_logger.processing` is true.
+      @processing_log_level = :debug
+
       def start_processing(event)
-        controller_logger(event).debug { action_message("Processing", event.payload) }
+        controller_logger(event).send(self.class.processing_log_level) { action_message("Processing", event.payload) }
       end
 
       def process_action(event)
         controller_logger(event).info do
+          # `event.payload` is shared with every other subscriber on this notification, so we work on
+          # a copy. A shallow `dup` is sufficient: only mutate `payload` via top-level key reassignment
+          # (e.g. `payload[:format] = ...`) or by writing into a freshly-created hash (e.g. the `.except`
+          # result below). Never mutate a nested object that still belongs to the original payload
+          # (e.g. `payload[:foo][:bar] = ...` on an unduped key), or the change will leak back into the
+          # shared payload and corrupt what other subscribers see.
           payload = event.payload.dup
 
           # Unused, but needed for Devise 401 status code monkey patch to still work.
@@ -51,47 +71,93 @@ module RailsSemanticLogger
             payload[key] = payload[key].to_f.round(2) if key.to_s =~ /(.*)_runtime/
           end
 
-          # Rails 6+ includes allocation count
-          payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+          payload[:allocations] = event.allocations
+          payload[:cpu_time]    = event.cpu_time.round(2)
+          payload[:idle_time]   = event.idle_time.round(2)
+          payload[:gc_time]     = event.gc_time.round(2) if event.respond_to?(:gc_time)
 
           payload[:status_message] = ::Rack::Utils::HTTP_STATUS_CODES[payload[:status]] if payload[:status].present?
 
-          # Causes excessive log output with Rails 5 RC1
           payload.delete(:headers)
-          # Causes recursion in Rails 6.1.rc1
           payload.delete(:request)
           payload.delete(:response)
 
           {
             message:  action_message("Completed", event.payload),
             duration: event.duration,
-            payload:  payload
+            payload:  payload,
+            metric:   "rails.controller.process_action"
           }
         end
       end
 
       def halted_callback(event)
-        controller_logger(event).info { "Filter chain halted as #{event.payload[:filter].inspect} rendered or redirected" }
+        controller_logger(event).info do
+          {
+            message: "Filter chain halted as #{event.payload[:filter].inspect} rendered or redirected",
+            metric:  "rails.controller.halted_callback"
+          }
+        end
+      end
+
+      # Rails 8.1+ emits this event when an exception is handled by a `rescue_from` callback.
+      # On earlier Rails versions the event is never instrumented, so this handler is dormant.
+      def rescue_from_callback(event)
+        controller_logger(event).info do
+          exception = event.payload[:exception]
+          backtrace = exception.backtrace&.first
+          backtrace = backtrace&.delete_prefix("#{Rails.root}/") if defined?(Rails.root) && Rails.root
+
+          {
+            message: "rescue_from handled #{exception.class}",
+            payload: {
+              exception:         exception.class.name,
+              exception_message: exception.message,
+              backtrace:         backtrace
+            },
+            metric:  "rails.controller.rescue_from_callback"
+          }
+        end
       end
 
       def send_file(event)
-        controller_logger(event).info(message: "Sent file", payload: {path: event.payload[:path]}, duration: event.duration)
+        controller_logger(event).info(message:  "Sent file",
+                                      payload:  {path: event.payload[:path]},
+                                      duration: event.duration,
+                                      metric:   "rails.controller.send_file")
       end
 
       def redirect_to(event)
-        controller_logger(event).info(message: "Redirected to", payload: {location: event.payload[:location]})
+        payload = {location: event.payload[:location]}
+
+        # Rails 8.1+ optionally logs the source location of the redirect when
+        # ActionDispatch.verbose_redirect_logs is enabled.
+        if ActionDispatch.respond_to?(:verbose_redirect_logs) && ActionDispatch.verbose_redirect_logs
+          source           = redirect_source_location
+          payload[:source] = source if source
+        end
+
+        controller_logger(event).info(message: "Redirected to", payload: payload, metric: "rails.controller.redirect_to")
       end
 
       def send_data(event)
         controller_logger(event).info(message:  "Sent data",
                                       payload:  {file_name: event.payload[:filename]},
-                                      duration: event.duration)
+                                      duration: event.duration,
+                                      metric:   "rails.controller.send_data")
       end
 
       def unpermitted_parameters(event)
         controller_logger(event).debug do
           unpermitted_keys = event.payload[:keys]
-          "Unpermitted parameter#{'s' if unpermitted_keys.size > 1}: #{unpermitted_keys.join(', ')}"
+          payload          = {keys: unpermitted_keys}
+          # Rails includes the controller/action context alongside the rejected keys.
+          payload[:context] = event.payload[:context] if event.payload[:context]
+
+          {
+            message: "Unpermitted parameter#{'s' if unpermitted_keys.size > 1}: #{unpermitted_keys.join(', ')}",
+            payload: payload
+          }
         end
       end
 
@@ -99,11 +165,10 @@ module RailsSemanticLogger
          expire_fragment expire_page write_page].each do |method|
         class_eval <<-METHOD, __FILE__, __LINE__ + 1
           def #{method}(event)
-            # enable_fragment_cache_logging as of Rails 5
-            return if ::ActionController::Base.respond_to?(:enable_fragment_cache_logging) && !::ActionController::Base.enable_fragment_cache_logging
+            return unless ::ActionController::Base.enable_fragment_cache_logging
             controller_logger(event).info do
               key_or_path = event.payload[:key] || event.payload[:path]
-              {message: "#{method.to_s.humanize} \#{key_or_path}", duration: event.duration}
+              {message: "#{method.to_s.humanize} \#{key_or_path}", duration: event.duration, metric: "rails.controller.#{method.delete('?')}"}
             end
           end
         METHOD
@@ -127,6 +192,11 @@ module RailsSemanticLogger
         index ? path[0, index] : path
       end
 
+      # Rails 8.1+ BacktraceCleaner exposes #first_clean_frame for verbose redirect logging.
+      def redirect_source_location
+        backtrace_cleaner.first_clean_frame if backtrace_cleaner.respond_to?(:first_clean_frame)
+      end
+
       def action_message(message, payload)
         if self.class.action_message_format
           self.class.action_message_format.call(message, payload)

data/lib/rails_semantic_logger/action_mailer/log_subscriber.rb

@@ -1,10 +1,23 @@
 require "active_support/log_subscriber"
 require "action_mailer"
 
+# This subscriber is a reimplementation of Rails' own ActionMailer::LogSubscriber that emits
+# structured (message + payload) log entries instead of formatted text. When Rails changes its
+# subscriber, those changes must be brought across here. Compare against the upstream source for
+# each supported Rails version:
+#
+#   Rails 8.1: https://github.com/rails/rails/blob/8-1-stable/actionmailer/lib/action_mailer/log_subscriber.rb
+#   Rails 8.0: https://github.com/rails/rails/blob/8-0-stable/actionmailer/lib/action_mailer/log_subscriber.rb
+#   Rails 7.2: https://github.com/rails/rails/blob/7-2-stable/actionmailer/lib/action_mailer/log_subscriber.rb
+#
 module RailsSemanticLogger
   module ActionMailer
     class LogSubscriber < ::ActiveSupport::LogSubscriber
       def deliver(event)
+        # Rails gates this event with `subscribe_log_level :deliver, :debug`, so the upstream
+        # subscriber only runs when the logger is at debug level (or lower). Match that here.
+        return unless logger.debug?
+
         ex = event.payload[:exception_object]
         message_id = event.payload[:message_id]
         duration = event.duration.round(1)
@@ -31,10 +44,14 @@ module RailsSemanticLogger
 
       # An email was generated.
       def process(event)
+        # Rails gates this event with `subscribe_log_level :process, :debug` and emits the message
+        # at debug level. Match both the gating and the level here.
+        return unless logger.debug?
+
         mailer   = event.payload[:mailer]
         action   = event.payload[:action]
         duration = event.duration.round(1)
-        log_with_formatter event: event do |_fmt|
+        log_with_formatter event: event, level: :debug do |_fmt|
           {message: "#{mailer}##{action}: processed outbound mail in #{duration}ms"}
         end
       end
@@ -47,34 +64,30 @@ module RailsSemanticLogger
           @log_duration = log_duration
         end
 
-        def mailer
-          event.payload[:mailer]
-        end
-
         def payload
+          p = event.payload
           {}.tap do |h|
             h[:event_name]         = event.name
             h[:mailer]             = mailer
             h[:action]             = action
-            h[:message_id]         = event.payload[:message_id]
-            h[:perform_deliveries] = event.payload[:perform_deliveries]
-            h[:subject]            = event.payload[:subject]
-            h[:to]                 = event.payload[:to]
-            h[:from]               = event.payload[:from]
-            h[:bcc]                = event.payload[:bcc]
-            h[:cc]                 = event.payload[:cc]
+            h[:message_id]         = p[:message_id]
+            h[:perform_deliveries] = p[:perform_deliveries]
+            h[:subject]            = p[:subject]
+            h[:to]                 = p[:to]
+            h[:from]               = p[:from]
+            h[:bcc]                = p[:bcc]
+            h[:cc]                 = p[:cc]
             h[:date]               = date
+            # Rails dumps the full encoded message at debug level via `debug { event.payload[:mail] }`.
+            # The `deliver` event is debug-gated, so include it here whenever it is present.
+            h[:mail]               = p[:mail] if p[:mail]
             h[:duration]           = event.duration.round(2) if log_duration?
             h[:args]               = formatted_args
           end
         end
 
         def date
-          if event.payload[:date].respond_to?(:to_time)
-            event.payload[:date].to_time.utc
-          elsif event.payload[:date].is_a?(String)
-            Time.parse(date).utc
-          end
+          event.payload[:date].to_time.utc if event.payload[:date].respond_to?(:to_time)
         end
 
         private
@@ -90,11 +103,9 @@ module RailsSemanticLogger
         end
 
         def formatted_args
-          if defined?(mailer.constantize.log_arguments?) && !mailer.constantize.log_arguments?
-            ""
-          elsif event.payload[:args].present?
-            JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) })
-          end
+          return unless event.payload[:args].present?
+
+          JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) })
         end
 
         def format(arg)
@@ -122,6 +133,9 @@ module RailsSemanticLogger
       def log_with_formatter(level: :info, **kw_args)
         fmt = EventFormatter.new(**kw_args)
         msg = yield fmt
+        # Emit a metric for every info/warn/error entry, named after the notification
+        # (e.g. "deliver.action_mailer" -> "rails.mailer.deliver"). Debug entries (process) are excluded.
+        msg[:metric] ||= "rails.mailer.#{kw_args[:event].name.split('.').first}" unless level == :debug
         logger.public_send(level, **msg, payload: fmt.payload)
       end