logstruct 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23182266ea1c9f53e0b824a8b806207b92255ed6a6d2755cf67c8f3d35680d19
-  data.tar.gz: 4d684c903461a10aa875314f6dac3fca9978ac190ce0616c3f6d34076c3b8ba7
+  metadata.gz: c9e72813c2641a2cc336184ab2e6f15b0d38e1f005da1ade37e136487a9c4369
+  data.tar.gz: b91cbaa7d64ea075db6937d415db0d0e7f86e58902083d54e0b985570a2573c5
 SHA512:
-  metadata.gz: 4a3dc3b56efac2d68703b77210006852059188425e612f537be307e7740da79781600dc4147d955c52c0e65a39978d476fefd0a796b07b7fe5ee170d2ce5b07a
-  data.tar.gz: bb328f655eda7dbcfb2ace155586966bfc47a4a60df88dcb7aa2e355b5213f0e76623d52e83906063a5aaff63039c8937c59bdd373c783faa7013a7c860acfac
+  metadata.gz: cb4d9ebb39a98d73f022c853daac9069599fe83528d0ca6234f2f63517803f48df932762827b37e5b4aae3b89e1da16c6d3b85005f54da7cab95dcfe8ee263d0
+  data.tar.gz: 7843625a239673d36ac68c092568927a9f5c112c830dd1b00caaf3c0e9d495fd6c9fb7514c18b5119000dc940f9a6706bbc2fb987506d55fefdd6264d9f0c568

data/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.2.2] - 2026-10-21
+
+### Changed
+
+- **Development**: Update Prettier, cspell and pnpm's setup action. The development tools require Node.js 22.18 or later in the 22.x series.
+- **Docs**: Upgrade the site to Next.js 16 and align its Node type declarations with the Node.js 22 runtime used in CI.
+
+### Fixed
+
+- **Filtering**: Nested URL query parameters such as `password[]` and `token[value]` are filtered, including URL-encoded names and paths in Rails' `filter_parameters`.
+- **Filtering**: Basic credentials are scrubbed even when their Base64 encoding is shorter than eight characters.
+- **Filtering**: Symbols beyond the nesting limit are summarized instead of being written without scrubbing.
+- **Filtering**: When a key or path matcher raises and error handling lets logging continue, its value is filtered. This also applies to Rails filter blocks.
+- **Errors**: A failed filter or scrubber does not keep queuing or reporting errors when it fails again while formatting its own error line or report context.
+- **Formatting**: Hash keys are normalized during filtering, so arrays, hashes and filtered values are no longer copied recursively before size limits are applied. Circular references are summarized at their first recurrence.
+- **Docs**: Correct the supported security release series and contributor instructions for releases, generated log types and schema fields. Describe size limits as limits per value, not a guarantee on total formatting time. Ensure the site's integration tests run when a local Watchman installation is broken.
+- **Development**: `task ci` verifies committed RBI files, matching GitHub CI, instead of downloading new annotations concurrently with typechecking.
+- **Generation**: A failed formatter or Sorbet JSON export stops code generation instead of leaving incomplete artifacts with a successful exit status.
+- **Development**: Update the locked `crass` dependency to 1.0.7, which fixes a denial-of-service issue in CSS number parsing.
+
 ## [0.2.1] - 2026-10-18
 
 ### Fixed

data/README.md

@@ -28,7 +28,7 @@ any other log platform. Sensitive values are filtered and scrubbed before a line
   `Bearer` and `Basic` credentials and sensitive URL query params (`?token=`) are replaced too. IP and MAC address
   scrubbing are opt-in.
 - **Limits.** Huge values are cut down (100 keys per Hash, 10 items per Array, 20 lines per backtrace, 32 KB per
-  String by default), so one large request body can't slow down your logging.
+  String by default), reducing log size and the work spent formatting large values.
 - **Error handling.** A mode for each kind of error decides whether it's raised, logged or reported, and whether
   that differs between development and production. Reports go to Sentry, Bugsnag, Rollbar, Honeybadger or your own
   reporter.

data/lib/log_struct/concerns/configuration.rb

@@ -260,7 +260,7 @@ module LogStruct
             !!result || (value.is_a?(String) && value != original_value)
           rescue => e
             handle_filter_error(e, filter, original_key || "")
-            false
+            true
           end
           ConfigStruct::PathFilterMatcher.new(callable: callable, label: filter.inspect)
         end
@@ -291,11 +291,11 @@ module LogStruct
               !!filter.call(key)
             rescue => e
               handle_filter_error(e, filter, key)
-              false
+              true
             end
           rescue => e
             handle_filter_error(e, filter, key)
-            false
+            true
           end
           ConfigStruct::FilterMatcher.new(callable: callable, label: filter.inspect)
         end

data/lib/log_struct/concerns/error_handling.rb

@@ -78,10 +78,15 @@ module LogStruct
         # request's parameters or a mail's recipients
         sig { params(context: T.nilable(T::Hash[Symbol, T.untyped])).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
         def filtered_context(context)
+          previous_internal_error = Thread.current[:logstruct_formatting_internal_error]
+          # The same filter may fail on the error's context. Keep that failure from reporting itself.
+          Thread.current[:logstruct_formatting_internal_error] = true
           return context if context.nil? || context.empty?
 
           filtered = Formatter.new.process_values(context)
           filtered.is_a?(Hash) ? filtered : {}
+        ensure
+          Thread.current[:logstruct_formatting_internal_error] = previous_internal_error
         end
 
         # Handle an error according to the configured error handling mode (log, report, raise, etc).
@@ -95,6 +100,12 @@ module LogStruct
             raise(error) if !LogStruct.is_production?
           end
 
+          # A broken filter or scrubber can also fail on its own error line. Enqueuing another error
+          # there would repeat forever on SemanticLogger's writer thread. Raise modes still raise.
+          if source == Source::Internal && Thread.current[:logstruct_formatting_internal_error] && mode != ErrorHandlingMode::Raise
+            return
+          end
+
           case mode
           when ErrorHandlingMode::Ignore
             # Do nothing

data/lib/log_struct/formatter.rb

@@ -194,12 +194,12 @@ module LogStruct
       StringScrubber.valid_utf8(string)
     end
 
-    # A String or Symbol key as valid UTF-8 (symbolize_keys makes Symbols of binary String keys)
+    # Normalize only keys that will be logged, after applying the size limits.
     sig { params(key: T.untyped).returns(T.untyped) }
     def valid_utf8_key(key)
       case key
       when String
-        valid_utf8(key)
+        valid_utf8(key).to_sym
       when Symbol
         name = key.name
         fixed = valid_utf8(name)
@@ -232,31 +232,6 @@ module LogStruct
       "#{kept}... (cut from #{string.bytesize} bytes)"
     end
 
-    # Like deep_symbolize_keys, but stops at circular references and at the depth where
-    # process_values stops, leaving those values for process_values to summarize
-    sig { params(value: T.untyped, recursion_depth: Integer, ancestors: T::Hash[T.untyped, T::Boolean]).returns(T.untyped) }
-    def symbolize_keys(value, recursion_depth: 0, ancestors: {}.compare_by_identity)
-      return value if recursion_depth > MAX_RECURSION_DEPTH || ancestors.key?(value)
-
-      case value
-      when Hash
-        ancestors[value] = true
-        result = value.each_with_object({}) do |(key, nested_value), symbolized|
-          symbol_key = key.respond_to?(:to_sym) ? key.to_sym : key
-          symbolized[symbol_key] = symbolize_keys(nested_value, recursion_depth: recursion_depth + 1, ancestors: ancestors)
-        end
-        ancestors.delete(value)
-        result
-      when Array
-        ancestors[value] = true
-        result = value.map { |item| symbolize_keys(item, recursion_depth: recursion_depth + 1, ancestors: ancestors) }
-        ancestors.delete(value)
-        result
-      else
-        value
-      end
-    end
-
     # Describes a value without filtering, scrubbing or serializing it, so that values which
     # couldn't be processed are never logged raw. Hashes and arrays are not serialized because
     # they may contain circular references.
@@ -267,16 +242,16 @@ module LogStruct
         {_filtered: {_class: arg.class.name, _keys_count: arg.size}}
       when Array
         {_filtered: {_class: arg.class.name, _count: arg.size}}
-      when String
+      when String, Symbol
         {_filtered: {_class: arg.class.name}}
-      when Numeric, Symbol, TrueClass, FalseClass, NilClass
+      when Numeric, TrueClass, FalseClass, NilClass
         arg
       else
         {_filtered: {_class: arg.class.name}}
       end
     end
 
-    sig { params(log_value: T.untyped, time: Time).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(log_value: T.untyped, time: Time).returns(T::Hash[T.untyped, T.untyped]) }
     def log_value_to_hash(log_value, time:)
       case log_value
       when Log::Interfaces::CommonFields
@@ -284,12 +259,10 @@ module LogStruct
         log_value.serialize
 
       when T::Struct
-        # Default T::Struct.serialize methods returns a hash with string keys, so convert them to symbols
-        symbolize_keys(log_value.serialize)
+        log_value.serialize
 
       when Hash
-        # Use hash as is and convert string keys to symbols
-        symbolize_keys(log_value)
+        log_value
 
       when Exception
         # logger.error(exception): its class, message and backtrace
@@ -357,9 +330,15 @@ module LogStruct
       ).returns(String)
     end
     def call(severity, time, progname, log_value, request_id: nil, context: nil, tags: nil)
+      previous_internal_error = Thread.current[:logstruct_formatting_internal_error]
       level_enum = Level.from_severity(severity)
 
       data = log_value_to_hash(log_value, time: time)
+      source = data[:src] || data["src"]
+      event = data[:evt] || data["evt"]
+      if [Source::Internal, :logstruct, "logstruct"].include?(source) && [Event::Error, :error, "error"].include?(event)
+        Thread.current[:logstruct_formatting_internal_error] = true
+      end
 
       # Filter params, scrub sensitive values, format ActiveJob GlobalID arguments
       data = process_values(data)
@@ -376,6 +355,8 @@ module LogStruct
       rescue SystemStackError, StandardError => e
         unwritable_line_json(data, e)
       end
+    ensure
+      Thread.current[:logstruct_formatting_internal_error] = previous_internal_error
     end
 
     # A line that can't be written as JSON is replaced by one that says so, instead of being lost
@@ -420,7 +401,7 @@ module LogStruct
       if request_id.is_a?(String) && !request_id.empty? && !data.key?(:req_id)
         metadata[:req_id] = request_id
       end
-      metadata[:ctx] = symbolize_keys(context) if context.present?
+      metadata[:ctx] = context if context.present?
       return if metadata.empty?
 
       processed = process_values(metadata)

data/lib/log_struct/integrations/shrine.rb

@@ -104,7 +104,7 @@ module LogStruct
       end
 
       # Upload options with the file names taken out of a Content-Disposition (upload_options:
-      # {content_disposition: ...}, which the upload_options plugin often sets): they can name a person
+      # `{content_disposition: ...}`, which the upload_options plugin often sets): they can name a person
       sig { params(options: T.untyped).returns(T.untyped) }
       def self.without_file_names(options)
         return options unless options.is_a?(Hash)

data/lib/log_struct/monkey_patches/active_support/tagged_logging/formatter.rb

@@ -6,8 +6,8 @@ require "active_support/tagged_logging"
 # Monkey-patch ActiveSupport::TaggedLogging::Formatter to work with structured logging.
 #
 # Problem: Rails' TaggedLogging prepends tags as text and converts messages to strings.
-# When we pass a hash to super(), Rails does "#{tags_text}#{msg}" which calls .to_s
-# on the hash, producing Ruby inspect format {message: "..."} instead of valid JSON.
+# When we pass a hash to super(), Rails does `"#{tags_text}#{msg}"` which calls .to_s
+# on the hash, producing Ruby inspect format `{message: "..."}` instead of valid JSON.
 #
 # Solution: When LogStruct is enabled, we add tags as a hash entry and delegate to
 # LogStruct::Formatter for proper JSON serialization with filtering and standard fields.
@@ -58,4 +58,6 @@ module ActiveSupport
   end
 end
 
-ActiveSupport::TaggedLogging::Formatter.prepend(ActiveSupport::TaggedLogging::FormatterExtension)
+module ActiveSupport::TaggedLogging::Formatter
+  prepend ActiveSupport::TaggedLogging::FormatterExtension
+end

data/lib/log_struct/param_filters.rb

@@ -44,7 +44,8 @@ module LogStruct
           matcher.matches?(normalized_key, value)
         rescue => e
           handle_filter_matcher_error(e, matcher.label, normalized_key)
-          false
+          # An unsuccessful filter must never expose the value it was meant to protect.
+          true
         end
         return true if matched
         return false if filters.path_matchers.empty?
@@ -55,7 +56,7 @@ module LogStruct
           matcher.matches?(path, value, root)
         rescue => e
           handle_filter_matcher_error(e, matcher.label, normalized_key)
-          false
+          true
         end
       end
 
@@ -101,8 +102,8 @@ module LogStruct
 
         {
           _class: Hash,
-          _keys_count: hash.keys.size,
-          _keys: hash.keys.take(10).map { |key| normalize_summary_key(StringScrubber.scrub_name(key)) }
+          _keys_count: hash.size,
+          _keys: hash.each_key.take(10).map { |key| normalize_summary_key(StringScrubber.scrub_name(key)) }
         }
       end
 

data/lib/log_struct/string_scrubber.rb

@@ -239,7 +239,7 @@ module LogStruct
       def authorization_credentials?(scheme, credentials)
         return credentials.length >= 16 if scheme.casecmp?("bearer")
 
-        credentials.length >= 8 && Base64.strict_decode64(credentials).include?(":")
+        Base64.strict_decode64(credentials).include?(":")
       rescue ArgumentError
         false
       end
@@ -260,7 +260,7 @@ module LogStruct
         end
       end
 
-      # user[password] is checked as password, written plainly or URL-encoded
+      # Every part of a nested name is checked: both password[] and token[value] carry secrets.
       sig { params(name: String, value: String).returns(T::Boolean) }
       def sensitive_query_param?(name, value)
         decoded = begin
@@ -268,10 +268,11 @@ module LogStruct
         rescue ArgumentError
           name
         end
-        key = decoded[/\[([^\[\]]*)\]\z/, 1] || decoded
-        return false if key.empty?
-
-        SENSITIVE_QUERY_PARAMS.include?(key.downcase) || ParamFilters.should_filter_key?(key, value)
+        path = T.let([], T::Array[String])
+        decoded.split(/[\[\]]/).reject(&:empty?).any? do |key|
+          path << key
+          SENSITIVE_QUERY_PARAMS.include?(key.downcase) || ParamFilters.should_filter_key?(key, value, path: path)
+        end
       end
 
       # The Luhn checksum that every card number passes

data/lib/log_struct/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module LogStruct
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/logstruct.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "An opinionated and type-safe structured logging solution. " \
     "Configures any Rails app to log JSON to stdout. " \
     "Structured logging is automatically configured for many gems, including Sidekiq, Carrierwave, Shrine, etc. " \
-    "Log messages, params, and job args are automatically filtered and scrubbed to remove any sensitive info."
+    "Log messages, params, and job args are filtered by sensitive keys and scrubbed for common credential and personal data patterns."
   spec.homepage = "https://logstruct.com"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.3.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logstruct
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - DocSpring
@@ -270,7 +270,8 @@ dependencies:
 description: An opinionated and type-safe structured logging solution. Configures
   any Rails app to log JSON to stdout. Structured logging is automatically configured
   for many gems, including Sidekiq, Carrierwave, Shrine, etc. Log messages, params,
-  and job args are automatically filtered and scrubbed to remove any sensitive info.
+  and job args are filtered by sensitive keys and scrubbed for common credential and
+  personal data patterns.
 email:
 - support@docspring.com
 executables: []