rails-profiler 0.33.1 → 0.33.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d632e07d28796ba7902cd20f9466b4c529c77ab76b5627c2b946e6b059b23c1f
-  data.tar.gz: 7c91607d3ae24180f6708938a8dfa118ad297b11a6b9749cf155adeef5b81336
+  metadata.gz: 8e1caccb1662a8f09108682f5933e943d41a0b36ed7d60930c60eb8c385b5159
+  data.tar.gz: c10d767853cc07caa36484f9693a4c4adeef415e0874d29ca817d8d7d1b17730
 SHA512:
-  metadata.gz: a7781894a3b105e730d47d63c0e7a2a15b28a58a51a38fc4662fb193c0665c1cdb8fd7072cadc7926f38a96e6a68a350ae19f16ef2560a119c89355fdbe3f4a6
-  data.tar.gz: e626c7d2d344ad58473fdecbbbaf3bfae340faf17eb1dd25ca7f88325ffe87c9a9837fefcdc9b1dea3cdc3541ce46a4156d1d4b17acd3f4b049defd2c08fcd03
+  metadata.gz: 8aacfc0469f52d9f6a11a58356eebb853ff716f2729ca47833b9b0ca99197f767a0dad5904f8c9e7d8a8501869dd712a0c5e6e246fa8ea0e55976b546589d1ac
+  data.tar.gz: 3ce33e8db95c0ae4028a68e11d941bb72072b5a6edcf539cfc0fb918c2248d675c4df92e28788da0d59d942546458384b22ec5ac974bb58404be1d0049130627

data/CHANGELOG.md

@@ -19,6 +19,47 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.33.2] - 2026-10-14
+
+<!-- stamped -->
+
+### Changed
+
+- **Configuration:** A String in `config.http_skip_hosts` is now a host name, compared whole and
+  ignoring case, instead of a pattern: `"example.com"` no longer leaves out `notexample.com`,
+  `exampleXcom` or `example.com.attacker.net`. A String that starts with a dot is a domain whose
+  subdomains are left out (`".internal"` leaves out `api.internal`). A Regexp is matched as
+  before. An entry that is not a host name, a wildcard String (`"*.internal"`), an empty one, or
+  anything that is neither a String nor a Regexp (`nil`), is left out when the list is set, with
+  a warning in the log that says what to write, and the other entries are kept. It does not
+  raise: the gem is loaded in production too, where a mistake in this list must not stop the
+  application from booting, even with the profiler disabled.
+- **Dumps:** A dump is stored as its formatted text only: the raw `value` field, which no tab
+  read and the API did not document, is no longer part of the dump data.
+
+### Fixed
+
+- **Configuration:** A String in `config.skip_paths` no longer fails every request with a
+  `TypeError`: it skips the path equal to it, and a Regexp is matched as before. A single
+  pattern, a String or a Regexp, set without a list is read as a list of one.
+- **Outbound HTTP:** A String in `config.http_skip_hosts` that is not a valid Regexp, such as
+  `"*.internal"` added with `<<`, no longer fails every `Net::HTTP` call of a profiled request
+  with a `RegexpError`.
+- **Database:** A query that binds bytes, a `blob` or `bytea` column such as an image, no longer
+  loses the profile of its request when it is saved: the bind shows as text when its bytes are
+  valid UTF-8, and as `[binary data, N bytes]` otherwise.
+- **Logs:** A line logged with bytes that are not valid UTF-8 no longer raises an
+  `Encoding::CompatibilityError` in the application's own logger call (Rails 7.1 and later), and
+  a binary line no longer loses the profile when it is saved: the line is kept as UTF-8, what
+  cannot be read replaced with U+FFFD, and a line in another encoding is converted.
+- **Dumps:** `Profiler.dump` of an object that refers to itself, directly or through an instance
+  variable, no longer fails the request with a `SystemStackError` (a 500 with the file store), and
+  an Array or a Hash holding itself no longer loses the profile. An object whose own `inspect`
+  recurses without end shows `[Error formatting value: stack level too deep]`.
+- **Middleware:** A page whose body is made of fragments of different encodings, a binary one
+  among UTF-8 ones, no longer fails with an `Encoding::CompatibilityError` once profiled: its
+  bytes are joined as the application gave them, and it gets its toolbar.
+
 ## [0.33.1] - 2026-10-14
 
 <!-- stamped -->

data/lib/profiler/collectors/database_collector.rb

@@ -9,6 +9,8 @@ module Profiler
       BACKTRACE_DEPTH = 10
       MAX_SCANNED_FRAMES = 100
       FRAMES_PAST_APPLICATION = 15
+      # What a bind holding bytes that are not text shows instead (see #displayable_bind).
+      BINARY_BIND = "[binary data, %d bytes]"
 
 
       # Frames between the application's code and the subscriber: the profiler itself, the
@@ -122,9 +124,9 @@ module Profiler
         binds.map do |bind|
           if bind.respond_to?(:value)
             name = bind.name if bind.respond_to?(:name)
-            Profiler::Redaction.filter_named(name, bind.value)
+            displayable_bind(Profiler::Redaction.filter_named(name, bind.value))
           else
-            bind
+            displayable_bind(bind)
           end
         end
       rescue StandardError
@@ -132,6 +134,18 @@ module Profiler
         binds.map { Profiler::Redaction::MASK }
       end
 
+      # A blob or bytea value is bytes, not text: kept as it is, it fails the JSON of the whole
+      # profile when it is saved. Bytes that are valid UTF-8 are shown as text, others as their
+      # size. Text in another encoding stays as it is: JSON converts it.
+      def displayable_bind(value)
+        value = value.to_s if defined?(ActiveModel::Type::Binary::Data) && value.is_a?(ActiveModel::Type::Binary::Data)
+        return value unless value.is_a?(String)
+        return value if value.valid_encoding? && value.encoding != Encoding::BINARY
+
+        utf8 = value.dup.force_encoding(Encoding::UTF_8)
+        utf8.valid_encoding? ? utf8 : format(BINARY_BIND, value.bytesize)
+      end
+
       # Capturing the caller costs tens of microseconds. The first run of a statement locates
       # it, an N+1 loop included (its repeats are the same statement with other values); a slow
       # query is always located.

data/lib/profiler/collectors/dump_collector.rb

@@ -33,9 +33,10 @@ module Profiler
         dumps = @dumps || Thread.current[:profiler_dumps] || []
         unsubscribe
 
+        # Only the formatted text is kept: the object itself can refer to itself, or hold what
+        # JSON cannot write, and would make the profile fail when it is saved.
         formatted_dumps = dumps.map do |dump|
           {
-            value: dump[:value],
             formatted: format_value(dump[:value]),
             file: dump[:file],
             line: dump[:line],
@@ -97,7 +98,8 @@ module Profiler
           formatted += ">"
           formatted
         end
-      rescue => e
+      # An inspect of the application's that recurses without end is said, like any other error.
+      rescue StandardError, SystemStackError => e
         "[Error formatting value: #{e.message}]"
       end
     end

data/lib/profiler/collectors/log_collector.rb

@@ -68,7 +68,7 @@ module Profiler
 
           entry = {
             level: SEVERITY_LABELS[severity] || "UNKNOWN",
-            message: msg.to_s.strip,
+            message: self.class.readable(msg.to_s).strip,
             timestamp: Time.now.iso8601(3)
           }
           logs.respond_to?(:record) ? logs.record(entry) : logs << entry
@@ -78,6 +78,20 @@ module Profiler
         def <<(msg)
           add(0, msg.to_s)
         end
+
+        # The line as valid UTF-8, a copy when it has to change: bytes that are not text in its
+        # encoding would raise in strip, inside the application's own logger call, or fail the
+        # JSON of the profile when it is saved. Binary bytes are read as UTF-8; a line in another
+        # encoding is converted. What cannot be read becomes U+FFFD.
+        def self.readable(text)
+          return text if text.encoding == Encoding::UTF_8 && text.valid_encoding?
+
+          if [Encoding::UTF_8, Encoding::BINARY, Encoding::US_ASCII].include?(text.encoding)
+            text.dup.force_encoding(Encoding::UTF_8).scrub
+          else
+            text.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+          end
+        end
       end
 
       def icon

data/lib/profiler/configuration.rb

@@ -38,13 +38,13 @@ module Profiler
     LOCAL_HTTP_HOSTS = [/\A127\.0\.0\.1\z/, /\Alocalhost\z/i, /\A::1\z/].freeze
 
     attr_accessor :storage_options, :collectors,
-                  :skip_paths, :slow_query_threshold, :max_queries_warning, :sql_backtrace,
+                  :slow_query_threshold, :max_queries_warning, :sql_backtrace,
                   :track_memory, :allocated_objects_warning_threshold,
                   :mcp_enabled, :mcp_transport, :mcp_port,
                   :authorization_mode, :extension_cors_enabled,
                   :cors_allowed_origins, :api_forgery_protection, :frame_ancestors,
                   :track_ajax, :ajax_skip_paths,
-                  :track_http, :slow_http_threshold, :http_skip_hosts, :http_backtrace_depth,
+                  :track_http, :slow_http_threshold, :http_backtrace_depth,
                   :track_jobs,
                   :track_console,
                   :apply_env_overrides_when_disabled, :restrict_storage_permissions,
@@ -148,7 +148,23 @@ module Profiler
       @tmp_path = value.nil? ? nil : Pathname.new(value)
     end
 
-    attr_reader :cluster_allowed_slave_urls, :mcp_allowed_hosts
+    attr_reader :cluster_allowed_slave_urls, :mcp_allowed_hosts, :skip_paths, :http_skip_hosts
+
+    # Paths that are not profiled: a Regexp matched against the path, or a String equal to it.
+    # A single pattern is a list of one.
+    def skip_paths=(value)
+      @skip_paths = Array(value)
+    end
+
+    # Hosts whose outbound calls are left out: a String is a host name, matched whole and
+    # case-insensitively, or, when it starts with a dot (".internal"), a domain whose subdomains
+    # are left out; a Regexp is matched against the host name. Any other entry (a wildcard
+    # "*.internal", an empty String, nil) is left out with a warning in the log, the others kept:
+    # the gem is loaded in production too, where a mistake here must not stop the application
+    # from booting.
+    def http_skip_hosts=(value)
+      @http_skip_hosts = Array(value).select { |entry| valid_http_skip_host?(entry) }
+    end
 
     # Host names the MCP HTTP endpoint accepts beyond the loopback ones and config.hosts: a String
     # (a host name, any port, or a host:port) or a Regexp anchored with \A and \z, matched
@@ -323,6 +339,22 @@ module Profiler
       end
     end
 
+    def valid_http_skip_host?(entry)
+      problem =
+        case entry
+        when Regexp then nil
+        when String
+          if entry.strip.empty? || entry.match?(/[*\s]/)
+            "is not a host name; list each host, a domain as \".internal\" for its subdomains, or use a Regexp"
+          end
+        else "must be a String or a Regexp"
+        end
+      return true unless problem
+
+      Profiler.log_warn("config.http_skip_hosts: #{entry.inspect} #{problem}; ignored")
+      false
+    end
+
     def validate_mcp_allowed_host_pattern(pattern)
       unless Profiler::Cluster::Security.anchored_pattern?(pattern)
         raise ArgumentError, "config.mcp_allowed_hosts: #{pattern.inspect} must start with \\A and end with \\z, " \

data/lib/profiler/instrumentation/net_http_instrumentation.rb

@@ -122,12 +122,29 @@ module Profiler
       # it are the profiler's, whichever code makes them.
       def self.skip_host?(host, port = nil)
         config = Profiler.configuration
-        return true if config.http_skip_hosts.any? { |pattern| host.match?(pattern) }
+        return true if config.http_skip_hosts.any? { |pattern| skip_host_pattern?(pattern, host) }
 
         master = master_address(config.master_url)
         !master.nil? && master[0].casecmp?(host) && (port.nil? || master[1] == port)
       end
 
+      # A String is never read as a Regexp: "example.com" would match notexample.com, and
+      # "*.internal" would raise on every call. It is the host name, or, starting with a dot, a
+      # domain whose subdomains match. A list changed in place (<<) is not validated: anything
+      # else matches nothing.
+      def self.skip_host_pattern?(pattern, host)
+        case pattern
+        when Regexp then pattern.match?(host)
+        when String
+          if pattern.start_with?(".")
+            host.length > pattern.length && host.downcase.end_with?(pattern.downcase)
+          else
+            pattern.casecmp?(host)
+          end
+        else false
+        end
+      end
+
       def self.master_address(url)
         return nil if url.nil? || url.to_s.empty?
 

data/lib/profiler/middleware/profiler_middleware.rb

@@ -278,7 +278,8 @@ module Profiler
 
         # Skip profiler's own paths and static assets
         path = env["PATH_INFO"]
-        Profiler.configuration.skip_paths.none? { |pattern| path =~ pattern }
+        # === matches a Regexp against the path and compares a String with it.
+        Profiler.configuration.skip_paths.none? { |pattern| pattern === path }
       end
 
       def build_request(env)
@@ -371,13 +372,7 @@ module Profiler
       def read_buffered_body(body)
         content =
           begin
-            if body.respond_to?(:to_ary)
-              body.to_ary.join
-            else
-              parts = +""
-              body.each { |part| parts << part }
-              parts
-            end
+            join_parts(body.respond_to?(:to_ary) ? body.to_ary : body)
           rescue Exception # rubocop:disable Lint/RescueException
             begin
               close_body(body)
@@ -390,6 +385,20 @@ module Profiler
         content
       end
 
+      # The fragments' bytes, joined as they are: fragments of different encodings (a binary one
+      # among UTF-8 ones) cannot be joined as text, and converting them would change the page.
+      # The result takes the encoding of the first fragment, as CapturingBody does.
+      def join_parts(parts)
+        content = String.new(encoding: Encoding::BINARY)
+        encoding = nil
+        parts.each do |part|
+          part = part.to_s
+          encoding ||= part.encoding
+          content << part.b
+        end
+        content.force_encoding(encoding || Encoding::UTF_8)
+      end
+
       def close_body(body)
         body.close if body.respond_to?(:close) && !(body.respond_to?(:closed?) && body.closed?)
       end

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.33.1"
+  VERSION = "0.33.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.33.1
+  version: 0.33.2
 platform: ruby
 authors:
 - Sébastien Duplessy