activesupport-json_logging 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c99bef73cc6bf2627075656ee38a3e3b756ac61ef54f2edcc628814b317ac7bf
-  data.tar.gz: c4a0e1ecfd0ae8862db0167cc5507b8da4572e6a58ed4035ec7aa606c3154442
+  metadata.gz: 71ac52d26c4cca14a0eaed618927f9432880865ad9b24e43232b5801ce10a055
+  data.tar.gz: 81ef2c90e5d44fc7910f319acdbbd4bb9b56572075c6a28050fd05759349e91b
 SHA512:
-  metadata.gz: 3abb724226828b28519f25dc8edb138c3b4d7dc1a07bf2946b952e46bee4bef5d71149a44df4a52cb12e41f892ca4d2f7147bfdeb9dbd7ad0ca3c4ee3873dddc
-  data.tar.gz: 25b2c9f5ae0c8107e4f5c7385ff96fbb379cbfba851234be9800909978b14d1d81b5fab961a5d72bd1d4ede78c5d1d16eb5ab1534e6ed54d2074e1c21456395c
+  metadata.gz: 0f8ebdfeb94e456cdffd8e8d176c9dde7dff4187f2547b721dd4ec33e229c290663386a1f1c091ee54e95821be3bc11eb8f02fbf645f3a9bd8a54ab1e79596b9
+  data.tar.gz: cbfdad0f75642ec096bf18ca154a9aef9ce3364d92a43c263ceea81f877f018db3459b1a3fc239b2025aa6d96815db8f37063675f33a29d24fd24de4eaeb2299

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # CHANGELOG
 
+## 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
+- Refactor timestamp handling in JsonLogging helpers to support Time.zone
+- Add Ruby 4.0 support in gemspec and Appraisal configurations
+
 ## 1.2.0 (2025-11-07)
 
 - Add support for service-specific tagged loggers: create loggers with permanent tags using `logger.tagged("service")` without a block

data/README.md

@@ -1,6 +1,6 @@
 # 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)
+[![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)
 
 Structured JSON logging for Rails and ActiveSupport with a safe, single-line formatter.
 No dependencies beyond Rails and Activesupport.
@@ -283,6 +283,8 @@ end
 
 If you use Lograge, configure it to feed raw hashes and let this gem handle JSON formatting. This example shows a complete setup including all Rails component loggers and common third-party libraries:
 
+**Important:** When using Lograge, `config.log_tags` does not work for adding fields to Lograge output. Instead, use `config.lograge.custom_options` to add custom fields to your request logs.
+
 ```ruby
 # config/initializers/lograge.rb
 # Note: require is optional in Rails apps (auto-loaded via Railtie)
@@ -295,8 +297,26 @@ Rails.application.configure do
   config.lograge.formatter = Lograge::Formatters::Raw.new
   config.lograge.keep_original_rails_log = ENV["DEBUG"] ? true : false
 
-  # Merge additional context into Lograge output
-  config.lograge.custom_options = ->(_event) { JsonLogging.additional_context }
+  # Add custom fields to Lograge output
+  # Note: config.log_tags does NOT work with Lograge - use custom_options instead
+  config.lograge.custom_options = ->(event) {
+    {
+      remote_ip: Current.remote_addr,
+      request_id: Current.request_id,
+      user_agent: Current.user_agent,
+      user_id: Current.user&.id
+    }
+  }
+
+  # Optionally merge additional context from JsonLogging.with_context
+  # config.lograge.custom_options = ->(event) {
+  #   {
+  #     remote_ip: Current.remote_addr,
+  #     request_id: Current.request_id,
+  #     user_agent: Current.user_agent,
+  #     user_id: Current.user&.id
+  #   }.merge(JsonLogging.additional_context)
+  # }
 
   # Build unified JSON logger
   logdev = Rails.env.production? ? Rails.root.join("log", "#{Rails.env}.log") : $stdout
@@ -306,7 +326,6 @@ Rails.application.configure do
 
   # Set the main Rails logger
   config.logger = json_logger
-  config.log_tags = [:request_id, :remote_ip]
 
   # Override Rails.logger to ensure it uses our formatter
   Rails.logger = json_logger
@@ -327,13 +346,6 @@ Rails.application.configure do
 
   # Disable verbose enqueue logs to reduce noise
   config.active_job.verbose_enqueue_logs = false
-
-  # Optional: Customize log tags based on request
-  # config.log_tags = [
-  #   :request_id,
-  #   ->(request) { request.remote_ip },
-  #   ->(request) { request.subdomain }
-  # ]
 end
 ```
 
@@ -594,27 +606,10 @@ The gem will automatically filter these from all log entries, including context
 
 ## Development
 
-```bash
-# Install dependencies
-bundle install
-bundle exec appraisal generate
-
-# Run tests for current Rails version
-bundle exec rspec
+Run release.rb script to prepare code for publishing, it has all the required checks and tests.
 
-# Run tests for all Rails versions (6.0, 6.1, 7.0, 7.1, 7.2, 8.0)
-bin/appraisals
-
-# Run tests for specific Rails version
-bin/appraisals rails-7.0
-
-# Run tests for multiple versions
-bin/appraisals rails-7.0 rails-8.0
-
-# Or use appraisal directly
-bundle exec appraisal rails-7.0 rspec
-
-bundle exec standardrb --fix
+```bash
+usr/bin/release.rb
 ```
 
 ### Development: Using from Local Repository

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

@@ -10,28 +10,31 @@ module JsonLogging
     def current_tags
       # If LocalTagStorage is extended on this formatter, use its tag_stack
       # This matches Rails' TaggedLogging behavior where tag_stack attribute shadows the method
-      if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
-        tag_stack.tags
+      if (stack = current_tag_stack)
+        stack.tags
       else
         @logger.send(:current_tags)
       end
     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
 
     def push_tags(*tags)
       # If LocalTagStorage is present, use it; otherwise use logger's thread-local storage
-      if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
-        tag_stack.push_tags(tags)
+      if (stack = current_tag_stack)
+        stack.push_tags(tags)
       else
         @logger.send(:push_tags, tags)
       end
@@ -40,14 +43,12 @@ module JsonLogging
     # Support tagged blocks for formatter
     def tagged(*tags)
       if block_given?
-        # If LocalTagStorage is present, use it; otherwise use logger's thread-local storage
-        if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
-          previous_count = tag_stack.tags.size
-          tag_stack.push_tags(tags)
+        if (stack = current_tag_stack)
+          pushed_count = stack.push_tags(tags).size
           begin
             yield @logger
           ensure
-            tag_stack.pop_tags(tag_stack.tags.size - previous_count)
+            stack.pop_tags(pushed_count)
           end
         else
           previous = @logger.send(:current_tags).dup
@@ -59,8 +60,8 @@ module JsonLogging
           end
         end
       else
-        if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
-          tag_stack.push_tags(tags)
+        if (stack = current_tag_stack)
+          stack.push_tags(tags)
         else
           @logger.send(:push_tags, tags)
         end
@@ -70,18 +71,35 @@ module JsonLogging
 
     private
 
+    # Returns the current tag_stack to use, checking in order:
+    # 1. This formatter's tag_stack (if LocalTagStorage is extended)
+    # 2. Logger's formatter's tag_stack (if it has LocalTagStorage)
+    # 3. nil (fall back to thread-local storage)
+    def current_tag_stack
+      if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
+        tag_stack
+      elsif logger_formatter_has_tag_stack?
+        @logger.formatter.tag_stack
+      end
+    end
+
+    def logger_formatter_has_tag_stack?
+      @logger.formatter.respond_to?(:tag_stack, true) &&
+        @logger.formatter.instance_variable_defined?(:@tag_stack)
+    end
+
     def build_fallback_output(severity, timestamp, msg, error)
       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,10 +1,35 @@
 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)
-      (timestamp || Time.now).utc.iso8601(6)
+      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
+        Time.zone.now
+      else
+        Time.now
+      end
     end
 
     # Safely convert object to string, never raises

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(Time.now),
-        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,6 +67,28 @@ 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
@@ -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(Time.now)
-      )
-      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,13 +154,16 @@ 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
 
       def pop_tags(count = 1)
+        return [] if count <= 0
+
         @tags.pop(count)
       end