activesupport-json_logging 1.2.1 → 1.3.0

data/lib/json_logging/structured_hash_sanitizer.rb

@@ -0,0 +1,206 @@
+module JsonLogging
+  module Sanitizer
+    module StructuredHash
+      JsonableResult = Struct.new(:tree, :owned, :leaf_count)
+
+      module_function
+
+      def structured_log_hash?(hash, seen = nil)
+        seen ||= Set.new.compare_by_identity
+        return false unless seen.add?(hash)
+
+        result = hash.all? { |_key, value| structured_log_value?(value, seen) }
+        seen.delete(hash)
+        result
+      end
+
+      def structured_log_value?(value, seen = nil)
+        case value
+        when String, Numeric, TrueClass, FalseClass, NilClass
+          Sanitizer.primitive_log_value?(value)
+        when Hash
+          structured_log_hash?(value, seen)
+        when Array
+          structured_log_array?(value, seen)
+        else
+          false
+        end
+      end
+
+      def structured_log_array?(array, seen = nil)
+        array.all? { |value| structured_log_value?(value, seen) }
+      end
+
+      def sanitize(hash, depth: 0)
+        return {"error" => "max_depth_exceeded"} if depth > Sanitizer::MAX_DEPTH
+
+        filter = Sanitizer.rails_parameter_filter
+        if filter
+          filter.filter(stringify(hash))
+        else
+          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
+      end
+
+      def jsonable_tree(hash, depth: 0, seen: nil, parent_key: nil, omit_keys: nil, count_leaves: false, leaf_counter: nil)
+        seen ||= Set.new.compare_by_identity
+        leaf_counter = [0] if count_leaves && leaf_counter.nil?
+        if depth > Sanitizer::MAX_DEPTH
+          return JsonableResult.new(tree: {"error" => "max_depth_exceeded"}, owned: true, leaf_count: leaf_counter&.[](0))
+        end
+        unless seen.add?(hash)
+          return JsonableResult.new(tree: {"error" => "cyclic_reference"}, owned: true, leaf_count: leaf_counter&.[](0))
+        end
+
+        entries = []
+        owned = false
+
+        hash.each do |key, value|
+          entry = process_jsonable_entry(
+            key,
+            value,
+            depth: depth,
+            seen: seen,
+            parent_key: parent_key,
+            omit_keys: omit_keys,
+            leaf_counter: leaf_counter
+          )
+          next unless entry
+
+          key_string, encoded_value, pair_owned = entry
+          owned ||= pair_owned
+          entries << [key_string, encoded_value, pair_owned]
+        end
+
+        seen.delete(hash)
+        leaf_count = leaf_counter&.[](0)
+        unless owned
+          tree = omit_root_keys(hash, omit_keys, depth: depth)
+          return JsonableResult.new(tree: tree, owned: false, leaf_count: leaf_count)
+        end
+
+        result = entries.each_with_object({}) do |(key_string, encoded_value, _pair_owned), object|
+          object[key_string] = encoded_value
+        end
+        JsonableResult.new(tree: result, owned: true, leaf_count: leaf_count)
+      end
+
+      def jsonable_value(value, depth:, seen:, parent_key:, leaf_counter: nil)
+        case value
+        when String
+          leaf_counter[0] += 1 if leaf_counter
+          sanitized = Sanitizer.sanitize_string(value)
+          JsonableResult.new(tree: sanitized, owned: sanitized != value, leaf_count: nil)
+        when Hash
+          jsonable_tree(value, depth: depth + 1, seen: seen, parent_key: parent_key, leaf_counter: leaf_counter)
+        when Array
+          jsonable_array(value, depth: depth, seen: seen, parent_key: parent_key, leaf_counter: leaf_counter)
+        else
+          leaf_counter[0] += 1 if leaf_counter
+          JsonableResult.new(tree: value, owned: false, leaf_count: nil)
+        end
+      end
+
+      def jsonable_array(array, depth:, seen:, parent_key:, leaf_counter: nil)
+        owned = false
+        result = nil
+
+        array.each_with_index do |entry, index|
+          child = jsonable_value(entry, depth: depth, seen: seen, parent_key: parent_key, leaf_counter: leaf_counter)
+          next unless child.owned
+
+          owned = true
+          result ||= array.dup
+          result[index] = child.tree
+        end
+
+        JsonableResult.new(tree: owned ? result : array, owned: owned, leaf_count: nil)
+      end
+
+      def process_jsonable_entry(key, value, depth:, seen:, parent_key:, omit_keys:, leaf_counter:)
+        key_string = key.to_s
+        if root_key_omitted?(depth, key_string, omit_keys)
+          count_leaves_in_value(value, leaf_counter, depth: depth, seen: seen) if leaf_counter
+          return
+        end
+
+        if Sanitizer::SENSITIVE_KEY_PATTERNS.match?(key_string)
+          return [Sanitizer.sensitive_filtered_key_name(key_string), "[FILTERED]", true]
+        end
+
+        nested_parent = parent_key ? "#{parent_key}.#{key_string}" : key_string
+        child = jsonable_value(
+          value,
+          depth: depth,
+          seen: seen,
+          parent_key: nested_parent,
+          leaf_counter: leaf_counter
+        )
+        encoded_value = child.owned ? child.tree : value
+        [key_string, encoded_value, child.owned]
+      end
+
+      def root_key_omitted?(depth, key_string, omit_keys)
+        depth.zero? && omit_keys&.include?(key_string)
+      end
+
+      def omit_root_keys(hash, omit_keys, depth:)
+        return hash unless depth.zero? && omit_keys&.any?
+
+        hash.each_with_object({}) do |(key, value), object|
+          object[key] = value unless omit_keys.include?(key.to_s)
+        end
+      end
+
+      def count_leaves_in_value(value, leaf_counter, depth:, seen:)
+        case value
+        when Hash
+          return unless seen.add?(value)
+
+          value.each_value do |entry|
+            count_leaves_in_value(entry, leaf_counter, depth: depth + 1, seen: seen)
+          end
+          seen.delete(value)
+        when Array
+          value.each { |entry| count_leaves_in_value(entry, leaf_counter, depth: depth, seen: seen) }
+        else
+          leaf_counter[0] += 1
+        end
+      end
+
+      def stringify(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          result[key.to_s] = stringify_value(value)
+        end
+      end
+
+      def stringify_value(value)
+        case value
+        when Hash
+          stringify(value)
+        when Array
+          value.map { |entry| stringify_value(entry) }
+        when String
+          Sanitizer.sanitize_string(value)
+        else
+          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.2.1"
+  VERSION = "1.3.0"
 end

data/lib/json_logging.rb

@@ -7,20 +7,37 @@ require_relative "json_logging/helpers"
 require_relative "json_logging/sanitizer"
 require_relative "json_logging/message_parser"
 require_relative "json_logging/payload_builder"
+require_relative "json_logging/line_encoder"
 require_relative "json_logging/formatter"
 require_relative "json_logging/formatter_with_tags"
 require_relative "json_logging/json_logger_extension"
 require_relative "json_logging/json_logger"
+require_relative "json_logging/event_subscriber"
 
 module JsonLogging
   THREAD_CONTEXT_KEY = :__json_logging_context
+  SANITIZED_CONTEXT_CACHE_KEY = :__json_logging_sanitized_context
+  @additional_context_warned = Set.new
+  @additional_context_transformer = nil
+
+  def self.context_storage
+    if defined?(ActiveSupport::IsolatedExecutionState)
+      ActiveSupport::IsolatedExecutionState
+    else
+      Thread.current
+    end
+  end
+  private_class_method :context_storage
 
   def self.with_context(extra_context)
-    original = Thread.current[THREAD_CONTEXT_KEY]
-    Thread.current[THREAD_CONTEXT_KEY] = (original || {}).merge(safe_hash(extra_context))
+    storage = context_storage
+    original = storage[THREAD_CONTEXT_KEY]
+    storage[THREAD_CONTEXT_KEY] = (original || {}).merge(safe_hash(extra_context))
+    invalidate_sanitized_context_cache(storage)
     yield
   ensure
-    Thread.current[THREAD_CONTEXT_KEY] = original
+    storage[THREAD_CONTEXT_KEY] = original
+    invalidate_sanitized_context_cache(storage)
   end
 
   # Returns the current thread-local context when called without arguments,
@@ -42,8 +59,9 @@ module JsonLogging
     end
 
     begin
-      base_context = (Thread.current[THREAD_CONTEXT_KEY] || {}).dup
-    rescue
+      base_context = (context_storage[THREAD_CONTEXT_KEY] || {}).dup
+    rescue => e
+      warn_additional_context_once(:dup, "thread context dup failed", e)
       base_context = {}
     end
 
@@ -51,7 +69,8 @@ module JsonLogging
     if transformer.is_a?(Proc)
       begin
         transformer.call(base_context)
-      rescue
+      rescue => e
+        warn_additional_context_once(:transformer, "additional_context transformer failed", e)
         base_context
       end
     else
@@ -61,6 +80,26 @@ module JsonLogging
 
   def self.additional_context=(proc_or_block)
     @additional_context_transformer = proc_or_block
+    invalidate_sanitized_context_cache(context_storage)
+  end
+
+  def self.additional_context_for_payload
+    if @additional_context_transformer.is_a?(Proc)
+      return sanitized_context_from(compact_context(additional_context))
+    end
+
+    storage = context_storage
+    cached = storage[SANITIZED_CONTEXT_CACHE_KEY]
+    return cached if cached
+
+    raw_context = storage[THREAD_CONTEXT_KEY]
+    if raw_context.nil? || (raw_context.is_a?(Hash) && raw_context.empty?)
+      return storage[SANITIZED_CONTEXT_CACHE_KEY] = {}.freeze
+    end
+
+    sanitized = sanitized_context_from(compact_context(raw_context))
+    storage[SANITIZED_CONTEXT_CACHE_KEY] = sanitized.freeze
+    sanitized
   end
 
   def self.safe_hash(obj)
@@ -69,6 +108,34 @@ module JsonLogging
     {}
   end
 
+  def self.warn_additional_context_once(key, message, error)
+    return if @additional_context_warned.include?(key)
+
+    @additional_context_warned.add(key)
+    warn "[activesupport-json_logging] #{message} (#{error.class}: #{error.message})"
+  end
+  private_class_method :warn_additional_context_once
+
+  def self.compact_context(context)
+    return {} unless context.is_a?(Hash)
+    return {} if context.empty?
+
+    context.compact
+  end
+  private_class_method :compact_context
+
+  def self.sanitized_context_from(compacted_context)
+    return {} if compacted_context.empty?
+
+    Sanitizer.sanitize_hash(compacted_context)
+  end
+  private_class_method :sanitized_context_from
+
+  def self.invalidate_sanitized_context_cache(storage)
+    storage[SANITIZED_CONTEXT_CACHE_KEY] = nil
+  end
+  private_class_method :invalidate_sanitized_context_cache
+
   # Returns an `ActiveSupport::Logger` that has already been wrapped with JSON logging concern.
   #
   # @param *args Arguments passed to ActiveSupport::Logger.new
@@ -97,6 +164,17 @@ module JsonLogging
   #   logger.tagged("BCX") { logger.info("Stuff") }  # Logs with tags
   #   logger.tagged("BCX").info("Stuff")  # Logs with tags (non-block form)
   def self.new(logger)
+    logger = prepare_logger_clone(logger)
+    logger.extend(JsonLoggerExtension)
+    formatter_with_tags = FormatterWithTags.new(logger)
+    logger.instance_variable_set(:@formatter_with_tags, formatter_with_tags)
+    # Custom formatters are not supported: JSON output requires FormatterWithTags.
+    logger.formatter = formatter_with_tags
+
+    logger
+  end
+
+  def self.prepare_logger_clone(logger)
     logger = logger.clone
     if logger.formatter
       logger.formatter = logger.formatter.clone
@@ -114,11 +192,7 @@ module JsonLogging
       end
     end
 
-    logger.extend(JsonLoggerExtension)
-    formatter_with_tags = FormatterWithTags.new(logger)
-    logger.instance_variable_set(:@formatter_with_tags, formatter_with_tags)
-    logger.formatter = formatter_with_tags
-
     logger
   end
+  private_class_method :prepare_logger_clone
 end

data/sig/json_logging.rbs

@@ -0,0 +1,8 @@
+module JsonLogging
+  VERSION: String
+
+  class EventSubscriber
+    def initialize: (?logger: untyped, ?io: untyped) -> void
+    def emit: (untyped event) -> void
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activesupport-json_logging
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -45,7 +45,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -64,47 +64,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: polyrun
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 2.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
@@ -119,20 +119,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.6'
-- !ruby/object:Gem::Dependency
-  name: simplecov-cobertura
-  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: standard
   requirement: !ruby/object:Gem::Requirement
@@ -301,8 +287,36 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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 6–8.
+  No extra deps beyond Rails/Activesupport. Compatible with Rails 7–8.
 email:
 - contact@kiskolabs.com
 executables: []
@@ -315,15 +329,21 @@ files:
 - lib/activesupport/json_logging.rb
 - lib/activesupport/json_logging/railtie.rb
 - lib/json_logging.rb
+- lib/json_logging/event_subscriber.rb
 - lib/json_logging/formatter.rb
 - lib/json_logging/formatter_with_tags.rb
 - lib/json_logging/helpers.rb
 - lib/json_logging/json_logger.rb
 - lib/json_logging/json_logger_extension.rb
+- lib/json_logging/line_encoder.rb
 - lib/json_logging/message_parser.rb
 - lib/json_logging/payload_builder.rb
 - lib/json_logging/sanitizer.rb
+- lib/json_logging/severity.rb
+- lib/json_logging/structured_hash_json_encoder.rb
+- lib/json_logging/structured_hash_sanitizer.rb
 - lib/json_logging/version.rb
+- sig/json_logging.rbs
 homepage: https://github.com/amkisko/activesupport-json_logging.rb
 licenses:
 - MIT
@@ -338,14 +358,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Structured JSON logging for Rails/ActiveSupport with safe, single-line entries.
 test_files: []