activesupport-json_logging 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 879dfb3d0d8142a294407c70771d234e55d410032dbc50f035bf85f3bd33b79a
-  data.tar.gz: bfa9d0637d5e84f58acdf407ce782feda91b584c5c63700b93ec2aa4e6e59dd4
+  metadata.gz: 2b40f43e3cd600bfc139665fa3e6cc9df7a4a56eab58bec7f760b986faa9d2f7
+  data.tar.gz: d8d3352e482dc9698aa94a499f9905a1fdec0ca157cedf4e8a61194dfd7e7fba
 SHA512:
-  metadata.gz: e4ed4ef5739e411af61e6186581ec30aa3f0653c557d7f2bc088abf264a3e8608c483b0790b892a7e1c10674d55811f95a5a3e4c33d073cd59949469e732e875
-  data.tar.gz: ec86db106814dee2731695159275fb7c56700d36564571edd72e54013d076dd1a3328a050eae06429d16eaaf1c0538404ae8345605d5a2ec63684ca1f71f40b7
+  metadata.gz: 4b0befde4733aeade6f332adaf529735ed718fc5b4ad03dbbcbcd6d66e0124ed107e508f47fc3efa70f4fc31479d61ac42508d364c185c846a9c93ce51924cac
+  data.tar.gz: 83b705a450abaf4b389495652843bc4ed537de7485bb1158423b5a9055e40616024ed928844a485d65aa26cadfbe64746570dd823943dc724b29e849dcbd7ecf

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # CHANGELOG
 
+## 1.3.0 (2026-07-25)
+
+- BREAKING: Require Ruby 3.2+ and Rails 7+ (drop Ruby 2.7–3.1 and Rails 6 support)
+- Add opt-in `JsonLogging::EventSubscriber` for Rails 8.1 `ActiveSupport::EventReporter` / `Rails.event` structured events
+
+## 1.2.3 (2026-07-13)
+
+- Reduce per-line work for plain string, hash, tagged, and context-scoped log messages on common shapes
+- Sanitize flat and nested structured hash payloads without deep-copying the source when values are logging-safe primitives
+- Reuse ISO8601 microsecond UTC timestamps when callers already supply them
+- Skip context merging when tags and additional context are both empty
+- Cache empty thread context as a frozen hash on the hot path
+- Expand hot-path contract specs for fast-path logging and sanitization
+- Encode large nested structured hash log lines in one pass with copy-on-write sanitization and JSON.generate instead of building a full sanitized tree first
+
+## 1.2.2 (2026-07-08)
+
+- Isolate log context per execution via `ActiveSupport::IsolatedExecutionState` when available
+- Sanitize fallback formatter output when JSON encoding fails
+- Refactor emit path into `LineEncoder`, `PayloadBuilder`, and `Severity` modules
+- Cache sanitized `additional_context` per `with_context` scope on the hot path
+- Memoize `ActiveSupport::ParameterFilter` when `filter_parameters` is unchanged
+- Fast-path `sanitize_string` for clean ASCII text within length limits
+- Sanitize tags at push time instead of on every log line
+- Skip `deep_stringify_keys` when payload structure already uses string keys
+- Add hot-path optimization specs
+
 ## 1.2.1 (2026-01-18)
 
 - Refactor tag stack handling in JsonLogging formatter for improved maintainability

data/README.md

@@ -1,17 +1,10 @@
 # activesupport-json_logging
 
-[![Gem Version](https://badge.fury.io/rb/activesupport-json_logging.svg)](https://badge.fury.io/rb/activesupport-json_logging) [![Test Status](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/activesupport-json_logging.rb/graph/badge.svg?token=UX80FTO0Y0)](https://codecov.io/gh/amkisko/activesupport-json_logging.rb) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=amkisko_activesupport-json_logging.rb&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=amkisko_activesupport-json_logging.rb)
+[![Gem Version](https://badge.fury.io/rb/activesupport-json_logging.svg)](https://badge.fury.io/rb/activesupport-json_logging) [![Test Status](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/activesupport-json_logging.rb/graph/badge.svg?token=UX80FTO0Y0)](https://app.codecov.io/github/amkisko/activesupport-json_logging.rb) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=amkisko_activesupport-json_logging.rb&metric=alert_status)](https://sonarcloud.io/project/overview?id=amkisko_activesupport-json_logging.rb)
 
 Structured JSON logging for Rails and ActiveSupport with a safe, single-line formatter.
 No dependencies beyond Rails and Activesupport.
-Supports Rails versions from 6 to 8.
-
-Sponsored by [Kisko Labs](https://www.kiskolabs.com).
-
-<a href="https://www.kiskolabs.com">
-  <img src="kisko.svg" width="200" alt="Sponsored by Kisko Labs" />
-</a>
-
+Supports Ruby 3.2+ and Rails 7–8.
 
 ## Installation
 
@@ -46,6 +39,7 @@ end
 - Native `tagged` method support - use it just like Rails' tagged logger
 - Service-specific tagged loggers - create loggers with permanent tags using `logger.tagged("service")` without a block
 - Full compatibility with `ActiveSupport::BroadcastLogger` (Rails 7.1+)
+- Opt-in `JsonLogging::EventSubscriber` for Rails 8.1 `ActiveSupport::EventReporter` / `Rails.event`
 - Automatic Rails integration via Railtie (auto-requires the gem in Rails apps)
 
 ## Basic usage
@@ -132,6 +126,37 @@ sidekiq_logger.info("Job enqueued")      # Tagged with "sidekiq"
 api_logger.info("Request received")      # Tagged with "api"
 ```
 
+### Rails 8.1 Event Reporter
+
+Rails 8.1 adds `Rails.event` (`ActiveSupport::EventReporter`) for structured events that complement `Rails.logger`. Setting `config.logger` to a `JsonLogging` logger does not subscribe you to events. Register a subscriber:
+
+```ruby
+# config/initializers/json_logging.rb
+subscriber = JsonLogging::EventSubscriber.new(logger: -> { Rails.logger })
+Rails.event.subscribe(subscriber)
+
+# Optional: only a subset of events
+Rails.event.subscribe(subscriber) { |event| event[:name].start_with?("app.") }
+```
+
+Pass either `logger:` or `io:`, not both. A callable `logger:` is resolved on each emit (the Railtie opt-in uses this so a later `Rails.logger=` swap is picked up).
+
+Or enable the Railtie opt-in (off by default):
+
+```ruby
+# config/application.rb or an environment file
+config.json_logging.subscribe_event_reporter = true
+```
+
+The subscriber writes one JSON line per event and keeps the Rails event shape (`name`, `payload`, `tags`, `context`, `timestamp`, `source_location`). It writes through `Logger#<<` so the logger formatter does not wrap the event again. Payload and tag objects that implement `#serialize` are encoded via that method. Encode and write failures never raise from `#emit`.
+
+```ruby
+Rails.event.set_context(request_id: "abc123")
+Rails.event.tagged("billing") do
+  Rails.event.notify("invoice.created", invoice_id: 3)
+end
+```
+
 ### BroadcastLogger integration
 
 `ActiveSupport::BroadcastLogger` (Rails 7.1+) allows writing logs to multiple destinations simultaneously. `JsonLogging` works seamlessly with `BroadcastLogger`:
@@ -460,6 +485,16 @@ formatter.call("INFO", Time.now, nil, "message")  # Output includes both tags
 
 **Note:** When used with a logger (via `JsonLogging.new`), the logger uses `FormatterWithTags` which automatically includes tags from the logger's tagged context. Use `Formatter` directly only when you need a standalone formatter without a logger instance.
 
+### JsonLogging::EventSubscriber
+
+Rails 8.1+ subscriber for `ActiveSupport::EventReporter`. See [Rails 8.1 Event Reporter](#rails-81-event-reporter).
+
+```ruby
+subscriber = JsonLogging::EventSubscriber.new(logger: -> { Rails.logger })
+# or: JsonLogging::EventSubscriber.new(io: $stdout)
+Rails.event.subscribe(subscriber)
+```
+
 ### JsonLogging.with_context
 
 Add thread-local context that appears in all log entries within the block:
@@ -554,7 +589,7 @@ This is useful for:
 - Temporary verbose logging in background jobs
 - Per-request log level changes
 
-**Note:** `local_level` is available in Rails 7.1+. In Rails 6-7.0, only the global `level` is available.
+**Note:** `local_level` is available in Rails 7.1+. In Rails 7.0, only the global `level` is available.
 
 #### Standard Logger Methods
 
@@ -652,7 +687,28 @@ gem build activesupport-json_logging.gemspec
 gem push activesupport-json_logging-*.gem
 ```
 
+## Links
+
+- [GitHub](https://github.com/amkisko/activesupport-json_logging.rb)
+- [GitLab](https://gitlab.com/amkisko/activesupport-json_logging.rb)
+- [RubyGems](https://rubygems.org/gems/activesupport-json_logging)
+- [Versions Atom](https://rubygems.org/gems/activesupport-json_logging/versions.atom) (feed id `9801944970071`)
+- [libraries.io](https://libraries.io/rubygems/activesupport-json_logging)
+- [Deps.dev](https://deps.dev/rubygems/activesupport-json_logging)
+- [SonarCloud](https://sonarcloud.io/project/overview?id=amkisko_activesupport-json_logging.rb)
+- [Snyk](https://snyk.io/test/github/amkisko/activesupport-json_logging.rb)
+- [Codecov](https://app.codecov.io/github/amkisko/activesupport-json_logging.rb)
+- [OpenSSF Scorecard](https://scorecard.dev/viewer/?uri=github.com/amkisko/activesupport-json_logging.rb)
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+## Sponsors
+
+Sponsored by [Kisko Labs](https://www.kiskolabs.com).
+
+<a href="https://www.kiskolabs.com">
+  <img src="kisko.svg" width="200" alt="Sponsored by Kisko Labs" />
+</a>
+

data/lib/activesupport/json_logging/railtie.rb

@@ -2,7 +2,18 @@ require "json_logging"
 
 module JsonLogging
   class Railtie < ::Rails::Railtie
+    config.json_logging = ActiveSupport::OrderedOptions.new
+    config.json_logging.subscribe_event_reporter = false
+
     # This Railtie ensures json_logging is automatically required when Rails loads
     # Without this, users would need to manually require "json_logging" in initializers
+
+    initializer "json_logging.subscribe_event_reporter", after: :load_config_initializers do |app|
+      next unless app.config.json_logging.subscribe_event_reporter
+      next unless defined?(ActiveSupport::EventReporter)
+      next unless Rails.respond_to?(:event)
+
+      Rails.event.subscribe(JsonLogging::EventSubscriber.new(logger: -> { Rails.logger }))
+    end
   end
 end

data/lib/json_logging/event_subscriber.rb

@@ -0,0 +1,146 @@
+module JsonLogging
+  # Opt-in subscriber for ActiveSupport::EventReporter (Rails 8.1+).
+  # Preserves the Rails event hash shape as a single JSON line.
+  class EventSubscriber
+    def initialize(logger: nil, io: nil)
+      if !logger.nil? && !io.nil?
+        raise ArgumentError, "JsonLogging::EventSubscriber accepts only one of logger: or io:"
+      end
+      if logger.nil? && io.nil?
+        raise ArgumentError, "JsonLogging::EventSubscriber requires logger: or io:"
+      end
+
+      @logger = logger
+      @io = io
+    end
+
+    def emit(event)
+      line = begin
+        encode_event(event)
+      rescue => error
+        encode_fallback(event, error)
+      end
+
+      write_line(line)
+    rescue => error
+      report_write_error(error)
+      nil
+    end
+
+    private
+
+    def encode_event(event)
+      payload = {
+        "name" => Helpers.safe_string(event_field(event, :name)),
+        "payload" => serialize_payload(event_field(event, :payload)),
+        "tags" => serialize_tags(event_field(event, :tags)),
+        "context" => hash_or_empty(event_field(event, :context)),
+        "timestamp" => event_field(event, :timestamp)
+      }
+      source_location = event_field(event, :source_location)
+      payload["source_location"] = hash_or_empty(source_location) if source_location
+
+      LineEncoder.to_json_line(Sanitizer.sanitize_hash(payload))
+    end
+
+    def encode_fallback(event, error)
+      event_name = begin
+        Helpers.safe_string(event && event_field(event, :name))
+      rescue
+        nil
+      end
+
+      LineEncoder.to_json_line(
+        Sanitizer.sanitize_hash(
+          {
+            "name" => "json_logging.event_encode_error",
+            "event_name" => event_name,
+            "error" => {
+              "class" => error.class.name,
+              "message" => Helpers.safe_string(error.message)
+            }
+          }
+        )
+      )
+    end
+
+    def event_field(event, key)
+      return nil unless event.is_a?(Hash)
+
+      if event.key?(key)
+        event[key]
+      elsif event.key?(key.to_s)
+        event[key.to_s]
+      end
+    end
+
+    def serialize_payload(payload)
+      case payload
+      when Hash
+        payload
+      when nil
+        {}
+      else
+        serialize_object(payload)
+      end
+    end
+
+    def serialize_tags(tags)
+      return {} unless tags.is_a?(Hash)
+
+      tags.transform_values { |value| serialize_tag_value(value) }
+    end
+
+    def serialize_tag_value(value)
+      case value
+      when Hash, TrueClass, FalseClass, Numeric, NilClass, String
+        value
+      else
+        serialize_object(value)
+      end
+    end
+
+    def serialize_object(object)
+      if object.respond_to?(:serialize)
+        serialized = object.serialize
+        serialized.is_a?(Hash) ? serialized : {"value" => serialized}
+      elsif object.respond_to?(:to_h)
+        object.to_h
+      else
+        {
+          "class" => object.class.name,
+          "value" => Helpers.safe_string(object)
+        }
+      end
+    end
+
+    def hash_or_empty(value)
+      value.is_a?(Hash) ? value : {}
+    end
+
+    def write_line(line)
+      if @io
+        @io.write(line)
+      else
+        resolve_logger << line
+      end
+    end
+
+    def resolve_logger
+      logger = @logger
+      # Proc responds to << (composition); Logger responds to add.
+      return logger.call if logger.respond_to?(:call) && !logger.respond_to?(:add)
+
+      logger
+    end
+
+    def report_write_error(error)
+      return unless defined?(ActiveSupport) && ActiveSupport.respond_to?(:error_reporter)
+      return if ActiveSupport.error_reporter.nil?
+
+      ActiveSupport.error_reporter.report(error, handled: true, severity: :error)
+    rescue
+      nil
+    end
+  end
+end

data/lib/json_logging/formatter.rb

@@ -2,17 +2,21 @@ module JsonLogging
   class Formatter < ::Logger::Formatter
     def initialize(tags: [])
       super()
-      @tags = Array(tags)
+      @tags = Sanitizer.prepare_tags(tags)
     end
 
     attr_reader :tags
 
     def call(severity, timestamp, progname, msg)
-      timestamp_str = Helpers.normalize_timestamp(timestamp)
-      payload = PayloadBuilder.build_base_payload(msg, severity: severity, timestamp: timestamp_str)
-      payload = PayloadBuilder.merge_context(payload, additional_context: JsonLogging.additional_context.compact, tags: @tags)
-
-      "#{payload.compact.to_json}\n"
+      LineEncoder.build_line(
+        msg: msg,
+        severity: severity,
+        timestamp: Helpers.normalize_timestamp(timestamp),
+        tags: @tags,
+        additional_context: JsonLogging.additional_context_for_payload,
+        additional_context_sanitized: true,
+        sanitize_tags: false
+      )
     rescue => e
       build_fallback_output(severity, timestamp, msg, e)
     end
@@ -23,14 +27,14 @@ module JsonLogging
       timestamp_str = Helpers.normalize_timestamp(timestamp)
       fallback_payload = {
         timestamp: timestamp_str,
-        severity: severity,
-        message: Helpers.safe_string(msg),
+        severity: Severity.name_for(severity),
+        message: Sanitizer.sanitize_string(Helpers.safe_string(msg)),
         formatter_error: {
           class: Sanitizer.sanitize_string(error.class.name),
           message: Sanitizer.sanitize_string(Helpers.safe_string(error.message))
         }
       }
-      "#{fallback_payload.compact.to_json}\n"
+      LineEncoder.to_json_line(fallback_payload)
     end
   end
 end

data/lib/json_logging/formatter_with_tags.rb

@@ -18,12 +18,15 @@ module JsonLogging
     end
 
     def call(severity, timestamp, progname, msg)
-      tags = current_tags
-      timestamp_str = Helpers.normalize_timestamp(timestamp)
-      payload = PayloadBuilder.build_base_payload(msg, severity: severity, timestamp: timestamp_str)
-      payload = PayloadBuilder.merge_context(payload, additional_context: JsonLogging.additional_context.compact, tags: tags)
-
-      "#{payload.compact.to_json}\n"
+      LineEncoder.build_line(
+        msg: msg,
+        severity: severity,
+        timestamp: Helpers.normalize_timestamp(timestamp),
+        tags: current_tags,
+        additional_context: JsonLogging.additional_context_for_payload,
+        additional_context_sanitized: true,
+        sanitize_tags: false
+      )
     rescue => e
       build_fallback_output(severity, timestamp, msg, e)
     end
@@ -89,14 +92,14 @@ module JsonLogging
       timestamp_str = Helpers.normalize_timestamp(timestamp)
       fallback_payload = {
         timestamp: timestamp_str,
-        severity: severity,
-        message: Helpers.safe_string(msg),
+        severity: Severity.name_for(severity),
+        message: Sanitizer.sanitize_string(Helpers.safe_string(msg)),
         formatter_error: {
           class: Sanitizer.sanitize_string(error.class.name),
           message: Sanitizer.sanitize_string(Helpers.safe_string(error.message))
         }
       }
-      "#{fallback_payload.compact.to_json}\n"
+      LineEncoder.to_json_line(fallback_payload)
     end
   end
 end

data/lib/json_logging/helpers.rb

@@ -1,13 +1,28 @@
 module JsonLogging
   module Helpers
+    ISO8601_MICROSECOND_UTC_PATTERN = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z\z/
+
     module_function
 
     # Normalize timestamp to ISO8601 with microseconds
     def normalize_timestamp(timestamp)
-      time = timestamp || current_time
+      return timestamp if iso8601_microsecond_utc?(timestamp)
+
+      format_timestamp(timestamp || current_time)
+    end
+
+    def current_timestamp
+      format_timestamp(current_time)
+    end
+
+    def format_timestamp(time)
       time.utc.iso8601(6)
     end
 
+    def iso8601_microsecond_utc?(timestamp)
+      timestamp.is_a?(String) && timestamp.match?(ISO8601_MICROSECOND_UTC_PATTERN)
+    end
+
     # Get current time, using Time.zone if available, otherwise Time.now
     def current_time
       if defined?(Time.zone) && Time.zone

data/lib/json_logging/json_logger.rb

@@ -8,18 +8,16 @@ module JsonLogging
 
     def initialize(*args, **kwargs)
       # Initialize with minimal args to avoid ActiveSupport::Logger threading issues
-      # Rails 7+ supports kwargs, Rails 6 uses positional args only
       logdev = args.first || $stdout
       shift_age = args[1] || 0
       shift_size = args[2]
 
-      # Handle both positional and keyword arguments for Rails 6-8 compatibility
+      # Handle both positional and keyword arguments for Rails 7–8 compatibility
       if kwargs.empty? && shift_size
         super(logdev, shift_age, shift_size)
       elsif kwargs.empty?
         super(logdev, shift_age)
       else
-        # Rails 7+ may pass kwargs - delegate to parent
         super
       end
 

data/lib/json_logging/json_logger_extension.rb

@@ -2,15 +2,6 @@ module JsonLogging
   # Module that extends any Logger with JSON formatting capabilities
   # This is used by JsonLogging.new to wrap standard loggers
   module JsonLoggerExtension
-    SEVERITY_NAMES = {
-      ::Logger::DEBUG => "DEBUG",
-      ::Logger::INFO => "INFO",
-      ::Logger::WARN => "WARN",
-      ::Logger::ERROR => "ERROR",
-      ::Logger::FATAL => "FATAL",
-      ::Logger::UNKNOWN => "UNKNOWN"
-    }.freeze
-
     def formatter
       @formatter_with_tags ||= begin
         formatter_with_tags = FormatterWithTags.new(self)
@@ -19,46 +10,31 @@ module JsonLogging
       end
     end
 
-    def formatter=(formatter)
-      # Always use FormatterWithTags to ensure JSON formatting
+    def formatter=(_ignored)
+      # Custom formatters are ignored; JSON output requires FormatterWithTags.
       formatter_with_tags = @formatter_with_tags || FormatterWithTags.new(self)
       instance_variable_set(:@formatter, formatter_with_tags)
       @formatter_with_tags = formatter_with_tags
     end
 
-    def add(severity, message = nil, progname = nil)
+    def add(severity, message = nil, progname = nil, &block)
       return true if severity < level
 
-      msg = if message.nil?
-        if block_given?
-          yield
-        else
-          progname
-        end
-      else
-        message
-      end
-
-      payload = build_payload(severity, progname, msg)
-
-      stringified = stringify_keys(payload)
-      @logdev&.write("#{stringified.to_json}\n")
+      msg = nil
+      msg = extract_log_message(message, progname, &block)
+      line = LineEncoder.build_line(
+        msg: msg,
+        severity: severity,
+        timestamp: Helpers.current_timestamp,
+        tags: formatter.current_tags,
+        additional_context: JsonLogging.additional_context_for_payload,
+        additional_context_sanitized: true,
+        sanitize_tags: false
+      )
+      @logdev&.write(line)
       true
     rescue => e
-      # Never fail logging - write a fallback entry
-      # Initialize msg if it wasn't set due to error
-      msg ||= "<uninitialized>"
-
-      fallback = {
-        timestamp: Helpers.normalize_timestamp(Helpers.current_time),
-        severity: severity_name(severity),
-        message: Sanitizer.sanitize_string(Helpers.safe_string(msg)),
-        logger_error: {
-          class: Sanitizer.sanitize_string(e.class.name),
-          message: Sanitizer.sanitize_string(Helpers.safe_string(e.message))
-        }
-      }
-      @logdev&.write("#{fallback.compact.to_json}\n")
+      write_add_fallback(severity, msg, e)
       true
     end
 
@@ -91,13 +67,35 @@ module JsonLogging
 
     private
 
+    def extract_log_message(message, progname, &block)
+      if message.nil?
+        block ? block.call : progname
+      else
+        message
+      end
+    end
+
+    def write_add_fallback(severity, msg, error)
+      msg ||= "<uninitialized>"
+      fallback = {
+        timestamp: Helpers.current_timestamp,
+        severity: Severity.name_for(severity),
+        message: Sanitizer.sanitize_string(Helpers.safe_string(msg)),
+        logger_error: {
+          class: Sanitizer.sanitize_string(error.class.name),
+          message: Sanitizer.sanitize_string(Helpers.safe_string(error.message))
+        }
+      }
+      @logdev&.write(LineEncoder.to_json_line(fallback))
+    end
+
     def tags_key
       @tags_key ||= :"json_logging_tags_#{object_id}"
     end
 
     def current_tags
       # Use IsolatedExecutionState (Rails 7.1+) for better thread/Fiber safety
-      # Falls back to Thread.current for Rails 6-7.0
+      # Falls back to Thread.current for Rails 7.0
       if defined?(ActiveSupport::IsolatedExecutionState)
         ActiveSupport::IsolatedExecutionState[tags_key] ||= []
       else
@@ -107,7 +105,7 @@ module JsonLogging
 
     def set_tags(new_tags)
       # Use IsolatedExecutionState (Rails 7.1+) for better thread/Fiber safety
-      # Falls back to Thread.current for Rails 6-7.0
+      # Falls back to Thread.current for Rails 7.0
       if defined?(ActiveSupport::IsolatedExecutionState)
         ActiveSupport::IsolatedExecutionState[tags_key] = new_tags
       else
@@ -116,8 +114,9 @@ module JsonLogging
     end
 
     def push_tags(tags)
-      flat = tags.flatten.compact.map(&:to_s).reject(&:empty?)
+      flat = Sanitizer.prepare_tags(tags)
       return if flat.empty?
+
       set_tags(current_tags + flat)
     end
 
@@ -125,36 +124,12 @@ module JsonLogging
       set_tags([])
     end
 
-    def build_payload(severity, _progname, msg)
-      payload = PayloadBuilder.build_base_payload(
-        msg,
-        severity: severity_name(severity),
-        timestamp: Helpers.normalize_timestamp(Helpers.current_time)
-      )
-      payload = PayloadBuilder.merge_context(
-        payload,
-        additional_context: JsonLogging.additional_context.compact,
-        tags: formatter.current_tags
-      )
-
-      payload.compact
-    end
-
     def severity_name(severity)
-      SEVERITY_NAMES[severity] || severity.to_s
+      Severity.name_for(severity)
     end
 
-    def stringify_keys(hash)
-      case hash
-      when Hash
-        hash.each_with_object({}) do |(k, v), result|
-          result[k.to_s] = stringify_keys(v)
-        end
-      when Array
-        hash.map { |v| stringify_keys(v) }
-      else
-        hash
-      end
+    def stringify_keys(obj)
+      LineEncoder.deep_stringify_structure(obj)
     end
   end
 
@@ -179,8 +154,9 @@ module JsonLogging
       end
 
       def push_tags(tags)
-        flat = Array(tags).flatten.compact.map(&:to_s).reject(&:empty?)
+        flat = Sanitizer.prepare_tags(tags)
         return [] if flat.empty?
+
         @tags.concat(flat)
         flat
       end