activesupport-json_logging 1.3.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b40f43e3cd600bfc139665fa3e6cc9df7a4a56eab58bec7f760b986faa9d2f7
-  data.tar.gz: d8d3352e482dc9698aa94a499f9905a1fdec0ca157cedf4e8a61194dfd7e7fba
+  metadata.gz: 34ff048fcdd516e4f0f8e2b5d6d9911e44a6a486ee166ee3287b5be217140385
+  data.tar.gz: af1f7dac1075da66a5e2fa4135d143cc58521f3cc848f9d40aeb54254f8cf907
 SHA512:
-  metadata.gz: 4b0befde4733aeade6f332adaf529735ed718fc5b4ad03dbbcbcd6d66e0124ed107e508f47fc3efa70f4fc31479d61ac42508d364c185c846a9c93ce51924cac
-  data.tar.gz: 83b705a450abaf4b389495652843bc4ed537de7485bb1158423b5a9055e40616024ed928844a485d65aa26cadfbe64746570dd823943dc724b29e849dcbd7ecf
+  metadata.gz: f3811c1fbf10caf6931e5eca77c645360def106697f651d7d6ba313415a5630f07517f0be570689bf25d0f8704c586614f23d71f75488211158b4d1783f47091
+  data.tar.gz: 5982806cd91b314b756e7d25dd9c2e6af92e58cfb41bef9413eec0621f18b76faa6c78d739329794a4bfdfaee0333f06e255b542233c9936fc686a30d634ca67

data/CHANGELOG.md

@@ -1,8 +1,32 @@
 # CHANGELOG
 
+## 1.3.2 (2026-11-07)
+
+- Prefer `JSON.fast_generate` on generic `to_json_line`, structured-hash encoder assembly, and `LineEncoder` fast-path lines
+- Keep hot-path optimizations always on: timestamp cache per UTC second, sanitizer and context fast paths, tag-list cache, single `Severity.name_for` per line
+- Experimental: add `JsonLogging.isolation_level = :fiber` so context, tags, and hot-path caches isolate per Fiber (`:thread` remains default)
+- Emit valid JSON when a large structured hash body is empty after field overrides
+- Resolve the home-directory prefix without ActiveSupport `blank?`
+- Stop release when confirmation input closes before an answer
+- Require a matching `CHANGELOG.md` version heading before publish
+- Run quality, test, and coverage jobs on pull requests to `main`
+
+## 1.3.1 (2026-09-04)
+
+- Copy large structured hashes before Rails parameter filtering so caller fields stay intact
+- Keep original key names on the large-hash encoder path when a Rails parameter filter is present
+- Isolate nested hashes in `with_context` from later caller mutations
+- Match fallback sensitive-key detection to Rails default filter substrings including email, otp, ssn, token, and credentials
+- Rebuild the compiled Rails parameter filter after in-place `filter_parameters` changes
+- Treat JSON object and array strings longer than 10,000 characters as truncated text
+- Replace home-directory prefixes in log strings and backtraces with a tilde
+- Skip EventSubscriber writes when the logger has INFO disabled; keep the Rails event timestamp as an integer
+- Keep overflow sensitive keys as filtered after the 50-key hash cap without copying their values
+- Require json 2.21.2 or newer
+
 ## 1.3.0 (2026-07-25)
 
-- BREAKING: Require Ruby 3.2+ and Rails 7+ (drop Ruby 2.7–3.1 and Rails 6 support)
+- 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)
@@ -36,7 +60,7 @@
 ## 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
-- Improve BroadcastLogger compatibility: service-specific loggers work seamlessly with `ActiveSupport::BroadcastLogger`
+- Improve BroadcastLogger compatibility: service-specific loggers work with `ActiveSupport::BroadcastLogger`
 - Fix LocalTagStorage implementation to match Rails' TaggedLogging behavior: use `tag_stack` attribute accessor pattern for proper tag isolation
 - Add comprehensive examples in README for service-specific loggers and BroadcastLogger integration
 

data/README.md

@@ -3,8 +3,8 @@
 [![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 Ruby 3.2+ and Rails 7–8.
+No dependencies beyond Rails and ActiveSupport.
+Supports Ruby 3.2+ and Rails 7-8.
 
 ## Installation
 
@@ -35,10 +35,10 @@ end
 - `JsonLogging.logger(*args)` - Convenience method that creates an `ActiveSupport::Logger` and wraps it
 - Safe JSON serialization that never raises from the formatter
 - `JsonLogging.with_context` to attach contextual fields per-thread
-- Smart message parsing (handles hashes, JSON strings, plain strings, and Exception objects)
+- Message parsing for hashes, JSON strings, plain strings, and Exception objects
 - 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+)
+- Compatible 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)
 
@@ -93,8 +93,21 @@ This gem does **not** automatically configure your Rails app. You set it up manu
 
 **Note:** 
 - In Rails apps, the gem is automatically required via Railtie, so you typically don't need to manually `require "json_logging"` in initializers (though it's harmless if you do).
-- In Rails 7.1+, Rails automatically wraps your logger in `ActiveSupport::BroadcastLogger` to enable writing to multiple destinations (e.g., STDOUT and file simultaneously). This works seamlessly with our logger - your JSON logger will be wrapped and all method calls will delegate correctly. No special handling needed.
-- In Rails 7.1+, tag storage uses `ActiveSupport::IsolatedExecutionState` for improved thread/Fiber safety.
+- In Rails 7.1+, Rails wraps the logger in `ActiveSupport::BroadcastLogger` so one logger can write to several destinations (for example STDOUT and a file). `JsonLogging` stays compatible: the JSON logger is wrapped and method calls delegate as usual.
+- In Rails 7.1+, default tag/context storage uses `ActiveSupport::IsolatedExecutionState` (thread isolation unless the app sets Rails fiber isolation).
+
+### Experimental Fiber isolation
+
+For Fiber-based servers or code that interleaves many Fibers on one Thread, enable JsonLogging's experimental fiber storage:
+
+```ruby
+# config/initializers/json_logging.rb
+JsonLogging.isolation_level = :fiber
+```
+
+This isolates `with_context`, logger tags, and JsonLogging hot-path caches per Fiber. It does **not** flip Rails' own `config.active_support.isolation_level`; Falcon-style apps usually set both.
+
+Default remains `:thread`.
 
 ### Service-specific loggers with tags
 
@@ -148,7 +161,7 @@ Or enable the Railtie opt-in (off by default):
 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`.
+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. It skips that write when the logger reports that INFO is disabled (`logger.level` above INFO). An IO destination always writes. `timestamp` stays the Rails event integer (nanoseconds), not the ISO8601 string used by `JsonLoggerExtension`. 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")
@@ -159,7 +172,7 @@ end
 
 ### BroadcastLogger integration
 
-`ActiveSupport::BroadcastLogger` (Rails 7.1+) allows writing logs to multiple destinations simultaneously. `JsonLogging` works seamlessly with `BroadcastLogger`:
+`ActiveSupport::BroadcastLogger` (Rails 7.1+) writes the same log stream to multiple destinations. `JsonLogging` works with `BroadcastLogger`:
 
 ```ruby
 # Create JSON loggers for different destinations
@@ -203,7 +216,7 @@ end
 - Tagged logging (`tagged`) works correctly through `BroadcastLogger`
 - Service-specific tagged loggers work with `BroadcastLogger`
 - Each destination receives properly formatted JSON logs
-- No special configuration needed - just wrap your `JsonLogging` logger in `BroadcastLogger`
+- Wrap your `JsonLogging` logger in `BroadcastLogger` when you need multiple destinations
 
 ### Basic setup
 
@@ -443,13 +456,13 @@ logger.tagged("BCX").tagged("Jason").info("Stuff")
 **Wrapping Compatibility:** You can wrap loggers that have already been wrapped with `ActiveSupport::TaggedLogging`:
 
 ```ruby
-# Wrap a TaggedLogging logger - works perfectly
+# Wrap a TaggedLogging logger
 tagged_logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
 json_logger = JsonLogging.new(tagged_logger)
 json_logger.tagged("TEST") { json_logger.info("message") }  # Tags appear at root level in JSON
 ```
 
-**Note:** If you wrap a `JsonLogging` logger with `ActiveSupport::TaggedLogging`, the TaggedLogging's text-based tags will appear as part of the message string in the JSON output, not as structured tags at the root level. For best results, wrap loggers with `JsonLogging` last.
+**Note:** If you wrap a `JsonLogging` logger with `ActiveSupport::TaggedLogging`, the TaggedLogging's text-based tags will appear as part of the message string in the JSON output, not as structured tags at the root level. Wrap loggers with `JsonLogging` last.
 
 ### JsonLogging::JsonLogger
 
@@ -551,7 +564,7 @@ end
 
 The transformer receives the current thread-local context hash and should return a hash. If the transformer raises an error, the base context will be returned to avoid breaking logging.
 
-**Note:** The transformer is called every time a log entry is created, so keep it lightweight to avoid performance issues.
+**Note:** The transformer is called every time a log entry is created, so keep it cheap to avoid slowing each line.
 
 ### Inherited Rails Logger Features
 
@@ -607,24 +620,25 @@ logger.reopen                       # Reopen the logger (if supported by logdev)
 ## Features
 
 - **Native tagged logging**: Use `logger.tagged("TAG")` just like Rails' tagged logger
-- **Smart message parsing**: Automatically handles hashes, JSON strings, plain strings, and Exception objects (with class, message, and backtrace)
+- **Message parsing**: Handles hashes, JSON strings, plain strings, and Exception objects (with class, message, and backtrace)
 - **Thread-safe context**: `JsonLogging.with_context` works across threads
-- **Rails 7.1+ thread/Fiber safety**: Uses `ActiveSupport::IsolatedExecutionState` for improved concurrency
-- **Never raises**: Formatter and logger methods handle errors gracefully with fallback entries
+- **Rails 7.1+ isolation**: Default `:thread` storage uses `ActiveSupport::IsolatedExecutionState` when available
+- **Experimental Fiber isolation**: `JsonLogging.isolation_level = :fiber` isolates context, tags, and hot-path caches per Fiber (for Fiber servers / interleaved Fibers on one Thread). Does not change Rails `config.active_support.isolation_level`; set that separately for CurrentAttributes and the rest of Rails.
+- **Safe on encode errors**: Formatter and logger methods fall back to safe entries instead of raising
 - **Single-line JSON**: Each log entry is a single line, safe for log aggregation tools
 
 ## Security & privacy
 
 - **Rails ParameterFilter integration**: Automatically uses `Rails.application.config.filter_parameters` to filter sensitive data (passwords, tokens, etc.). This includes encrypted attributes automatically. See [Rails parameter filtering guide](https://thoughtbot.com/blog/parameter-filtering).
-- **Input sanitization**: Removes control characters, truncates long strings, and limits structure depth/size:
+- **Input sanitization**: Removes control characters, truncates long strings, redacts home-directory prefixes to `~`, and limits structure depth/size:
   - Maximum string length: 10,000 characters (truncated with `...[truncated]` suffix)
-  - Maximum context hash size: 50 keys (additional keys are truncated)
+  - Maximum context hash size: 50 keys (additional keys are truncated; overflow keys that match sensitive patterns or `filter_parameters` still appear as `[FILTERED]`)
   - Maximum nesting depth: 10 levels (deeper structures return `{"error" => "max_depth_exceeded"}`)
   - Maximum backtrace lines: 20 lines per exception
 - **Single-line JSON**: Emits single-line JSON to avoid log injection via newlines
-- **Never fails**: Formatter and logger never raise; fallback to safe entries on serialization errors
+- **Safe on encode errors**: Formatter and logger never raise; fallback to safe entries on serialization errors
 - **Sensitive key detection**: Falls back to pattern matching when Rails ParameterFilter isn't available
-- **You control context**: You decide what goes into context via `JsonLogging.with_context`; avoid sensitive data
+- **Caller-owned context**: You decide what goes into context via `JsonLogging.with_context`; avoid sensitive data
 
 ### Configuring sensitive parameter filtering
 
@@ -632,7 +646,7 @@ This gem automatically uses Rails' `config.filter_parameters` when available. Co
 
 ```ruby
 Rails.application.config.filter_parameters += [
-  :passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn
+  :passw, :email, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn
 ]
 ```
 

data/lib/json_logging/event_subscriber.rb

@@ -121,9 +121,13 @@ module JsonLogging
     def write_line(line)
       if @io
         @io.write(line)
-      else
-        resolve_logger << line
+        return
       end
+
+      logger = resolve_logger
+      return if logger.respond_to?(:info?) && !logger.info?
+
+      logger << line
     end
 
     def resolve_logger

data/lib/json_logging/execution_state.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module JsonLogging
+  # Storage for request-scoped logging state (context, tags, hot-path caches).
+  #
+  # Default +:thread+ follows ActiveSupport::IsolatedExecutionState when present
+  # (Rails 7.1+), otherwise Thread.current.
+  #
+  # Experimental +:fiber+ stores JsonLogging keys on the current Fiber so concurrent
+  # Fibers on one Thread do not share context or tags. Does not change Rails'
+  # ActiveSupport::IsolatedExecutionState.isolation_level; Falcon-style apps should
+  # still set config.active_support.isolation_level = :fiber for the rest of Rails.
+  module ExecutionState
+    PREPARED_TAGS_CACHE_KEY = :__json_logging_prepared_tags
+
+    module_function
+
+    def [](key)
+      backend[key]
+    end
+
+    def []=(key, value)
+      backend[key] = value
+    end
+
+    def delete(key)
+      backend.delete(key)
+    end
+
+    def key?(key)
+      backend.key?(key)
+    end
+
+    def prepared_tags_cache
+      self[PREPARED_TAGS_CACHE_KEY] ||= {}
+    end
+
+    def backend
+      if JsonLogging.isolation_level == :fiber
+        fiber_backend
+      else
+        thread_backend
+      end
+    end
+
+    def fiber_backend
+      state = Fiber.current.json_logging_execution_state
+      unless state
+        state = {}
+        Fiber.current.json_logging_execution_state = state
+      end
+      state
+    end
+
+    def thread_backend
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState
+      else
+        Thread.current
+      end
+    end
+  end
+end
+
+Fiber.attr_accessor :json_logging_execution_state unless Fiber.method_defined?(:json_logging_execution_state)

data/lib/json_logging/helpers.rb

@@ -2,6 +2,9 @@ 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/
 
+    # Microsecond bundle exec / hot add path: avoid fresh iso8601(6) every line when still in the same UTC second.
+    TIMESTAMP_CACHE_KEY = :__json_logging_ts_cache
+
     module_function
 
     # Normalize timestamp to ISO8601 with microseconds
@@ -12,7 +15,20 @@ module JsonLogging
     end
 
     def current_timestamp
-      format_timestamp(current_time)
+      cached_log_timestamp
+    end
+
+    def cached_log_timestamp
+      now = current_time
+      sec_key = now.to_i
+      cache = ExecutionState[TIMESTAMP_CACHE_KEY]
+      if cache.is_a?(Array) && cache[0] == sec_key && cache[1]
+        return cache[1]
+      end
+
+      formatted = format_timestamp(now)
+      ExecutionState[TIMESTAMP_CACHE_KEY] = [sec_key, formatted]
+      formatted
     end
 
     def format_timestamp(time)

data/lib/json_logging/json_logger.rb

@@ -12,7 +12,7 @@ module JsonLogging
       shift_age = args[1] || 0
       shift_size = args[2]
 
-      # Handle both positional and keyword arguments for Rails 7–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?

data/lib/json_logging/json_logger_extension.rb

@@ -22,10 +22,11 @@ module JsonLogging
 
       msg = nil
       msg = extract_log_message(message, progname, &block)
+      timestamp = Helpers.cached_log_timestamp
       line = LineEncoder.build_line(
         msg: msg,
         severity: severity,
-        timestamp: Helpers.current_timestamp,
+        timestamp: timestamp,
         tags: formatter.current_tags,
         additional_context: JsonLogging.additional_context_for_payload,
         additional_context_sanitized: true,
@@ -77,8 +78,9 @@ module JsonLogging
 
     def write_add_fallback(severity, msg, error)
       msg ||= "<uninitialized>"
+      ts = Helpers.cached_log_timestamp
       fallback = {
-        timestamp: Helpers.current_timestamp,
+        timestamp: ts,
         severity: Severity.name_for(severity),
         message: Sanitizer.sanitize_string(Helpers.safe_string(msg)),
         logger_error: {
@@ -94,27 +96,18 @@ module JsonLogging
     end
 
     def current_tags
-      # Use IsolatedExecutionState (Rails 7.1+) for better thread/Fiber safety
-      # Falls back to Thread.current for Rails 7.0
-      if defined?(ActiveSupport::IsolatedExecutionState)
-        ActiveSupport::IsolatedExecutionState[tags_key] ||= []
-      else
-        Thread.current[tags_key] ||= []
-      end
+      tags = ExecutionState[tags_key]
+      return tags if tags
+
+      ExecutionState[tags_key] = []
     end
 
     def set_tags(new_tags)
-      # Use IsolatedExecutionState (Rails 7.1+) for better thread/Fiber safety
-      # Falls back to Thread.current for Rails 7.0
-      if defined?(ActiveSupport::IsolatedExecutionState)
-        ActiveSupport::IsolatedExecutionState[tags_key] = new_tags
-      else
-        Thread.current[tags_key] = new_tags
-      end
+      ExecutionState[tags_key] = new_tags
     end
 
     def push_tags(tags)
-      flat = Sanitizer.prepare_tags(tags)
+      flat = Sanitizer.prepare_tags(tags, tag_source: :logger_extension_push)
       return if flat.empty?
 
       set_tags(current_tags + flat)
@@ -154,7 +147,7 @@ module JsonLogging
       end
 
       def push_tags(tags)
-        flat = Sanitizer.prepare_tags(tags)
+        flat = Sanitizer.prepare_tags(tags, tag_source: :local_tag_stack)
         return [] if flat.empty?
 
         @tags.concat(flat)

data/lib/json_logging/line_encoder.rb

@@ -10,10 +10,12 @@ module JsonLogging
     module_function
 
     def build_line(msg:, severity:, timestamp:, tags:, additional_context:, additional_context_sanitized: false, sanitize_tags: true)
+      severity_string = Severity.name_for(severity)
+
       if simple_string_line?(msg, tags, additional_context)
         return simple_string_json_line(
           message: msg,
-          severity: Severity.name_for(severity),
+          severity: severity_string,
           timestamp: timestamp
         )
       end
@@ -21,7 +23,7 @@ module JsonLogging
       if tagged_simple_string_line?(msg, tags, additional_context)
         return tagged_simple_string_json_line(
           message: msg,
-          severity: Severity.name_for(severity),
+          severity: severity_string,
           timestamp: timestamp,
           tags: tags,
           sanitize_tags: sanitize_tags
@@ -31,7 +33,7 @@ module JsonLogging
       if contextual_simple_string_line?(msg, tags, additional_context, additional_context_sanitized: additional_context_sanitized)
         return contextual_simple_string_json_line(
           message: msg,
-          severity: Severity.name_for(severity),
+          severity: severity_string,
           timestamp: timestamp,
           additional_context: additional_context
         )
@@ -40,7 +42,7 @@ module JsonLogging
       if standalone_hash_line?(msg, tags, additional_context)
         return standalone_hash_json_line(
           message: msg,
-          severity: Severity.name_for(severity),
+          severity: severity_string,
           timestamp: timestamp
         )
       end
@@ -48,7 +50,7 @@ module JsonLogging
       if tagged_hash_line?(msg, tags, additional_context)
         return tagged_hash_json_line(
           message: msg,
-          severity: Severity.name_for(severity),
+          severity: severity_string,
           timestamp: timestamp,
           tags: tags,
           sanitize_tags: sanitize_tags
@@ -58,13 +60,13 @@ module JsonLogging
       if contextual_hash_line?(msg, tags, additional_context, additional_context_sanitized: additional_context_sanitized)
         return contextual_hash_json_line(
           message: msg,
-          severity: Severity.name_for(severity),
+          severity: severity_string,
           timestamp: timestamp,
           additional_context: additional_context
         )
       end
 
-      sev = Severity.name_for(severity)
+      sev = severity_string
       payload = PayloadBuilder.build_base_payload(msg, severity: sev, timestamp: timestamp)
       unless tags.empty? && PayloadBuilder.empty_additional_context?(additional_context)
         payload = PayloadBuilder.merge_context(
@@ -81,7 +83,7 @@ module JsonLogging
     def to_json_line(payload_hash)
       compacted = payload_hash.compact
       json_payload = string_keyed_structure?(compacted) ? compacted : compacted.deep_stringify_keys
-      "#{json_payload.to_json}\n"
+      "#{JSON.fast_generate(json_payload)}\n"
     end
 
     def string_keyed_structure?(object)
@@ -104,7 +106,7 @@ module JsonLogging
 
     def simple_string_json_line(message:, severity:, timestamp:)
       sanitized_message = Sanitizer.sanitize_string(message)
-      "#{JSON.generate("message" => sanitized_message, "severity" => severity, "timestamp" => timestamp)}\n"
+      "#{JSON.fast_generate("message" => sanitized_message, "severity" => severity, "timestamp" => timestamp)}\n"
     end
 
     def tagged_simple_string_line?(message, tags, additional_context)
@@ -116,8 +118,13 @@ module JsonLogging
 
     def tagged_simple_string_json_line(message:, severity:, timestamp:, tags:, sanitize_tags:)
       sanitized_message = Sanitizer.sanitize_string(message)
-      prepared_tags = sanitize_tags ? Sanitizer.prepare_tags(tags) : tags
-      "#{JSON.generate("message" => sanitized_message, "severity" => severity, "timestamp" => timestamp, "tags" => prepared_tags.uniq)}\n"
+      prepared_tags = if sanitize_tags
+        t = Sanitizer.prepare_tags(tags, tag_source: :line_encoder_tagged_simple)
+        t.uniq
+      else
+        tags
+      end
+      "#{JSON.fast_generate("message" => sanitized_message, "severity" => severity, "timestamp" => timestamp, "tags" => prepared_tags)}\n"
     end
 
     def contextual_simple_string_line?(message, tags, additional_context, additional_context_sanitized:)
@@ -137,7 +144,7 @@ module JsonLogging
       }
       context = PayloadBuilder.context_payload_portion(additional_context)
       payload["context"] = context unless context.empty?
-      "#{JSON.generate(payload)}\n"
+      "#{JSON.fast_generate(payload)}\n"
     end
 
     def standalone_hash_line?(message, tags, additional_context)
@@ -158,7 +165,7 @@ module JsonLogging
       payload = Sanitizer.sanitize_hash(hash)
       payload["severity"] = severity
       payload["timestamp"] = timestamp
-      "#{JSON.generate(payload)}\n"
+      "#{JSON.fast_generate(payload)}\n"
     end
 
     def tagged_hash_line?(message, tags, additional_context)
@@ -169,7 +176,11 @@ module JsonLogging
 
     def tagged_hash_json_line(message:, severity:, timestamp:, tags:, sanitize_tags:)
       hash = message.is_a?(Hash) ? message : message.to_hash
-      prepared_tags = sanitize_tags ? Sanitizer.prepare_tags(tags) : tags
+      prepared_tags = if sanitize_tags
+        Sanitizer.prepare_tags(tags, tag_source: :line_encoder_tagged_hash)
+      else
+        tags
+      end
       merged_tags = (Array(hash[:tags] || hash["tags"]) + prepared_tags).uniq
       field_overrides = {"tags" => merged_tags}
 
@@ -185,7 +196,7 @@ module JsonLogging
       payload["severity"] = severity
       payload["timestamp"] = timestamp
       payload["tags"] = merged_tags
-      "#{JSON.generate(payload)}\n"
+      "#{JSON.fast_generate(payload)}\n"
     end
 
     def contextual_hash_line?(message, tags, additional_context, additional_context_sanitized:)
@@ -220,15 +231,7 @@ module JsonLogging
         existing_context = payload["context"].is_a?(Hash) ? payload["context"] : {}
         payload["context"] = existing_context.merge(merged_context)
       end
-      "#{JSON.generate(payload)}\n"
-    end
-
-    def build_sanitized_hash_payload(message:, severity:, timestamp:)
-      hash = message.is_a?(Hash) ? message : message.to_hash
-      payload = Sanitizer.sanitize_hash(hash)
-      payload["severity"] = severity
-      payload["timestamp"] = timestamp
-      payload
+      "#{JSON.fast_generate(payload)}\n"
     end
 
     def deep_stringify_structure(obj)

data/lib/json_logging/message_parser.rb

@@ -25,6 +25,10 @@ module JsonLogging
     end
 
     def json_string?(str)
+      # Short strings cannot be JSON object/array literals with both delimiters.
+      return false if str.length < 2
+      return false if str.length > Sanitizer::MAX_STRING_LENGTH
+
       (str.start_with?("{") && str.end_with?("}")) ||
         (str.start_with?("[") && str.end_with?("]"))
     end

data/lib/json_logging/payload_builder.rb

@@ -25,30 +25,42 @@ module JsonLogging
       return merge_tags_only(payload, tags: tags, sanitize_tags: sanitize_tags) if tags_only_merge?(payload, additional_context: additional_context, tags: tags)
 
       existing_context = payload["context"].is_a?(Hash) ? payload["context"] : {}
+      user_context = filtered_user_context(additional_context, sanitized: additional_context_sanitized)
+      deduped = user_context.reject { |key, _| payload.key?(key) || payload.key?(key.to_s) }
+      merged_context = existing_context.merge(deduped)
 
-      sanitized_context = if additional_context_sanitized
+      assign_tags!(payload, tags: tags, sanitize_tags: sanitize_tags) unless tags.empty?
+      assign_context!(payload, merged_context) unless merged_context.empty?
+      payload
+    end
+
+    def filtered_user_context(additional_context, sanitized:)
+      context = resolve_additional_context(additional_context, sanitized: sanitized)
+      context.except(*SYSTEM_CONTROLLED_KEYS)
+    end
+
+    def resolve_additional_context(additional_context, sanitized:)
+      if sanitized
         additional_context.is_a?(Hash) ? additional_context : {}
       elsif additional_context.is_a?(Hash) && !additional_context.empty?
         Sanitizer.sanitize_hash(additional_context)
       else
         additional_context || {}
       end
+    end
 
-      user_context_filtered = sanitized_context.except(*SYSTEM_CONTROLLED_KEYS)
-
-      deduped_additional = user_context_filtered.reject { |key, _| payload.key?(key) || payload.key?(key.to_s) }
-      merged_context = existing_context.merge(deduped_additional)
-
-      unless tags.empty?
-        existing_tags = Array(payload["tags"])
-        prepared_tags = sanitize_tags ? tags.map { |tag| Sanitizer.sanitize_string(tag.to_s) } : tags
-        payload["tags"] = (existing_tags + prepared_tags).uniq
-      end
+    def assign_tags!(payload, tags:, sanitize_tags:)
+      existing_tags = Array(payload["tags"])
+      prepared_tags = sanitize_tags ? tags.map { |tag| Sanitizer.sanitize_string(tag.to_s) } : tags
+      payload["tags"] = (existing_tags + prepared_tags).uniq
+    end
 
-      unless merged_context.empty?
-        payload["context"] = merged_context.transform_keys(&:to_s)
+    def assign_context!(payload, merged_context)
+      payload["context"] = if merged_context.keys.all? { |key| key.is_a?(String) }
+        merged_context
+      else
+        merged_context.transform_keys(&:to_s)
       end
-      payload
     end
 
     def empty_additional_context?(additional_context)
@@ -73,7 +85,8 @@ module JsonLogging
     end
 
     def merge_tags_only(payload, tags:, sanitize_tags:)
-      existing_tags = Array(payload["tags"])
+      raw = payload["tags"]
+      existing_tags = raw ? Array(raw) : []
       prepared_tags = sanitize_tags ? tags.map { |tag| Sanitizer.sanitize_string(tag.to_s) } : tags
       payload["tags"] = (existing_tags + prepared_tags).uniq
       payload
@@ -81,6 +94,7 @@ module JsonLogging
 
     def context_payload_portion(additional_context)
       return {} unless additional_context.is_a?(Hash)
+      return additional_context if additional_context.empty?
 
       additional_context.reject do |key, _|
         SYSTEM_CONTROLLED_KEYS.include?(key) || SYSTEM_CONTROLLED_KEYS.include?(key.to_s)

data/lib/json_logging/sanitizer.rb

@@ -1,6 +1,8 @@
 require_relative "structured_hash_sanitizer"
+require_relative "sanitizer_hash_limit"
 
 module JsonLogging
+  # rubocop:disable Metrics/ModuleLength -- sanitizer owns string/hash/tag policy in one place
   module Sanitizer
     # Control characters that should be escaped or removed from log messages
     CONTROL_CHARS = /[\x00-\x1F\x7F]/
@@ -18,7 +20,7 @@ module JsonLogging
     MAX_BACKTRACE_LINES = 20
 
     # Common sensitive key patterns (case insensitive) - fallback when Rails ParameterFilter not available
-    SENSITIVE_KEY_PATTERNS = /\b(password|passwd|pwd|secret|token|api_key|apikey|access_token|auth_token|private_key|credential)\b/i
+    SENSITIVE_KEY_PATTERNS = /(passw|pwd|email|secret|token|_key|crypt|salt|certificate|otp|ssn|cvv|cvc|credential)/i
 
     @parameter_filter = nil
     @parameter_filter_config = nil
@@ -38,7 +40,7 @@ module JsonLogging
         return @parameter_filter
       end
 
-      @parameter_filter_config = filter_params
+      @parameter_filter_config = filter_params.dup.freeze
       @parameter_filter_requires_full_tree_walk = parameter_filter_requires_full_tree_walk?(filter_params)
       @parameter_filter = ActiveSupport::ParameterFilter.new(filter_params)
     rescue
@@ -69,19 +71,34 @@ module JsonLogging
       @parameter_filter_requires_full_tree_walk = false
     end
 
-    def prepare_tags(tags)
-      tags.flatten.compact.map(&:to_s).reject(&:empty?).map { |tag| sanitize_string(tag) }
+    def prepare_tags(tags, tag_source: nil)
+      flat = tags.flatten.compact.map(&:to_s).reject(&:empty?)
+      return [] if flat.empty?
+
+      if tag_source && flat.none? { |t| t.match?(CONTROL_CHARS) } && flat.all? { |t| t.length <= MAX_STRING_LENGTH }
+        cache = ExecutionState.prepared_tags_cache
+        key = [tag_source, flat]
+        return cache[key] if cache.key?(key)
+
+        prepared = flat.map { |tag| sanitize_string(tag) }
+        cache[key] = prepared.freeze
+        return prepared
+      end
+
+      flat.map { |tag| sanitize_string(tag) }
     end
 
     # Sanitize a string by removing/escaping control characters and truncating
     def sanitize_string(str)
       return str unless str.is_a?(String)
-      return str if str.length <= MAX_STRING_LENGTH && !str.match?(CONTROL_CHARS)
 
-      # Remove or replace control characters
+      home_prefix = home_directory_prefix
+      has_home_directory = home_prefix && str.include?(home_prefix)
+      return str if str.length <= MAX_STRING_LENGTH && !str.match?(CONTROL_CHARS) && !has_home_directory
+
       sanitized = str.gsub(CONTROL_CHARS, "")
+      sanitized = redact_home_directory(sanitized, home_prefix) if has_home_directory
 
-      # Truncate if too long
       if sanitized.length > MAX_STRING_LENGTH
         sanitized = sanitized[0, MAX_STRING_LENGTH] + "...[truncated]"
       end
@@ -91,13 +108,10 @@ module JsonLogging
       "<sanitization_error>"
     end
 
-    # Sanitize a hash, removing sensitive keys and limiting size/depth
-    # Uses Rails ParameterFilter when available, falls back to pattern matching
     def sanitize_hash(hash, depth: 0)
       return hash unless hash.is_a?(Hash)
-
-      # Prevent excessive nesting
       return {"error" => "max_depth_exceeded"} if depth > MAX_DEPTH
+      return hash if hash.empty?
 
       limited_hash = limited_hash_for_sanitization(hash)
       fast_path_result = fast_path_sanitized_hash(limited_hash, depth: depth)
@@ -109,13 +123,11 @@ module JsonLogging
     end
 
     def limited_hash_for_sanitization(hash)
-      if hash.size > MAX_CONTEXT_SIZE
-        truncated = hash.first(MAX_CONTEXT_SIZE).to_h
-        truncated["_truncated"] = true
-        truncated
-      else
-        hash
+      if !rails_parameter_filter && hash.is_a?(Hash) && hash.size <= MAX_CONTEXT_SIZE
+        return hash
       end
+
+      SanitizerHashLimit.apply(hash, filter_config: rails_parameter_filter && @parameter_filter_config)
     end
 
     def fast_path_sanitized_hash(hash, depth: 0)
@@ -126,38 +138,26 @@ module JsonLogging
     end
 
     def sanitize_hash_with_filtering(limited_hash, depth: 0)
-      # Use Rails ParameterFilter if available (handles encrypted attributes automatically)
       filter = rails_parameter_filter
       if filter
-        # ParameterFilter will filter based on Rails.config.filter_parameters
-        # This includes encrypted attributes automatically
-        # Create a deep copy since filter modifies in place
+        # ParameterFilter mutates in place; copy first
         filtered = limited_hash.respond_to?(:deep_dup) ? limited_hash.deep_dup : limited_hash.dup
         filtered = filter.filter(filtered)
-
-        # Then sanitize values (strings, control chars, etc.) preserving filtered structure
         filtered.each_with_object({}) do |(key, value), result|
           result[key.to_s] = sanitize_value(value, depth: depth + 1)
         end
-
       else
-        # Fallback: use pattern matching for sensitive keys
         limited_hash.each_with_object({}) do |(key, value), result|
           key_string = key.to_s
-
-          # Skip sensitive keys
           if SENSITIVE_KEY_PATTERNS.match?(key_string)
             result[sensitive_filtered_key_name(key_string)] = "[FILTERED]"
             next
           end
-
           result[key_string] = sanitize_value(value, depth: depth + 1)
         end
       end
     end
 
-    # Sanitize a value (handles strings, hashes, arrays, etc.)
-    # Preserves numeric, boolean, and nil types
     def sanitize_value(value, depth: 0)
       case value
       when String
@@ -165,24 +165,22 @@ module JsonLogging
       when Hash
         sanitize_hash(value, depth: depth)
       when Array
-        # Limit array size
+        return [] if value.empty?
+
         sanitized = value.first(MAX_CONTEXT_SIZE).map { |v| sanitize_value(v, depth: depth + 1) }
         sanitized << "[truncated]" if value.size > MAX_CONTEXT_SIZE
         sanitized
       when Exception
         sanitize_exception(value)
       when Numeric, TrueClass, FalseClass, NilClass
-        # Preserve numeric, boolean, and nil types
         value
       else
-        # For other types, convert to string and sanitize
         sanitize_string(value.to_s)
       end
     rescue
       "<unprintable>"
     end
 
-    # Sanitize exception, including backtrace
     def sanitize_exception(ex)
       {
         "error" => {
@@ -195,11 +193,9 @@ module JsonLogging
       {"error" => {"class" => "Exception", "message" => "<sanitization_failed>"}}
     end
 
-    # Sanitize backtrace - truncate and remove sensitive paths
     def sanitize_backtrace(backtrace)
       return [] unless backtrace.is_a?(Array)
 
-      # Take first MAX_BACKTRACE_LINES, sanitize each
       backtrace.first(MAX_BACKTRACE_LINES).map do |line|
         sanitize_string(line.to_s)
       end
@@ -207,7 +203,6 @@ module JsonLogging
       []
     end
 
-    # Check if a key looks sensitive
     def sensitive_key?(key)
       SENSITIVE_KEY_PATTERNS.match?(key.to_s)
     end
@@ -255,5 +250,25 @@ module JsonLogging
     def sensitive_filtered_key_name(key_string)
       key_string.gsub(/(?<!^)(?=[A-Z])/, "_").downcase + "_filtered"
     end
+
+    def home_directory_prefix
+      prefix = ENV["HOME"]
+      # rubocop:disable Rails/Blank -- string path must not require ActiveSupport blank?
+      prefix = Dir.home if prefix.nil? || prefix.empty?
+      # rubocop:enable Rails/Blank
+      prefix = prefix.to_s.chomp("/").chomp("\\")
+      return if prefix.empty?
+
+      prefix
+    rescue ArgumentError, RuntimeError
+      nil
+    end
+
+    def redact_home_directory(str, prefix)
+      return str unless prefix
+
+      str.gsub(/#{Regexp.escape(prefix)}(?=\/|\\|\z)/, "~")
+    end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/json_logging/sanitizer_hash_limit.rb

@@ -0,0 +1,42 @@
+module JsonLogging
+  module SanitizerHashLimit
+    FILTERED = "[FILTERED]"
+
+    module_function
+
+    def apply(hash, filter_config:)
+      return hash if hash.size <= Sanitizer::MAX_CONTEXT_SIZE
+
+      truncated = {}
+      kept = 0
+      extra_filtered = 0
+      hash.each do |key, value|
+        if kept < Sanitizer::MAX_CONTEXT_SIZE
+          truncated[key] = value
+          kept += 1
+        elsif extra_filtered < Sanitizer::MAX_CONTEXT_SIZE && key_requires_filtering?(key, filter_config)
+          truncated[key] = FILTERED
+          extra_filtered += 1
+        end
+      end
+      truncated["_truncated"] = true
+      truncated
+    end
+
+    def key_requires_filtering?(key, filter_config)
+      return true if Sanitizer.sensitive_key?(key)
+
+      Array(filter_config).any? do |filter|
+        next false if filter.is_a?(Proc)
+
+        key_string = key.to_s
+        if filter.is_a?(Regexp)
+          filter.match?(key_string)
+        else
+          token = filter.to_s
+          !token.empty? && !token.include?(".") && key_string.match?(/#{Regexp.escape(token)}/i)
+        end
+      end
+    end
+  end
+end

data/lib/json_logging/structured_hash_json_encoder.rb

@@ -6,35 +6,6 @@ module JsonLogging
 
     module_function
 
-    def eligible?(hash)
-      return false if Sanitizer.primitive_log_hash?(hash)
-      return false unless Sanitizer::StructuredHash.structured_log_hash?(hash)
-      return false unless large_structured_hash?(hash)
-
-      filter = Sanitizer.rails_parameter_filter
-      return true unless filter
-
-      !Sanitizer.rails_parameter_filter_requires_full_tree_walk?
-    end
-
-    def large_structured_hash?(hash, leaf_threshold: LEAF_THRESHOLD)
-      leaf_count = 0
-      walker = lambda do |value|
-        case value
-        when Hash
-          value.each_value { |entry| walker.call(entry) }
-        when Array
-          value.each { |entry| walker.call(entry) }
-        else
-          leaf_count += 1
-          throw(:enough, true) if leaf_count > leaf_threshold
-        end
-      end
-
-      catch(:enough) { walker.call(hash) }
-      leaf_count > leaf_threshold
-    end
-
     def try_encode_line(hash, severity:, timestamp:, field_overrides: {})
       tree = prepared_tree(hash, field_overrides: field_overrides)
       return nil unless tree
@@ -88,19 +59,17 @@ module JsonLogging
       return jsonable.tree unless filter
       return jsonable.tree if Sanitizer.rails_parameter_filter_requires_full_tree_walk?
 
-      tree = if jsonable.owned
-        jsonable.tree
-      else
-        Sanitizer::StructuredHash.stringify_keys_copy(jsonable.tree)
-      end
-
-      filter.filter(tree)
+      filter.filter(Sanitizer::StructuredHash.stringify(jsonable.tree))
     end
 
     def append_json_line(tree, severity:, timestamp:, field_overrides:)
-      body = JSON.generate(tree)
       extras = field_overrides.merge("severity" => severity, "timestamp" => timestamp)
-      extra_json = extras.map { |key, value| "#{JSON.generate(key.to_s)}:#{JSON.generate(value)}" }.join(",")
+      # rubocop:disable Rails/Blank -- encoder path must not require ActiveSupport blank?
+      return "#{JSON.fast_generate(extras)}\n" if tree.nil? || tree.empty?
+      # rubocop:enable Rails/Blank
+
+      body = JSON.fast_generate(tree)
+      extra_json = extras.map { |key, value| "#{JSON.fast_generate(key.to_s)}:#{JSON.fast_generate(value)}" }.join(",")
       "#{body.chop},#{extra_json}}\n"
     end
 

data/lib/json_logging/structured_hash_sanitizer.rb

@@ -38,17 +38,15 @@ module JsonLogging
         if filter
           filter.filter(stringify(hash))
         else
+          return Sanitizer.sanitize_primitive_hash(hash) if Sanitizer.primitive_log_hash?(hash)
+
           sanitize_without_filter(hash, depth: depth)
         end
       end
 
       def sanitize_without_filter(hash, depth: 0)
         jsonable = jsonable_tree(hash, depth: depth)
-        if jsonable.owned
-          stringify(jsonable.tree)
-        else
-          jsonable.tree.dup
-        end
+        stringify(jsonable.tree)
       end
 
       def jsonable_tree(hash, depth: 0, seen: nil, parent_key: nil, omit_keys: nil, count_leaves: false, leaf_counter: nil)
@@ -133,7 +131,8 @@ module JsonLogging
           return
         end
 
-        if Sanitizer::SENSITIVE_KEY_PATTERNS.match?(key_string)
+        # ParameterFilter keeps original key names; fallback rename would hide them from it.
+        if Sanitizer.rails_parameter_filter.nil? && Sanitizer::SENSITIVE_KEY_PATTERNS.match?(key_string)
           return [Sanitizer.sensitive_filtered_key_name(key_string), "[FILTERED]", true]
         end
 
@@ -195,12 +194,6 @@ module JsonLogging
           value
         end
       end
-
-      def stringify_keys_copy(hash)
-        return hash if hash.keys.all? { |key| key.is_a?(String) }
-
-        hash.transform_keys(&:to_s)
-      end
     end
   end
 end

data/lib/json_logging/version.rb

@@ -1,3 +1,3 @@
 module JsonLogging
-  VERSION = "1.3.0"
+  VERSION = "1.3.2"
 end

data/lib/json_logging.rb

@@ -3,6 +3,7 @@ require "json"
 require "time"
 
 require_relative "json_logging/version"
+require_relative "json_logging/execution_state"
 require_relative "json_logging/helpers"
 require_relative "json_logging/sanitizer"
 require_relative "json_logging/message_parser"
@@ -17,15 +18,29 @@ require_relative "json_logging/event_subscriber"
 module JsonLogging
   THREAD_CONTEXT_KEY = :__json_logging_context
   SANITIZED_CONTEXT_CACHE_KEY = :__json_logging_sanitized_context
+  ISOLATION_LEVELS = [:thread, :fiber].freeze
+
   @additional_context_warned = Set.new
   @additional_context_transformer = nil
+  @isolation_level = :thread
 
-  def self.context_storage
-    if defined?(ActiveSupport::IsolatedExecutionState)
-      ActiveSupport::IsolatedExecutionState
-    else
-      Thread.current
+  # Experimental: +:fiber+ isolates JsonLogging context, tags, and caches per Fiber.
+  # Default +:thread+ keeps Rails IsolatedExecutionState / Thread.current behavior.
+  def self.isolation_level
+    @isolation_level
+  end
+
+  def self.isolation_level=(level)
+    normalized = level.to_sym
+    unless ISOLATION_LEVELS.include?(normalized)
+      raise ArgumentError, "isolation_level must be :thread or :fiber, got: #{level.inspect}"
     end
+
+    @isolation_level = normalized
+  end
+
+  def self.context_storage
+    ExecutionState
   end
   private_class_method :context_storage
 

data/sig/json_logging.rbs

@@ -1,5 +1,9 @@
 module JsonLogging
   VERSION: String
+  ISOLATION_LEVELS: Array[Symbol]
+
+  def self.isolation_level: () -> Symbol
+  def self.isolation_level=: (Symbol | String) -> Symbol
 
   class EventSubscriber
     def initialize: (?logger: untyped, ?io: untyped) -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activesupport-json_logging
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.2
 platform: ruby
 authors:
 - Andrei Makarov
@@ -50,35 +50,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '9.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
-- !ruby/object:Gem::Dependency
-  name: polyrun
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
-  type: :development
+        version: 2.21.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.21.2
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -92,33 +78,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: polyrun
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13'
+        version: 2.2.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13'
+        version: 2.2.9
 - !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -315,8 +301,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-description: Lightweight JSON logger and formatter integrating with Rails/ActiveSupport.
-  No extra deps beyond Rails/Activesupport. Compatible with Rails 7–8.
+description: JSON logger and formatter for Rails/ActiveSupport. No extra deps beyond
+  Rails/ActiveSupport. Compatible with Rails 7-8.
 email:
 - contact@kiskolabs.com
 executables: []
@@ -330,6 +316,7 @@ files:
 - lib/activesupport/json_logging/railtie.rb
 - lib/json_logging.rb
 - lib/json_logging/event_subscriber.rb
+- lib/json_logging/execution_state.rb
 - lib/json_logging/formatter.rb
 - lib/json_logging/formatter_with_tags.rb
 - lib/json_logging/helpers.rb
@@ -339,6 +326,7 @@ files:
 - lib/json_logging/message_parser.rb
 - lib/json_logging/payload_builder.rb
 - lib/json_logging/sanitizer.rb
+- lib/json_logging/sanitizer_hash_limit.rb
 - lib/json_logging/severity.rb
 - lib/json_logging/structured_hash_json_encoder.rb
 - lib/json_logging/structured_hash_sanitizer.rb