rails-profiler 0.31.4 → 0.31.5

data/lib/profiler/instrumentation/net_http_instrumentation.rb

@@ -6,6 +6,7 @@ require "zlib"
 require "stringio"
 require "securerandom"
 require_relative "../redaction"
+require_relative "../configuration"
 
 module Profiler
   module Instrumentation
@@ -17,36 +18,19 @@ module Profiler
           # Re-entrancy guard: Net::HTTP#request calls itself recursively when
           # the connection isn't started yet. Only record the outermost call.
           return super if Thread.current[:profiler_http_recording]
+          # The profiler's own calls (Profiler.untracked_http).
+          return super if Thread.current[:profiler_http_untracked]
 
           host = address.to_s
-          return super if NetHttpInstrumentation.skip_host?(host)
+          return super if NetHttpInstrumentation.skip_host?(host, port)
 
           url = Redaction.filter_url(build_url(host, port, req.path, use_ssl?))
-          req_body = req.body.to_s
-          # Fallback: body may be passed as the 2nd argument and only applied
-          # to req inside super via req.set_body_internal(body)
-          req_body = body.to_s if req_body.empty? && body
-          # Fallback: libraries like RestClient set body_stream instead of body
-          # and pass nil as the 2nd argument to Net::HTTP#request.
-          # Read the stream content, then restore it so the actual request works.
-          # RestClient::Payload doesn't implement #rewind, so we fall back to
-          # replacing body_stream with a fresh StringIO.
-          if req_body.empty? && req.body_stream
-            begin
-              stream = req.body_stream
-              req_body = stream.read.to_s
-              if stream.respond_to?(:rewind)
-                stream.rewind
-              else
-                req.body_stream = StringIO.new(req_body)
-              end
-            rescue
-              req_body = ""
-            end
-          end
+          limit = Profiler.configuration.max_captured_body_bytes
+          captured = NetHttpInstrumentation.capture_request_body(req, body, limit)
           req_headers = Redaction.filter_headers(req.to_hash.transform_values { |v| v.join(", ") })
           req_content_type = req["content-type"].to_s
-          processed_req = req_body.empty? ? { body: nil, encoding: "text" } : NetHttpInstrumentation.process_body(req_body, req_content_type)
+          req_body = captured[:content]
+          processed_req = req_body.nil? || req_body.empty? ? { body: nil, encoding: "text" } : NetHttpInstrumentation.process_body(req_body, req_content_type)
 
           request_id = SecureRandom.hex(8)
           started_at = Time.now.iso8601(3)
@@ -63,7 +47,10 @@ module Profiler
             request_headers: req_headers,
             request_body: processed_req[:body],
             request_body_encoding: processed_req[:encoding],
-            request_size: req_body.bytesize,
+            request_size: captured[:size],
+            request_size_is_minimum: captured[:size_is_minimum],
+            request_body_truncated: captured[:truncated],
+            request_body_not_captured: captured[:not_captured],
             backtrace: NetHttpInstrumentation.extract_backtrace
           )
 
@@ -74,7 +61,9 @@ module Profiler
           duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
           resp_body_raw = response.body.to_s
           resp_content_encoding = response["content-encoding"].to_s.strip.downcase
-          resp_body = NetHttpInstrumentation.decompress_body(resp_body_raw, resp_content_encoding)
+          resp_body = NetHttpInstrumentation.decompress_body(resp_body_raw, resp_content_encoding, limit)
+          resp_truncated = limit ? resp_body.bytesize > limit : false
+          resp_body = Redaction.cut_bytes(resp_body, limit) if resp_truncated
           resp_content_type = response["content-type"].to_s
           processed_resp = NetHttpInstrumentation.process_body(resp_body, resp_content_type)
 
@@ -87,7 +76,8 @@ module Profiler
             response_headers: Redaction.filter_headers(response.to_hash.transform_values { |v| v.join(", ") }),
             response_body: processed_resp[:body],
             response_body_encoding: processed_resp[:encoding],
-            response_size: resp_body_raw.bytesize
+            response_size: resp_body_raw.bytesize,
+            response_body_truncated: resp_truncated
           )
 
           fg = Thread.current[:profiler_flamegraph_collector]
@@ -113,7 +103,11 @@ module Profiler
         end
       end
 
+      # Deprecated, as it was: the hosts earlier versions always left out, kept for code that read
+      # them. They are left out only when listed in config.http_skip_hosts now
+      # (Profiler::Configuration::LOCAL_HTTP_HOSTS).
       SKIP_HOSTS = %w[127.0.0.1 localhost ::1].freeze
+      deprecate_constant :SKIP_HOSTS
 
       TEXT_CONTENT_TYPES   = /\A(text\/|application\/(json|xml|xhtml|javascript|x-www-form-urlencoded)|image\/svg)/i
       BINARY_CONTENT_TYPES = /\A(image\/|application\/pdf|application\/octet-stream|application\/zip|audio\/|video\/)/i
@@ -124,26 +118,126 @@ module Profiler
         @installed = true
       end
 
-      def self.skip_host?(host)
-        SKIP_HOSTS.include?(host) ||
-          Profiler.configuration.http_skip_hosts.any? { |p| host.match?(p) }
+      # The hosts of http_skip_hosts, and the cluster's master (host and port): a slave's calls to
+      # 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) }
+
+        master = master_address(config.master_url)
+        !master.nil? && master[0].casecmp?(host) && (port.nil? || master[1] == port)
       end
 
-      def self.decompress_body(body, content_encoding)
-        return body if content_encoding.empty? || body.nil? || body.empty?
+      def self.master_address(url)
+        return nil if url.nil? || url.to_s.empty?
 
-        case content_encoding
-        when "gzip", "x-gzip"
-          Zlib::GzipReader.new(StringIO.new(body)).read
-        when "deflate"
-          Zlib::Inflate.inflate(body)
-        else
-          body
+        uri = URI(url.to_s)
+        uri.host ? [uri.host.delete_prefix("[").delete_suffix("]"), uri.port] : nil
+      rescue URI::Error
+        nil
+      end
+
+      # What a profile keeps of the body Net::HTTP is about to send: at most +limit+ bytes, and
+      # the whole size when known (size_is_minimum when only a lower bound is). A body_stream is
+      # read only when it can be put back where it was (a StringIO, a file), and no further than
+      # its Content-Length; a pipe, a socket or an object without pos (a multipart payload) is
+      # never touched, as reading it would leave nothing to send.
+      def self.capture_request_body(req, body, limit)
+        content = req.body
+        content = body if (content.nil? || content.empty?) && body
+        unless content.nil? || content.to_s.empty?
+          content = content.to_s
+          truncated = limit ? content.bytesize > limit : false
+          return { content: truncated ? Redaction.cut_bytes(content, limit) : content,
+                   size: content.bytesize, size_is_minimum: false, truncated: truncated, not_captured: false }
         end
-      rescue StandardError
+
+        stream = req.body_stream
+        return { content: nil, size: 0, size_is_minimum: false, truncated: false, not_captured: false } unless stream
+
+        declared = req["content-length"].to_s
+        declared = declared.match?(/\A\d+\z/) ? declared.to_i : nil
+        unless rewindable?(stream)
+          return { content: nil, size: declared, size_is_minimum: false, truncated: false, not_captured: true }
+        end
+
+        position = stream.pos
+        total = declared || remaining_size(stream, position)
+        want = [limit && limit + 1, total].compact.min
+        begin
+          read = (want ? stream.read(want) : stream.read).to_s
+        ensure
+          stream.pos = position
+        end
+        # Bytes as they were sent: labelled UTF-8, the encoding of text on the wire, for the text
+        # filter; a binary type is kept as bytes whatever the label.
+        read = read.dup.force_encoding(Encoding::UTF_8)
+        cut = limit ? read.bytesize > limit : false
+        content = cut ? Redaction.cut_bytes(read, limit) : read
+        size = total || read.bytesize
+        { content: content, size: size, size_is_minimum: total.nil? && cut,
+          truncated: content.bytesize < size, not_captured: false }
+      rescue IOError, SystemCallError => e
+        Profiler.log_error_once(:net_http_body_stream, "NetHttpInstrumentation: could not read a request body_stream", e)
+        { content: nil, size: declared, size_is_minimum: false, truncated: false, not_captured: true }
+      end
+
+      # What is left to read of a stream that knows its size (a StringIO, a file), else nil.
+      def self.remaining_size(stream, position)
+        size = stream.respond_to?(:size) ? stream.size : nil
+        size.is_a?(Integer) ? [size - position, 0].max : nil
+      rescue IOError, SystemCallError
+        nil
+      end
+
+      def self.rewindable?(stream)
+        return false unless stream.respond_to?(:pos) && stream.respond_to?(:pos=) && stream.respond_to?(:read)
+        return stream.stat.file? if stream.respond_to?(:stat)
+
+        true
+      rescue IOError, SystemCallError
+        false
+      end
+
+      # Inflated up to the limit, give or take one buffer of the inflater (16 KB): a small
+      # compressed answer can stand for a huge text, which a profile never keeps whole. Labelled
+      # UTF-8, as the text it is when its type is a text one.
+      def self.decompress_body(body, content_encoding, limit = nil)
+        return body if content_encoding.empty? || body.nil? || body.empty?
+
+        inflated =
+          case content_encoding
+          when "gzip", "x-gzip" then inflate_capped(body, limit, Zlib::MAX_WBITS + 16)
+          when "deflate" then inflate_capped(body, limit, Zlib::MAX_WBITS)
+          else return body
+          end
+        inflated.force_encoding(Encoding::UTF_8)
+      rescue Zlib::Error
         body
       end
 
+      # The input goes in by small slices, and the output is taken buffer by buffer: the
+      # inflating stops as soon as the limit is passed.
+      def self.inflate_capped(body, limit, window_bits)
+        inflater = Zlib::Inflate.new(window_bits)
+        return inflater.inflate(body) unless limit
+
+        out = +""
+        offset = 0
+        catch(:full) do
+          while offset < body.bytesize && !inflater.finished?
+            inflater.inflate(body.byteslice(offset, 1024)) do |chunk|
+              out << chunk
+              throw :full if out.bytesize > limit
+            end
+            offset += 1024
+          end
+        end
+        out
+      ensure
+        inflater&.close
+      end
+
       def self.process_body(body, content_type)
         return { body: nil, encoding: "text" } if body.nil? || body.empty?
 
@@ -153,8 +247,12 @@ module Profiler
           # Masked on the raw bytes, before the encoding hides them from any later search.
           { body: Base64.strict_encode64(Redaction.hide_credentials(body.b)), encoding: "base64" }
         else
+          # Bytes are read as UTF-8, as a text body on the wire is; what is not valid UTF-8 shows
+          # as "?".
+          body = body.dup.force_encoding(Encoding::UTF_8) if body.encoding == Encoding::BINARY
           text = Redaction.filter_body(body, content_type)
                           .encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+          text = text.scrub("?") unless text.valid_encoding?
           { body: text, encoding: "text" }
         end
       end

data/lib/profiler/job_profiler.rb

@@ -105,7 +105,7 @@ module Profiler
             collector.collect if collector.respond_to?(:collect)
             profile.add_collector_metadata(collector)
           rescue => e
-            warn "Profiler JobProfiler: Collector #{collector.class} failed: #{e.message}"
+            Profiler.log_error("JobProfiler: collector #{collector.class} failed", e)
           end
         end
 

data/lib/profiler/local_request.rb

@@ -57,18 +57,14 @@ module Profiler
           @warned = true
         end
 
-        message = "[Profiler] Request refused or not profiled by authorization_mode :allow_local: #{reason}. " \
+        message = "Request refused or not profiled by authorization_mode :allow_local: #{reason}. " \
                   "The profiler only serves and captures requests made from this machine. " \
                   "If the application runs in Docker or behind a remote proxy, either set " \
                   "config.authorization_mode = :allow_authorized with a config.authorize_with block " \
                   "that admits your network (see the Access control section of the README), or set " \
                   "config.authorization_mode = :allow_all, which offers no protection at all. " \
                   "This message is logged once per process."
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.warn(message)
-        else
-          warn(message)
-        end
+        Profiler.log_warn(message)
       end
 
       def reset_warning!

data/lib/profiler/mcp/file_cache.rb

@@ -26,7 +26,8 @@ module Profiler
 
         dir = Storage::PrivateFiles.tmp_dir(DIR_NAME, token)
         Storage::PrivateFiles.write(dir.join(name), content)
-      rescue Errno::EACCES, Errno::EROFS
+      rescue Errno::EACCES, Errno::EROFS => e
+        Profiler.log_error_once(:mcp_file_cache, "MCP: could not cache a body under tmp_path", e)
         nil
       end
 

data/lib/profiler/mcp/server.rb

@@ -57,7 +57,7 @@ module Profiler
         when :stdio
           ::MCP::Server::Transports::StdioTransport.new(@server).open
         when :http
-          $stderr.puts "MCP HTTP transport active — endpoint: /_profiler/mcp"
+          Profiler.log_info("MCP: HTTP transport active, endpoint /_profiler/mcp")
         else
           raise Error, "Unknown transport: #{transport}"
         end

data/lib/profiler/mcp/tools/get_profile_http.rb

@@ -85,8 +85,13 @@ module Profiler
               lines << "- **URL:** #{req['url']}"
               lines << "- **Status:** #{req['status'] == 0 ? 'connection error' : req['status']}"
               lines << "- **Duration:** #{req['duration'].round(2)} ms"
-              lines << "- **Request Size:** #{req['request_size']} bytes"
+              lines << "- **Request Size:** #{req['request_size'].nil? ? 'unknown' : "#{'at least ' if req['request_size_is_minimum']}#{req['request_size']} bytes"}"
               lines << "- **Response Size:** #{req['response_size']} bytes"
+              if req["request_body_not_captured"]
+                lines << "- _Request body not captured: a stream that cannot be rewound is sent unread._"
+              end
+              lines << "- _Request body truncated: only the first bytes were kept (max_captured_body_bytes)._" if req["request_body_truncated"]
+              lines << "- _Response body truncated: only the first bytes were kept (max_captured_body_bytes)._" if req["response_body_truncated"]
               lines << "- **Error:** #{req['error']}" if req["error"]
 
               if req["request_headers"] && !req["request_headers"].empty?

data/lib/profiler/mcp/tools/query_console_profiles.rb

@@ -40,7 +40,11 @@ module Profiler
           end
 
           if params["cursor"]
-            cutoff = Time.parse(params["cursor"]) rescue nil
+            cutoff = begin
+              Time.parse(params["cursor"])
+            rescue ArgumentError, TypeError
+              nil # a cursor that is not a time is ignored, as before
+            end
             consoles = consoles.select { |p| p.started_at < cutoff } if cutoff
           end
 

data/lib/profiler/mcp/tools/query_jobs.rb

@@ -31,7 +31,11 @@ module Profiler
           end
 
           if params["cursor"]
-            cutoff = Time.parse(params["cursor"]) rescue nil
+            cutoff = begin
+              Time.parse(params["cursor"])
+            rescue ArgumentError, TypeError
+              nil # a cursor that is not a time is ignored, as before
+            end
             jobs = jobs.select { |p| p.started_at < cutoff } if cutoff
           end
 

data/lib/profiler/mcp/tools/query_mailers.rb

@@ -49,7 +49,11 @@ module Profiler
             end
 
             if params["cursor"]
-              cutoff = Time.parse(params["cursor"]) rescue nil
+              cutoff = begin
+                Time.parse(params["cursor"])
+              rescue ArgumentError, TypeError
+                nil # a cursor that is not a time is ignored, as before
+              end
               if cutoff
                 emails = emails.select do |e|
                   started = e["profile_started_at"]

data/lib/profiler/mcp/tools/query_profiles.rb

@@ -23,7 +23,11 @@ module Profiler
           profiles = profiles.select { |p| p.profile_type == params["profile_type"] } if params["profile_type"]
 
           if params["cursor"]
-            cutoff = Time.parse(params["cursor"]) rescue nil
+            cutoff = begin
+              Time.parse(params["cursor"])
+            rescue ArgumentError, TypeError
+              nil # a cursor that is not a time is ignored, as before
+            end
             profiles = profiles.select { |p| p.started_at < cutoff } if cutoff
           end
 

data/lib/profiler/mcp/tools/query_test_profiles.rb

@@ -37,7 +37,11 @@ module Profiler
           end
 
           if params["cursor"]
-            cutoff = Time.parse(params["cursor"]) rescue nil
+            cutoff = begin
+              Time.parse(params["cursor"])
+            rescue ArgumentError, TypeError
+              nil # a cursor that is not a time is ignored, as before
+            end
             tests = tests.select { |p| p.started_at < cutoff } if cutoff
           end
 

data/lib/profiler/mcp/tools/run_tests.rb

@@ -117,7 +117,10 @@ module Profiler
           Profiler.storage.list(limit: 500, type: "test").select do |p|
             p.profile_type == "test" && p.started_at && p.started_at >= since
           end.map(&:token)
-        rescue
+        rescue Profiler::Storage::Unavailable::Error
+          raise # answered by the MCP server as an error
+        rescue StandardError => e
+          Profiler.log_error("MCP run_tests: could not list the profiles of the run", e)
           []
         end
 

data/lib/profiler/middleware/profiler_middleware.rb

@@ -42,7 +42,7 @@ module Profiler
             env["profiler.collectors"] = collectors
             subscribed = Collectors::Lifecycle.subscribe_all(collectors, "ProfilerMiddleware")
           rescue => e
-            warn "Profiler error: #{e.message}\n#{e.backtrace.join("\n")}"
+            Profiler.log_error("ProfilerMiddleware: could not start profiling the request", e, backtrace: true)
             subscribed = false
           end
 
@@ -104,10 +104,9 @@ module Profiler
         record_response(env, profile, request_body, status, headers, content, content.bytesize, true)
         collect_all(profile, collectors)
 
-        storage = Profiler.storage
-        storage.save(profile.token, profile)
-        # Not saved: no token to send, no toolbar to inject for it.
-        return [status, headers, body] if storage.is_a?(Profiler::Storage::Unavailable)
+        # A profile that was not saved (a store unavailable, a save that failed) gets no token and
+        # no toolbar: both would point to a profile that is not there.
+        return [status, headers, body] unless Profiler.save_profile(profile, from: "ProfilerMiddleware")
 
         set_header(headers, TOKEN_HEADER, profile.token)
 
@@ -122,7 +121,7 @@ module Profiler
         [status, headers, body]
       rescue => e
         # The application has run: its response goes out, profiled or not.
-        warn "Profiler error: #{e.message}\n#{e.backtrace.join("\n")}"
+        Profiler.log_error("ProfilerMiddleware: could not complete the profile", e, backtrace: true)
         [status, headers, body || []]
       end
 
@@ -140,7 +139,6 @@ module Profiler
         collect_all(profile, now)
         # Their tabs keep their place; what they hold is filled in when they are collected.
         kept.each { |collector| profile.add_collector_metadata(collector) }
-        set_header(headers, TOKEN_HEADER, profile.token)
 
         # A Rack 3 streaming body (call without each) writes to the socket itself: nothing to relay.
         unless body.respond_to?(:each)
@@ -148,13 +146,18 @@ module Profiler
             collector.collect if collector.respond_to?(:collect)
             profile.refresh_collector_metadata(collector)
           rescue => e
-            warn "Collector #{collector.class} failed: #{e.message}"
+            Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
           end
           record_response(env, profile, request_body, status, profiled_headers, "", nil, false)
-          Profiler.storage.save(profile.token, profile)
+          # Saved before the headers leave: a profile that is not there gets no token.
+          set_header(headers, TOKEN_HEADER, profile.token) if Profiler.save_profile(profile, from: "ProfilerMiddleware")
           return [[status, headers, body], nil]
         end
 
+        # Saved when the server closes the body, after the headers have left: the token is sent
+        # unless the store is already known to be unavailable, where it would be dropped.
+        set_header(headers, TOKEN_HEADER, profile.token) unless Profiler.storage.is_a?(Profiler::Storage::Unavailable)
+
         streamed = StreamedProfile.new(profile, kept) do |captured, size, complete, error|
           finish_streamed(env, streamed, collectors, request_body, allocations_before, status, profiled_headers,
                           captured, size, complete, error)
@@ -166,7 +169,7 @@ module Profiler
         StreamedProfile.register(streamed)
         [[status, headers, streamed.body], kept]
       rescue => e
-        warn "Profiler error: #{e.message}\n#{e.backtrace.join("\n")}"
+        Profiler.log_error("ProfilerMiddleware: could not profile a streamed response", e, backtrace: true)
         [[status, headers, body], nil]
       end
 
@@ -189,12 +192,12 @@ module Profiler
           collector.collect
           profile.refresh_collector_metadata(collector)
         rescue => e
-          warn "Collector #{collector.class} failed: #{e.message}"
+          Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
         end
 
-        Profiler.storage.save(profile.token, profile)
+        Profiler.save_profile(profile, from: "ProfilerMiddleware")
       rescue => e
-        warn "Profiler error while finishing a streamed response: #{e.message}"
+        Profiler.log_error("ProfilerMiddleware: could not finish the profile of a streamed response", e)
       end
 
       def collect_from_any_thread?(collector)
@@ -241,9 +244,9 @@ module Profiler
           resp_content_type: ""
         )
         collect_all(profile, collectors)
-        Profiler.storage.save(profile.token, profile)
+        Profiler.save_profile(profile, from: "ProfilerMiddleware")
       rescue => e
-        warn "Profiler error while recording a failed request: #{e.message}"
+        Profiler.log_error("ProfilerMiddleware: could not record a failed request", e)
       end
 
       def collect_all(profile, collectors)
@@ -252,7 +255,7 @@ module Profiler
             collector.collect if collector.respond_to?(:collect)
             profile.add_collector_metadata(collector)
           rescue => e
-            warn "Collector #{collector.class} failed: #{e.message}"
+            Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
           end
         end
       end
@@ -262,7 +265,7 @@ module Profiler
         kept&.each do |collector|
           collector.release_thread_slots if collector.respond_to?(:release_thread_slots)
         rescue => e
-          warn "Profiler: Collector #{collector.class} release failed: #{e.message}"
+          Profiler.log_error("ProfilerMiddleware: collector #{collector.class} release failed", e)
         end
         Profiler::CurrentContext.clear
       end
@@ -379,7 +382,7 @@ module Profiler
             begin
               close_body(body)
             rescue => e
-              warn "Profiler: closing a body that failed also failed: #{e.message}"
+              Profiler.log_error("ProfilerMiddleware: closing a body that failed also failed", e)
             end
             raise
           end
@@ -413,7 +416,7 @@ module Profiler
         content = Redaction.cut_bytes(content, limit) if limit
         { content: content, size: size, size_is_minimum: size_is_minimum || false }
       rescue => e
-        warn "Profiler: could not read the request body: #{e.message}"
+        Profiler.log_error("ProfilerMiddleware: could not read the request body", e)
         { content: "", size: nil }
       end
     end

data/lib/profiler/middleware/streamed_profile.rb

@@ -85,7 +85,7 @@ module Profiler
             collector.collect if collector.respond_to?(:collect)
             @profile.refresh_collector_metadata(collector)
           rescue => e
-            warn "Collector #{collector.class} failed: #{e.message}"
+            Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
           end
           Collectors::Lifecycle.release_all(@collectors)
         end

data/lib/profiler/middleware/toolbar_injector.rb

@@ -26,6 +26,17 @@ module Profiler
       TAG_REST = %r{(?:#{WS}++|/|#{ATTRIBUTE})*+>}
       # A whole start or end tag, read after its <: the slash and the name are captured.
       TAG = %r{(/)?([a-z][^\t\n\f\r\ />]*+)#{TAG_REST}}i
+      # Text and complete tags that cannot hold the page's end, skipped in one match: every tag
+      # but </body>, a raw-text element, <plaintext>, a comment, a declaration or a tag left
+      # open, which the scan below reads one by one. A tag here is read with TAG_REST, as there.
+      NAME_END = "(?=[\\t\\n\\f\\r\\ />])"
+      PLAIN_MARKUP = %r{
+        (?:
+          [^<]++
+          | <(?:/(?!body#{NAME_END})|(?!(?:#{(RAW_TEXT_ELEMENTS.keys + [PLAINTEXT]).join("|")})#{NAME_END}))
+            [a-z][^\t\n\f\r\ />]*+#{TAG_REST}
+        )*+
+      }xi
 
       def initialize(body, token, nonce = nil)
         @body = body
@@ -58,7 +69,10 @@ module Profiler
         scanner = StringScanner.new(bytes)
         position = nil
 
-        while scanner.skip_until(/</)
+        loop do
+          skip_plain_markup(scanner)
+          break unless scanner.skip_until(/</)
+
           start = scanner.pos - 1
 
           if scanner.skip(TAG)
@@ -97,6 +111,11 @@ module Profiler
         position
       end
 
+      # A page is mostly ordinary text and tags: one match instead of one scan step per tag.
+      def skip_plain_markup(scanner)
+        scanner.skip(PLAIN_MARKUP)
+      end
+
       # In a script, <!-- followed by <script enters a state where </script> does not close it.
       # Only the script itself is searched, so that a page of many scripts is read in linear
       # time.
@@ -124,7 +143,7 @@ module Profiler
           path = File.join(__dir__, "..", "..", "..", "app", "assets", "javascript", "profiler-ajax-interceptor.js")
           File.read(path)
         rescue => e
-          warn "Failed to load AJAX interceptor script: #{e.message}"
+          Profiler.log_error("ToolbarInjector: could not load the AJAX interceptor script", e)
           ""
         end
       end