activesupport-json_logging 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8860a79aadc768a5173400d8c56041edde0fcd66b9e3f2f50e4918956c31b451
-  data.tar.gz: 07420fcc1f8aa91271ebf0484a338b921dba8fd41c16e2e50adf789a9eaaed33
+  metadata.gz: 34ff048fcdd516e4f0f8e2b5d6d9911e44a6a486ee166ee3287b5be217140385
+  data.tar.gz: af1f7dac1075da66a5e2fa4135d143cc58521f3cc848f9d40aeb54254f8cf907
 SHA512:
-  metadata.gz: df9baad44f3b33dce3e18b795691fd6e7d8d620930826d2d9e423808b266b294b6ab3355619df9a2a406d51c7c0d3338be984599871579fbc67b69c5fc198a42
-  data.tar.gz: c93486338ce6906fb91bd96b55732a67525883971d7b7551690b34a4280337482160c096459b63623f0c2e629cb41b6af028fa008b274fc756137e5f21fc9958
+  metadata.gz: f3811c1fbf10caf6931e5eca77c645360def106697f651d7d6ba313415a5630f07517f0be570689bf25d0f8704c586614f23d71f75488211158b4d1783f47091
+  data.tar.gz: 5982806cd91b314b756e7d25dd9c2e6af92e58cfb41bef9413eec0621f18b76faa6c78d739329794a4bfdfaee0333f06e255b542233c9936fc686a30d634ca67

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # CHANGELOG
 
-## Unreleased
+## 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)
 
@@ -17,7 +26,7 @@
 
 ## 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)
@@ -51,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
 
@@ -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,10 +620,11 @@ 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
@@ -622,9 +636,9 @@ logger.reopen                       # Reopen the logger (if supported by logdev)
   - 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
 

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,7 +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"
+      "#{JSON.fast_generate(payload)}\n"
     end
 
     def deep_stringify_structure(obj)

data/lib/json_logging/message_parser.rb

@@ -25,6 +25,8 @@ 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?("}")) ||

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

@@ -2,6 +2,7 @@ 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]/
@@ -70,8 +71,21 @@ 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
@@ -97,6 +111,7 @@ module JsonLogging
     def sanitize_hash(hash, depth: 0)
       return hash unless hash.is_a?(Hash)
       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)
@@ -108,6 +123,10 @@ module JsonLogging
     end
 
     def limited_hash_for_sanitization(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
 
@@ -146,6 +165,8 @@ module JsonLogging
       when Hash
         sanitize_hash(value, depth: depth)
       when Array
+        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
@@ -232,7 +253,9 @@ module JsonLogging
 
     def home_directory_prefix
       prefix = ENV["HOME"]
-      prefix = Dir.home if prefix.blank?
+      # 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?
 
@@ -247,4 +270,5 @@ module JsonLogging
       str.gsub(/#{Regexp.escape(prefix)}(?=\/|\\|\z)/, "~")
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/json_logging/structured_hash_json_encoder.rb

@@ -63,9 +63,13 @@ module JsonLogging
     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,6 +38,8 @@ 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

data/lib/json_logging/version.rb

@@ -1,3 +1,3 @@
 module JsonLogging
-  VERSION = "1.3.1"
+  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.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Andrei Makarov
@@ -83,14 +83,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.2.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.2.9
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -105,20 +105,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13'
-- !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
 - !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