rails-profiler 0.31.3 → 0.31.5

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

@@ -5,7 +5,7 @@ module Profiler
     module Resources
       class SlowTests
         def self.call
-          profiles = Profiler.storage.list(limit: 500)
+          profiles = Profiler.storage.list(limit: 500, type: "test")
           tests = profiles.select { |p| p.profile_type == "test" }
                           .sort_by { |p| -p.duration }
                           .first(10)

data/lib/profiler/mcp/server.rb

@@ -35,8 +35,12 @@ module Profiler
           handler = @resource_handlers[uri]
           next [{ uri: uri, mimeType: "application/json", text: "Resource not found: #{uri}" }] unless handler
 
-          result = handler.call
-          [{ uri: result[:uri], mimeType: result[:mimeType], text: result[:text] }]
+          begin
+            result = handler.call
+            [{ uri: result[:uri], mimeType: result[:mimeType], text: result[:text] }]
+          rescue Profiler::Storage::Unavailable::Error => e
+            [{ uri: uri, mimeType: "text/plain", text: e.message }]
+          end
         end
       end
 
@@ -53,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
@@ -393,6 +397,8 @@ module Profiler
         ::MCP::Tool.define(name: name, description: description, input_schema: input_schema) do |server_context: nil, **args|
           result = handler.call(args.transform_keys(&:to_s))
           result.is_a?(::MCP::Tool::Response) ? result : ::MCP::Tool::Response.new(result)
+        rescue Profiler::Storage::Unavailable::Error => e
+          ::MCP::Tool::Response.new([{ type: "text", text: e.message }], error: true)
         end
       end
 

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

@@ -22,6 +22,8 @@ module Profiler
             return [{ type: "text", text: "Profile not found: #{token}" }]
           end
 
+          # The sub-requests are saved after the page: computed from its children, as the page does.
+          Profiler::AjaxData.attach(profile, storage.find_by_parent(profile.token))
           ajax_data = profile.collector_data("ajax")
           unless ajax_data && ajax_data["total_requests"].to_i > 0
             return [{ type: "text", text: "No AJAX requests found in this profile" }]

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/get_test_profile_detail.rb

@@ -14,7 +14,7 @@ module Profiler
 
           storage = MCP::SlaveSupport.resolve_storage(params)
           profile = if token == "latest"
-            profiles = storage.list(limit: 200)
+            profiles = storage.list(limit: 1, type: "test")
             profiles.find { |p| p.profile_type == "test" }
           else
             storage.load(token)

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

@@ -12,7 +12,7 @@ module Profiler
           limit = params["limit"]&.to_i || 20
           fetch_size = [limit * 5, 500].min
           storage = MCP::SlaveSupport.resolve_storage(params)
-          profiles = storage.list(limit: fetch_size)
+          profiles = storage.list(limit: fetch_size, type: "console")
 
           consoles = profiles.select { |p| p.profile_type == "console" }
 
@@ -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

@@ -12,7 +12,7 @@ module Profiler
           limit = params["limit"]&.to_i || 20
           fetch_size = [limit * 5, 500].min
           storage = MCP::SlaveSupport.resolve_storage(params)
-          profiles = storage.list(limit: fetch_size)
+          profiles = storage.list(limit: fetch_size, type: "job")
 
           jobs = profiles.select { |p| p.profile_type == "job" }
 
@@ -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

@@ -12,7 +12,7 @@ module Profiler
           storage = MCP::SlaveSupport.resolve_storage(params)
           limit = params["limit"]&.to_i || 20
           fetch_size = [limit * 5, 500].min
-          profiles = storage.list(limit: fetch_size)
+          profiles = storage.list(limit: fetch_size, type: params["profile_type"])
 
           profiles = profiles.select { |p| p.path&.include?(params["path"]) } if params["path"]
           profiles = profiles.select { |p| p.method == params["method"]&.upcase } if params["method"]
@@ -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

@@ -12,7 +12,7 @@ module Profiler
           limit = params["limit"]&.to_i || 20
           fetch_size = [limit * 5, 500].min
           storage = MCP::SlaveSupport.resolve_storage(params)
-          profiles = storage.list(limit: fetch_size)
+          profiles = storage.list(limit: fetch_size, type: "test")
 
           tests = profiles.select { |p| p.profile_type == "test" }
 
@@ -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

@@ -114,10 +114,13 @@ module Profiler
         end
 
         def self.collect_run_profiles(since)
-          Profiler.storage.list(limit: 500).select do |p|
+          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,7 +104,9 @@ module Profiler
         record_response(env, profile, request_body, status, headers, content, content.bytesize, true)
         collect_all(profile, collectors)
 
-        Profiler.storage.save(profile.token, profile)
+        # 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)
 
@@ -119,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
 
@@ -137,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)
@@ -145,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)
@@ -163,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
 
@@ -186,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)
@@ -238,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)
@@ -249,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
@@ -259,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
@@ -376,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
@@ -410,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

data/lib/profiler/models/profile.rb

@@ -19,7 +19,7 @@ module Profiler
                     :response_body, :response_body_encoding,
                     :request_body_size, :request_body_truncated, :request_body_size_is_minimum,
                     :response_body_size, :response_body_truncated, :response_body_size_is_minimum,
-                    :collectors_released_after_seconds,
+                    :collectors_released_after_seconds, :params_truncated,
                     :gem_version
 
       def initialize(request = nil)
@@ -34,7 +34,8 @@ module Profiler
         if request
           @path = request.path
           @method = request.request_method
-          @params = sanitize_params(request.params)
+          @params, @params_truncated = cap_params(sanitize_params(request.params),
+                                                  Profiler.configuration.max_captured_body_bytes)
           @headers = extract_headers(request.env)
         end
       end
@@ -133,6 +134,7 @@ module Profiler
           started_at: @started_at&.iso8601,
           finished_at: @finished_at&.iso8601,
           params: @params,
+          params_truncated: @params_truncated,
           headers: @headers,
           response_headers: @response_headers,
           request_body: req_body,
@@ -178,6 +180,7 @@ module Profiler
         profile.started_at = data[:started_at] ? Time.parse(data[:started_at]) : nil
         profile.finished_at = data[:finished_at] ? Time.parse(data[:finished_at]) : nil
         profile.params = data[:params]
+        profile.params_truncated = data[:params_truncated]
         profile.headers = data[:headers]
         profile.response_headers = data[:response_headers]
         profile.request_body = data[:request_body]
@@ -266,6 +269,61 @@ module Profiler
 
       LEGACY_FILTERED_PARAMS = %w[password password_confirmation token secret].freeze
 
+      # The key added to params cut at max_captured_body_bytes, so that the cut shows wherever
+      # the params are read.
+      PARAMS_TRUNCATED_KEY = "[profiler]"
+
+      # A copy of +params+ whose JSON stays within about +limit+ bytes: long strings are cut, and
+      # the entries past the limit left out. The application's own params are never touched.
+      # Returns the params and whether they were cut.
+      def cap_params(params, limit)
+        return [params, false] if limit.nil? || !params.is_a?(Hash)
+
+        budget = [limit]
+        cut = [false]
+        capped = cap_value(params, budget, cut)
+        return [capped, false] unless cut[0]
+
+        capped[PARAMS_TRUNCATED_KEY] = "params truncated at #{limit} bytes (max_captured_body_bytes)"
+        [capped, true]
+      end
+
+      def cap_value(value, budget, cut)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, item), out|
+            cost = key.to_s.bytesize + 4
+            if cost >= budget[0]
+              cut[0] = true
+              break out
+            end
+            budget[0] -= cost
+            out[key] = cap_value(item, budget, cut)
+          end
+        when Array
+          value.each_with_object([]) do |item, out|
+            if budget[0] <= 1
+              cut[0] = true
+              break out
+            end
+            budget[0] -= 1
+            out << cap_value(item, budget, cut)
+          end
+        when String
+          cost = value.bytesize + 2
+          if cost > budget[0]
+            cut[0] = true
+            value = Redaction.cut_bytes(value, [budget[0] - 2, 0].max).scrub("")
+            cost = value.bytesize + 2
+          end
+          budget[0] -= cost
+          value
+        else
+          budget[0] -= value.to_s.bytesize
+          value
+        end
+      end
+
       def sanitize_params(params)
         return {} unless params
 

data/lib/profiler/process_snapshot.rb

@@ -36,7 +36,11 @@ module Profiler
         candidates.find { |route| route[:verb].split("|").include?(verb) } ||
           candidates.find { |route| route[:verb] == "ANY" } ||
           candidates.first
-      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(:snapshot_route, "could not find the route of a profile", e)
+        end
         nil
       end
 
@@ -61,7 +65,7 @@ module Profiler
         end
         profile
       rescue StandardError => e
-        warn "Profiler: could not add the routes and ENV to profile #{profile.token}: #{e.message}"
+        Profiler.log_error("could not add the routes and ENV to profile #{profile.token}", e)
         profile
       end
 
@@ -84,7 +88,8 @@ module Profiler
           @routes = build_snapshot(fingerprint, list) unless @routes && @routes[0] == fingerprint
           @routes
         end
-      rescue StandardError
+      rescue StandardError => e
+        Profiler.log_error_once(:snapshot_routes, "could not read the application's routes", e)
         [nil, [].freeze, {}.freeze]
       end
 

data/lib/profiler/railtie.rb

@@ -15,12 +15,15 @@ module Profiler
         config.default(:enabled, development_or_test)
         config.default(:storage, development_or_test ? :file : :memory)
         config.default(:track_tests, Rails.env.test?)
+        # One test profile per example: no cap on the count in the test environment, so that the
+        # report at the end of a suite sees all of them.
+        config.default(:max_profiles, Rails.env.test? ? nil : 100)
 
         app.config.profiler.each do |key, value|
           if config.respond_to?("#{key}=")
             config.public_send("#{key}=", value)
           else
-            Rails.logger&.warn("[Profiler] config.profiler.#{key} is not a profiler option, ignored")
+            Profiler.log_warn("config.profiler.#{key} is not a profiler option, ignored")
           end
         end
       end

data/lib/profiler/redaction.rb

@@ -518,9 +518,7 @@ module Profiler
         return if reported.include?(error.class)
 
         reported << error.class
-        message = "[Profiler] Redaction: #{error.class} while #{during}; the value was masked instead."
-        logger = ::Rails.logger if defined?(::Rails) && ::Rails.respond_to?(:logger)
-        logger ? logger.warn(message) : Kernel.warn(message)
+        Profiler.log_warn("Redaction: #{error.class} while #{during}; the value was masked instead.")
       rescue StandardError
         nil
       end

data/lib/profiler/sse/redis_event_bus.rb

@@ -29,7 +29,8 @@ module Profiler
       # The version of the last save of +token+, 0 when none is known or Redis cannot be read.
       def version(token)
         redis.get(key(token)).to_i
-      rescue StandardError
+      rescue StandardError => e
+        Profiler.log_error_once(:redis_event_bus_version, "RedisEventBus: could not read the version of a profile", e)
         0
       end
 

data/lib/profiler/storage/base_store.rb

@@ -34,7 +34,8 @@ module Profiler
 
       def exists?(token)
         !load(token).nil?
-      rescue
+      rescue StandardError => e
+        Profiler.log_error_once(:store_exists, "#{self.class.name.split("::").last}: could not look up a profile", e)
         false
       end
 
@@ -54,8 +55,9 @@ module Profiler
 
       def broadcast_event(token)
         Profiler::SSE.current.broadcast(token)
-      rescue StandardError
+      rescue StandardError => e
         # Never let a broadcast failure prevent profile persistence
+        Profiler.log_error_once(:store_broadcast, "#{self.class.name.split("::").last}: could not announce a saved profile", e)
       end
     end
   end

data/lib/profiler/storage/blob_store.rb

@@ -35,7 +35,7 @@ module Profiler
 
         JSON.parse(File.read(file))
       rescue => e
-        warn "BlobStore: failed to read #{token}/#{collector_name}: #{e.message}"
+        Profiler.log_error("BlobStore: could not read #{token}/#{collector_name}", e)
         nil
       end