rails-profiler 0.31.3 → 0.31.5

data/lib/profiler/collectors/log_collector.rb

@@ -8,6 +8,43 @@ module Profiler
     class LogCollector < BaseCollector
       SEVERITY_LABELS = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN].freeze
 
+      # The lines of one request, up to max_captured_log_bytes of messages: past it, a line is cut
+      # to what is left, and the next ones are only counted. A request, or a stream held open,
+      # that logs without end no longer grows its thread's buffer without bound.
+      class Buffer < Array
+        attr_reader :bytes, :dropped
+
+        def initialize(limit)
+          super()
+          @limit = limit
+          @bytes = 0
+          @dropped = 0
+          @truncated = false
+        end
+
+        def truncated?
+          @truncated
+        end
+
+        def record(entry)
+          message = entry[:message]
+          if @limit
+            room = @limit - @bytes
+            if room <= 0
+              @dropped += 1
+              @truncated = true
+              return
+            end
+            if message.bytesize > room
+              message = Redaction.cut_bytes(message, room).scrub("")
+              @truncated = true
+            end
+          end
+          @bytes += message.bytesize
+          self << entry.merge(message: message)
+        end
+      end
+
       # Records into the thread's buffer, which only exists while a LogCollector of this thread
       # is subscribed: lines logged by other threads, or after release, are not kept. A logger
       # bound to one collector's buffer records only while that buffer is the thread's current
@@ -21,17 +58,20 @@ module Profiler
         def add(severity, message = nil, progname = nil)
           logs = Thread.current[:profiler_logs]
           return true unless logs
+          # The profiler's own messages (Profiler.log) are not the application's.
+          return true if Thread.current[:profiler_logging]
           return true if @buffer && !logs.equal?(@buffer)
 
           msg = message || progname
           msg = yield if block_given? && msg.nil?
           return true if msg.nil?
 
-          logs << {
+          entry = {
             level: SEVERITY_LABELS[severity] || "UNKNOWN",
             message: msg.to_s.strip,
             timestamp: Time.now.iso8601(3)
           }
+          logs.respond_to?(:record) ? logs.record(entry) : logs << entry
           true
         end
 
@@ -78,7 +118,7 @@ module Profiler
       end
 
       def subscribe
-        @logs = claim_thread_slot(:profiler_logs, [])
+        @logs = claim_thread_slot(:profiler_logs, Buffer.new(Profiler.configuration.max_captured_log_bytes))
 
         if defined?(Rails) && Rails.logger
           if Rails.logger.respond_to?(:broadcast_to)
@@ -90,7 +130,7 @@ module Profiler
           end
         end
       rescue => e
-        warn "LogCollector#subscribe failed: #{e.message}"
+        Profiler.log_error("LogCollector: subscribe failed", e)
       end
 
       # Collect reads only what the collector gathered itself.
@@ -113,12 +153,21 @@ module Profiler
 
         errors   = logs.count { |l| %w[ERROR FATAL].include?(l[:level]) }
         warnings = logs.count { |l| l[:level] == "WARN" }
+        dropped = logs.respond_to?(:dropped) ? logs.dropped : 0
+        truncated = logs.respond_to?(:truncated?) && logs.truncated?
+        lines = logs.to_a
+        if dropped.positive?
+          lines += [{ level: "WARN", timestamp: Time.now.iso8601(3),
+                      message: "[Profiler] #{dropped} more log lines were not recorded (max_captured_log_bytes)" }]
+        end
 
         store_data({
-          count: logs.size,
+          count: logs.size + dropped,
           errors: errors,
           warnings: warnings,
-          logs: logs
+          logs: lines,
+          truncated: truncated,
+          dropped: dropped
         })
       end
 

data/lib/profiler/collectors/mailer_collector.rb

@@ -213,7 +213,8 @@ module Profiler
             serialize_assign(filtered)
           end
         end
-      rescue StandardError
+      rescue StandardError => e
+        Profiler.log_error_once(:mailer_assigns, "MailerCollector: could not read the mailer's assigns", e)
         {}
       end
 
@@ -232,7 +233,8 @@ module Profiler
           text = Profiler::Redaction.truncate(mail.body.decoded, MAX_BODY_SIZE, "")
         end
         [html.nil? || html.empty? ? nil : html, text.nil? || text.empty? ? nil : text]
-      rescue StandardError
+      rescue StandardError => e
+        Profiler.log_error_once(:mailer_body, "MailerCollector: could not read the mail's body", e)
         [nil, nil]
       end
 
@@ -250,7 +252,8 @@ module Profiler
         return nil unless mail.is_a?(String)
 
         Mail.new(mail)
-      rescue StandardError
+      rescue StandardError => e
+        Profiler.log_error_once(:mailer_parse, "MailerCollector: could not parse the mail", e)
         nil
       end
 
@@ -291,7 +294,8 @@ module Profiler
             "filename" => att.filename.to_s,
             "size" => att.body.decoded.bytesize
           }
-        rescue StandardError
+        rescue StandardError => e
+          Profiler.log_error_once(:mailer_attachment, "MailerCollector: could not read an attachment", e)
           { "filename" => att.filename.to_s, "size" => 0 }
         end
       end

data/lib/profiler/collectors/request_collector.rb

@@ -33,6 +33,7 @@ module Profiler
           allocated_objects: @profile.allocated_objects,
           memory: @profile.memory, # deprecated, see Profile#memory
           params: @profile.params,
+          params_truncated: @profile.params_truncated || false,
           headers: @profile.headers,
           response_headers: @profile.response_headers,
           request_body: @profile.request_body,
@@ -103,7 +104,11 @@ module Profiler
           route_params:      Profiler::Redaction.filter_hash(route_params),
           controller_action: controller_action
         }
-      rescue StandardError
+      rescue StandardError => e
+        # A path no route matches (a 404) has no route to show.
+        unless defined?(ActionController::RoutingError) && e.is_a?(ActionController::RoutingError)
+          Profiler.log_error_once(:request_route, "RequestCollector: could not read the matched route", e)
+        end
         {}
       end
 

data/lib/profiler/collectors/scoped_notifications.rb

@@ -219,7 +219,7 @@ module Profiler
               handler.call(name, started, finished, id, payload)
             rescue StandardError => e
               # Never into the application's query, nor at the expense of the other collectors.
-              warn "Profiler: a collector failed on #{event}: #{e.class}: #{e.message}"
+              Profiler.log_error("collector failed on #{event}", e)
             end
           end
         end

data/lib/profiler/configuration.rb

@@ -29,13 +29,19 @@ module Profiler
 
     # Options whose default depends on the Rails environment: the railtie sets them only when
     # the application has not assigned them itself (see #default).
-    RAILS_DEFAULTED = %i[enabled storage track_tests].freeze
+    RAILS_DEFAULTED = %i[enabled storage track_tests max_profiles].freeze
+
+    BACKEND_LOCK = Mutex.new
+
+    # The hosts earlier versions always left out of the outbound HTTP tab. Add them back with
+    # config.http_skip_hosts += Profiler::Configuration::LOCAL_HTTP_HOSTS.
+    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,
                   :track_memory, :allocated_objects_warning_threshold,
                   :mcp_enabled, :mcp_transport, :mcp_port,
-                  :authorization_mode, :max_profiles, :extension_cors_enabled,
+                  :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,
@@ -44,14 +50,14 @@ module Profiler
                   :apply_env_overrides_when_disabled, :restrict_storage_permissions,
                   :test_runner_allow_undiscovered_files,
                   :track_mailers, :capture_mail_body, :sanitize_mailer_recipients, :mailer_skip_actions,
-                  :compress_bodies, :compress_body_threshold, :max_captured_body_bytes,
+                  :compress_bodies, :compress_body_threshold, :max_captured_body_bytes, :max_captured_log_bytes,
                   :redact_sensitive_data, :filter_parameters, :env_allowlist,
                   :name, :master_url, :self_url,
                   :cluster_heartbeat_interval, :cluster_offline_threshold,
                   :cluster_master, :cluster_secret, :cluster_require_secret,
-                  :cluster_allow_insecure_http
+                  :cluster_allow_insecure_http, :logger
 
-    attr_reader :authorize_block, :enabled, :track_tests
+    attr_reader :authorize_block, :enabled, :track_tests, :max_profiles
 
     def initialize
       @assigned = []
@@ -87,6 +93,8 @@ module Profiler
       @ajax_skip_paths = [/^\/_profiler/]
       @track_http = true
       @slow_http_threshold = 500 # milliseconds
+      # Every host whose outbound calls are left out (Strings and Regexps matched against the host).
+      # The profiler's own calls (cluster, slave proxy) are never recorded, whatever this says.
       @http_skip_hosts = []
       @http_backtrace_depth = 40
       @track_jobs = true
@@ -105,6 +113,8 @@ module Profiler
       # The request and response bodies kept in a profile stop at this many bytes; the
       # application still reads and sends all of them. nil keeps whole bodies.
       @max_captured_body_bytes = 256 * 1024
+      # What a profile keeps of the lines its request logs, in bytes. nil keeps every line.
+      @max_captured_log_bytes = 1024 * 1024
       @redact_sensitive_data = true
       @filter_parameters = DEFAULT_FILTER_PARAMETERS.dup
       @env_allowlist = DEFAULT_ENV_ALLOWLIST.dup
@@ -123,6 +133,9 @@ module Profiler
       @cluster_require_secret = true
       @cluster_allowed_slave_urls = []
       @cluster_allow_insecure_http = false
+      # Where the profiler's own errors go (Profiler.log): Rails.logger when nil, or $stderr when
+      # there is none.
+      @logger = nil
     end
 
     # Always a Pathname, whether set from a String or left to its default.
@@ -144,8 +157,8 @@ module Profiler
     end
 
     def memory_warning_threshold=(bytes)
-      warn "[Profiler] memory_warning_threshold is deprecated, set allocated_objects_warning_threshold " \
-           "(a number of objects) instead"
+      Profiler.log_warn("memory_warning_threshold is deprecated, set allocated_objects_warning_threshold " \
+                        "(a number of objects) instead")
       @allocated_objects_warning_threshold = bytes && bytes / AllocationCounter::LEGACY_BYTES_PER_OBJECT
     end
 
@@ -181,6 +194,13 @@ module Profiler
       @track_tests = value
     end
 
+    # How many profiles a store keeps, the oldest evicted first; nil for no cap on the count (the
+    # memory store still keeps 100). The railtie leaves it nil in the test environment.
+    def max_profiles=(value)
+      @assigned |= [:max_profiles]
+      @max_profiles = value
+    end
+
     # Sets one of RAILS_DEFAULTED to value unless the application assigned it, in
     # config/application.rb for instance, which runs before the railtie's initializers.
     def default(option, value)
@@ -246,8 +266,10 @@ module Profiler
       @storage_backend = nil
     end
 
+    # Under a lock of its own, for a caller that asks the configuration directly; Profiler.storage
+    # takes it inside its own, always in that order.
     def storage_backend
-      @storage_backend ||= build_storage_backend
+      @storage_backend || BACKEND_LOCK.synchronize { @storage_backend ||= build_storage_backend }
     end
 
     private

data/lib/profiler/console_profiler.rb

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

data/lib/profiler/engine.rb

@@ -9,8 +9,9 @@ module Profiler
     config.profiler = ActiveSupport::OrderedOptions.new
 
     initializer "profiler.helpers" do
+      # The hook runs for ActionController::API as well, which has no view helpers.
       ActiveSupport.on_load(:action_controller) do
-        helper Profiler::Engine.helpers
+        helper Profiler::Engine.helpers if respond_to?(:helper)
       end
     end
   end

data/lib/profiler/env_override_store.rb

@@ -108,10 +108,10 @@ module Profiler
 
       @boot_warning_logged = true
       noun, verb = count == 1 ? %w[override was] : %w[overrides were]
-      logger&.warn("[Profiler] #{count} persisted environment #{noun} in #{override_file_path} " \
-                   "#{verb} not applied: #{BLOCKED_REASONS.fetch(reason)}.")
+      Profiler.log_warn("#{count} persisted environment #{noun} in #{override_file_path} " \
+                        "#{verb} not applied: #{BLOCKED_REASONS.fetch(reason)}.", logger: logger)
     rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to check overrides at boot: #{e.message}"
+      Profiler.log_error("EnvOverrideStore: failed to check overrides at boot", e)
     end
 
     # Set by the test runner in the environment of the test process, to which it already gave
@@ -158,7 +158,7 @@ module Profiler
         end
       end
     rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to apply overrides: #{e.message}"
+      Profiler.log_error("EnvOverrideStore: failed to apply overrides", e)
     end
 
     # Returns active overrides (excludes RESTORE entries, already being reverted)

data/lib/profiler/explain_runner.rb

@@ -61,7 +61,11 @@ module Profiler
       result = if format == "json"
         # PostgreSQL / MySQL return JSON in rows[0]["QUERY PLAN"] or rows[0]["EXPLAIN"]
         raw = rows.first&.values&.first.to_s
-        JSON.parse(raw) rescue raw
+        begin
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          raw
+        end
       else
         rows.map { |r| r.values.join("\t") }.join("\n")
       end

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/resources/failing_tests.rb

@@ -5,7 +5,7 @@ module Profiler
     module Resources
       class FailingTests
         def self.call
-          profiles = Profiler.storage.list(limit: 500)
+          profiles = Profiler.storage.list(limit: 500, type: "test")
           failing = profiles.select do |p|
             next false unless p.profile_type == "test"
             test_data = p.collector_data("test") || {}

data/lib/profiler/mcp/resources/recent_console.rb

@@ -5,8 +5,8 @@ module Profiler
     module Resources
       class RecentConsole
         def self.call
-          profiles = Profiler.storage.list(limit: 200)
-          consoles = profiles.select { |p| p.profile_type == "console" }.first(50)
+          profiles = Profiler.storage.list(limit: 50, type: "console")
+          consoles = profiles.select { |p| p.profile_type == "console" }
 
           data = consoles.map do |profile|
             console_data = profile.collector_data("console") || {}

data/lib/profiler/mcp/resources/recent_jobs.rb

@@ -5,8 +5,8 @@ module Profiler
     module Resources
       class RecentJobs
         def self.call
-          profiles = Profiler.storage.list(limit: 200)
-          jobs = profiles.select { |p| p.profile_type == "job" }.first(50)
+          profiles = Profiler.storage.list(limit: 50, type: "job")
+          jobs = profiles.select { |p| p.profile_type == "job" }
 
           data = jobs.map do |profile|
             job_data = profile.collector_data("job") || {}