activesupport-json_logging 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b40f43e3cd600bfc139665fa3e6cc9df7a4a56eab58bec7f760b986faa9d2f7
-  data.tar.gz: d8d3352e482dc9698aa94a499f9905a1fdec0ca157cedf4e8a61194dfd7e7fba
+  metadata.gz: 8860a79aadc768a5173400d8c56041edde0fcd66b9e3f2f50e4918956c31b451
+  data.tar.gz: 07420fcc1f8aa91271ebf0484a338b921dba8fd41c16e2e50adf789a9eaaed33
 SHA512:
-  metadata.gz: 4b0befde4733aeade6f332adaf529735ed718fc5b4ad03dbbcbcd6d66e0124ed107e508f47fc3efa70f4fc31479d61ac42508d364c185c846a9c93ce51924cac
-  data.tar.gz: 83b705a450abaf4b389495652843bc4ed537de7485bb1158423b5a9055e40616024ed928844a485d65aa26cadfbe64746570dd823943dc724b29e849dcbd7ecf
+  metadata.gz: df9baad44f3b33dce3e18b795691fd6e7d8d620930826d2d9e423808b266b294b6ab3355619df9a2a406d51c7c0d3338be984599871579fbc67b69c5fc198a42
+  data.tar.gz: c93486338ce6906fb91bd96b55732a67525883971d7b7551690b34a4280337482160c096459b63623f0c2e629cb41b6af028fa008b274fc756137e5f21fc9958

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+## Unreleased
+
+## 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)

data/README.md

@@ -148,7 +148,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")
@@ -616,9 +616,9 @@ logger.reopen                       # Reopen the logger (if supported by logdev)
 ## 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
@@ -632,7 +632,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/line_encoder.rb

@@ -223,14 +223,6 @@ module JsonLogging
       "#{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
-    end
-
     def deep_stringify_structure(obj)
       case obj
       when Hash

data/lib/json_logging/message_parser.rb

@@ -25,6 +25,8 @@ module JsonLogging
     end
 
     def json_string?(str)
+      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/sanitizer.rb

@@ -1,4 +1,5 @@
 require_relative "structured_hash_sanitizer"
+require_relative "sanitizer_hash_limit"
 
 module JsonLogging
   module Sanitizer
@@ -18,7 +19,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 +39,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
@@ -76,12 +77,14 @@ module JsonLogging
     # 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,12 +94,8 @@ 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
 
       limited_hash = limited_hash_for_sanitization(hash)
@@ -109,13 +108,7 @@ 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
-      end
+      SanitizerHashLimit.apply(hash, filter_config: rails_parameter_filter && @parameter_filter_config)
     end
 
     def fast_path_sanitized_hash(hash, depth: 0)
@@ -126,38 +119,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 +146,20 @@ module JsonLogging
       when Hash
         sanitize_hash(value, depth: depth)
       when Array
-        # Limit array size
         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 +172,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 +182,6 @@ module JsonLogging
       []
     end
 
-    # Check if a key looks sensitive
     def sensitive_key?(key)
       SENSITIVE_KEY_PATTERNS.match?(key.to_s)
     end
@@ -255,5 +229,22 @@ module JsonLogging
     def sensitive_filtered_key_name(key_string)
       key_string.gsub(/(?<!^)(?=[A-Z])/, "_").downcase + "_filtered"
     end
+
+    def home_directory_prefix
+      prefix = ENV["HOME"]
+      prefix = Dir.home if prefix.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
 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,13 +59,7 @@ 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:)

data/lib/json_logging/structured_hash_sanitizer.rb

@@ -44,11 +44,7 @@ module JsonLogging
 
       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 +129,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 +192,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.1"
 end

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.1
 platform: ruby
 authors:
 - Andrei Makarov
@@ -49,6 +49,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.21.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.21.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -77,20 +91,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.0
-- !ruby/object:Gem::Dependency
-  name: webmock
-  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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -339,6 +339,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