rails-profiler 0.31.2 → 0.31.4

data/lib/profiler/collectors/scoped_notifications.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require_relative "../current_context"
+
+module Profiler
+  module Collectors
+    # ActiveSupport::Notifications subscriptions scoped to the request that made them.
+    #
+    # The notifications bus is process-wide: a collector subscribed on it directly receives the
+    # events of every thread, another request's SQL included. Here the process holds one
+    # subscriber per event name, whatever the number of requests being profiled, and hands each
+    # event to the handlers of the execution context that emitted it only.
+    #
+    # The context is ActiveSupport::IsolatedExecutionState, which Rails itself scopes its
+    # connections and instrumenters to: a thread, or a fiber with
+    # config.active_support.isolation_level = :fiber. ActionController::Live shares it with the
+    # thread it runs the action in, and ThreadContextPropagation hands it to the threads a request
+    # starts. A thread with no scope of its own that carries a profile's token
+    # (Profiler::CurrentContext), as a server thread iterating a streamed body does, gets the scope
+    # opened under that token. A scope lasts until its last handler is released, after the
+    # response body is closed for a streamed response, wherever that release runs; the next
+    # request of the thread then opens a new one, so a thread still holding the old scope, or the
+    # old token, receives nothing more.
+    module ScopedNotifications
+      STATE_KEY = :profiler_notification_scope
+      # Fiber storage, inherited by the fibers and threads a fiber creates: Ruby 3.2+.
+      FIBER_STORAGE = Fiber.respond_to?(:[])
+
+      # The handlers of one request, by event name.
+      class Scope
+        attr_reader :token, :owner
+
+        def initialize(token = nil)
+          @token = token
+          @owner = Thread.current
+          @mutex = Mutex.new
+          @handlers = {}
+          @size = 0
+          @closed = false
+        end
+
+        def closed?
+          @closed
+        end
+
+        def handlers_for(event)
+          @handlers[event]
+        end
+
+        # False when the scope was closed meanwhile: the caller opens a new one.
+        def add(event, handler)
+          @mutex.synchronize do
+            return false if @closed
+
+            @handlers[event] = [*@handlers[event], handler].freeze
+            @size += 1
+            true
+          end
+        end
+
+        # nil when the handler was not there (released already), :last when it was the scope's
+        # last one, :removed otherwise.
+        def remove(event, handler)
+          @mutex.synchronize do
+            list = @handlers[event]
+            return nil unless list&.any? { |h| h.equal?(handler) }
+
+            rest = list.reject { |h| h.equal?(handler) }
+            rest.empty? ? @handlers.delete(event) : @handlers[event] = rest.freeze
+            @size -= 1
+            @closed = @size.zero?
+            @closed ? :last : :removed
+          end
+        end
+      end
+
+      Handle = Struct.new(:scope, :event, :handler)
+
+      @mutex = Mutex.new
+      @subscribers = {} # event name => [subscriber, handler count]
+      @by_token = {}.freeze # profile token => the scope opened under it, replaced on write
+
+      class << self
+        # Calls +handler+ with (name, started, finished, id, payload), monotonic times, for each
+        # +event+ the current execution context emits until the handle is unsubscribed.
+        def subscribe(event, &handler)
+          # The process subscriber first: when the notifier fails, nothing was added to the scope.
+          retain(event)
+          scope = current_scope
+          scope = open_scope until scope.add(event, handler)
+          Handle.new(scope, event, handler)
+        end
+
+        # Safe from any thread, and more than once.
+        def unsubscribe(handle)
+          return unless handle
+
+          removed = handle.scope.remove(handle.event, handle.handler)
+          return unless removed
+
+          release(handle.event)
+          close_scope(handle.scope) if removed == :last
+        end
+
+        # The current context's scope, for ThreadContextPropagation to hand to a new thread: the
+        # one of its execution state, or else the one a fiber inherited from the fiber that created
+        # it (Fiber storage, Ruby 3.2+). With isolation_level = :fiber, a fiber the request creates
+        # (render stream: true renders the layout in one) has no execution state of its own.
+        def current
+          scope = state[STATE_KEY]
+          scope = fiber_scope if scope.nil? || scope.closed?
+          scope unless scope.nil? || scope.closed?
+        end
+
+        # The scope the current context's events go to.
+        def routed_scope
+          scope = current
+          return scope if scope
+
+          token = CurrentContext.token
+          @by_token[token] if token
+        end
+
+        def adopt(scope)
+          state[STATE_KEY] = scope
+          Fiber[STATE_KEY] = scope if FIBER_STORAGE
+        end
+
+        # A thread a pool creates inherits the Fiber storage of the code that created it, which
+        # may be a request's: it must not keep that request's scope.
+        def forget_inherited_scope
+          Fiber[STATE_KEY] = nil if FIBER_STORAGE && !Fiber[STATE_KEY].nil?
+        end
+
+        # Runs the block with a scope of its own when the current one was opened by another thread:
+        # a job a pool performs for the request that enqueued it (ActiveJob's :async adapter) is
+        # profiled apart from that request, which may still be running. A job performed inline,
+        # on the request's own thread, keeps sharing its scope, as it always did.
+        def apart_from_other_threads
+          scope = current
+          return yield if scope.nil? || scope.owner.equal?(Thread.current)
+
+          previous = adopted
+          adopt(nil)
+          begin
+            yield
+          ensure
+            restore(previous)
+          end
+        end
+
+        # What the current context holds, closed or not, for RequestContext to put back.
+        def adopted
+          [state[STATE_KEY], fiber_scope]
+        end
+
+        def restore(adopted)
+          state[STATE_KEY], inherited = adopted
+          Fiber[STATE_KEY] = inherited if FIBER_STORAGE
+        end
+
+        private
+
+        def state
+          defined?(ActiveSupport::IsolatedExecutionState) ? ActiveSupport::IsolatedExecutionState : Thread.current
+        end
+
+        def current_scope
+          current || open_scope
+        end
+
+        def fiber_scope
+          Fiber[STATE_KEY] if FIBER_STORAGE
+        end
+
+        def open_scope
+          token = CurrentContext.token
+          scope = Scope.new(token)
+          if token
+            @mutex.synchronize { @by_token = @by_token.merge(token => scope).freeze }
+          end
+          adopt(scope)
+          scope
+        end
+
+        def close_scope(scope)
+          state[STATE_KEY] = nil if state[STATE_KEY].equal?(scope)
+          Fiber[STATE_KEY] = nil if FIBER_STORAGE && fiber_scope.equal?(scope)
+          return unless scope.token
+
+          @mutex.synchronize do
+            @by_token = @by_token.reject { |_, s| s.equal?(scope) }.freeze if @by_token[scope.token].equal?(scope)
+          end
+        end
+
+        def retain(event)
+          @mutex.synchronize do
+            entry = (@subscribers[event] ||= [subscribe_process(event), 0])
+            entry[1] += 1
+          end
+        end
+
+        def release(event)
+          @mutex.synchronize do
+            entry = @subscribers[event]
+            return unless entry
+
+            entry[1] -= 1
+            return unless entry[1] <= 0
+
+            ActiveSupport::Notifications.unsubscribe(entry[0])
+            @subscribers.delete(event)
+          end
+        end
+
+        def subscribe_process(event)
+          ActiveSupport::Notifications.monotonic_subscribe(event) do |name, started, finished, id, payload|
+            routed_scope&.handlers_for(event)&.each do |handler|
+              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}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/profiler/collectors/view_collector.rb

@@ -34,7 +34,7 @@ module Profiler
       def subscribe
         return unless defined?(ActiveSupport::Notifications)
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_template.action_view") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("render_template.action_view") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @views << {
             identifier: payload[:identifier],
@@ -43,7 +43,7 @@ module Profiler
           }
         end
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_partial.action_view") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("render_partial.action_view") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @partials << {
             identifier: payload[:identifier],

data/lib/profiler/configuration.rb

@@ -29,13 +29,15 @@ 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
 
     attr_accessor :storage_options, :collectors,
-                  :skip_paths, :slow_query_threshold, :max_queries_warning,
+                  :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,
@@ -51,7 +53,7 @@ module Profiler
                   :cluster_master, :cluster_secret, :cluster_require_secret,
                   :cluster_allow_insecure_http
 
-    attr_reader :authorize_block, :enabled, :track_tests
+    attr_reader :authorize_block, :enabled, :track_tests, :max_profiles
 
     def initialize
       @assigned = []
@@ -62,6 +64,10 @@ module Profiler
       @skip_paths = [%r{^/_profiler}, /\.well-known/, /favicon\.ico/, /manifest\.json/]
       @slow_query_threshold = 100 # milliseconds
       @max_queries_warning = 50
+      # Where each query comes from: :first_and_slow captures the caller the first time a
+      # statement runs in the request and for every slow query, :all for every query (as earlier
+      # versions did, about 0.1 ms each), :none never.
+      @sql_backtrace = :first_and_slow
       @track_memory = true
       # Not compared with anything yet. The default is the former 100 MB memory threshold read
       # as the objects it stood for.
@@ -177,6 +183,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)
@@ -242,8 +255,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/instrumentation/executor_context_propagation.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require_relative "request_context"
+
+module Profiler
+  module Instrumentation
+    # A task posted to a concurrent-ruby executor while a request is profiled runs in that
+    # request's context, whichever pool thread runs it and whenever: Concurrent::Promises,
+    # Concurrent::Future, ActiveJob's :async adapter and ActionController::Live all post their
+    # work this way. The pool thread has its own context back once the task returns.
+    module ExecutorContextPropagation
+      def post(*args, &task)
+        return super if task.nil?
+
+        context = RequestContext.capture
+        return super if context.nil?
+
+        wrapper = proc do |*task_args|
+          RequestContext.with(context) { task.call(*task_args) }
+        end
+        wrapper.ruby2_keywords
+        super(*args, &wrapper)
+      end
+      ruby2_keywords :post
+
+      # The executors that define post themselves; the others inherit it from one of them.
+      EXECUTORS = %w[
+        Concurrent::RubyExecutorService
+        Concurrent::SimpleExecutorService
+        Concurrent::TimerSet
+        Concurrent::SerializedExecutionDelegator
+      ].freeze
+
+      def self.install!
+        EXECUTORS.each do |name|
+          executor = Object.const_get(name)
+          executor.prepend(self) unless executor.ancestors.include?(self)
+        rescue NameError
+          next # not in this version of concurrent-ruby
+        end
+      end
+    end
+  end
+end
+
+Profiler::Instrumentation::ExecutorContextPropagation.install!

data/lib/profiler/instrumentation/request_context.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../collectors/scoped_notifications"
+
+module Profiler
+  module Instrumentation
+    # What a request being profiled hands to the work it starts on other threads: its
+    # notification scope and the collectors that record through thread-local slots.
+    #
+    # It travels with the work, not with a thread: a thread the application starts with
+    # Thread.new gets it for the life of its block (ThreadContextPropagation), a task posted to a
+    # concurrent-ruby executor for the time the task runs (ExecutorContextPropagation). A thread
+    # an executor creates to run tasks, a pool worker or a Puma thread, gets nothing: it outlives
+    # the request and serves others.
+    module RequestContext
+      KEYS = %i[
+        profiler_http_collector
+        profiler_flamegraph_collector
+      ].freeze
+
+      # The files whose code calls Thread.new to create the threads of a pool: concurrent-ruby's
+      # executors (a worker of RubyThreadPoolExecutor, the thread of SimpleExecutorService) and
+      # Puma's thread pool.
+      POOL_FILES = %r{/concurrent/executor/[a-z_]+\.rb\z|/puma/thread_pool\.rb\z}
+
+      module_function
+
+      # The current request's context, or nil outside of one.
+      def capture
+        slots = KEYS.filter_map do |key|
+          value = Thread.current[key]
+          [key, value] unless value.nil?
+        end.to_h
+        scope = Collectors::ScopedNotifications.current
+        return nil if slots.empty? && scope.nil?
+
+        { slots: slots, scope: scope }.freeze
+      end
+
+      # Runs the block in +context+, and gives the thread back what it had before.
+      def with(context)
+        return yield if context.nil?
+
+        previous_slots = KEYS.to_h { |key| [key, Thread.current[key]] }
+        previous_scope = Collectors::ScopedNotifications.adopted
+        KEYS.each { |key| Thread.current[key] = context[:slots][key] }
+        Collectors::ScopedNotifications.adopt(context[:scope])
+        begin
+          yield
+        ensure
+          previous_slots.each { |key, value| Thread.current[key] = value }
+          Collectors::ScopedNotifications.restore(previous_scope)
+        end
+      end
+
+      # The block of a pool's thread, rid of the request's scope its Fiber storage inherits.
+      def without_inherited(block)
+        wrapper = proc do |*args|
+          Collectors::ScopedNotifications.forget_inherited_scope
+          block.call(*args)
+        end
+        wrapper.ruby2_keywords
+        wrapper
+      end
+
+      # Whether the thread being created is one of a pool's: then it must not inherit. Only the
+      # code that calls Thread.new counts; a thread the application starts from a task, or from a
+      # request a pool thread serves, is the request's.
+      def creating_pool_thread?
+        # 0 is this method, 1 the Thread#initialize patch, 2 Thread.new, which reports the file
+        # of the code that called it.
+        location = caller_locations(2, 1)&.first
+        location ? POOL_FILES.match?(location.path.to_s) : false
+      end
+    end
+  end
+end

data/lib/profiler/instrumentation/thread_context_propagation.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
+require_relative "request_context"
+
 module Profiler
   module Instrumentation
+    # A thread the application starts while a request is profiled works for that request: it gets
+    # the request's context (RequestContext) for the life of its block. A thread a pool creates
+    # (concurrent-ruby, Puma) does not: it outlives the request, and the tasks it runs bring
+    # their own context (ExecutorContextPropagation).
     module ThreadContextPropagation
-      PROPAGATED_KEYS = %i[
-        profiler_http_collector
-        profiler_flamegraph_collector
-      ].freeze
+      PROPAGATED_KEYS = RequestContext::KEYS
 
       def initialize(*args, &block)
         # Ruby refuses a Thread with no block, and the wrapper below is a block, so
         # without this the error would never come while a profile is being collected.
         return super if block.nil?
 
-        parent_context = PROPAGATED_KEYS.filter_map do |key|
-          val = Thread.current[key]
-          [key, val] unless val.nil?
-        end.to_h
-
-        return super if parent_context.empty?
+        context = RequestContext.capture
+        return super if context.nil?
+        return super(*args, &RequestContext.without_inherited(block)) if RequestContext.creating_pool_thread?
 
         # Thread.new hands its arguments to the block, so the wrapper has to take
         # them and pass them on. Ruby 3.4 depends on it in the stdlib: the Happy
@@ -30,12 +30,7 @@ module Profiler
         # on this method, keeps a trailing keyword hash a keyword hash rather than
         # flattening it into a positional argument.
         wrapper = proc do |*block_args|
-          parent_context.each { |k, v| Thread.current[k] = v }
-          begin
-            block&.call(*block_args)
-          ensure
-            PROPAGATED_KEYS.each { |k| Thread.current[k] = nil }
-          end
+          RequestContext.with(context) { block&.call(*block_args) }
         end
         wrapper.ruby2_keywords
 

data/lib/profiler/job_profiler.rb

@@ -31,14 +31,16 @@ module Profiler
     def self.profile(job_class:, job_id:, queue:, arguments:, executions:, parent_token: nil, &block)
       return block.call unless Profiler.enabled? && Profiler.configuration.track_jobs
 
-      new(
+      profiler = new(
         job_class: job_class,
         job_id: job_id,
         queue: queue,
         arguments: arguments,
         executions: executions,
         parent_token: parent_token
-      ).run(&block)
+      )
+      # Performed by a pool for the request that enqueued it: the job's notifications are its own.
+      Collectors::ScopedNotifications.apart_from_other_threads { profiler.run(&block) }
     end
 
     def initialize(job_class:, job_id:, queue:, arguments:, executions:, parent_token: nil)

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") || {}

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
 
@@ -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_detail.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../slave_support"
+require_relative "../../process_snapshot"
 
 require "shellwords"
 require "cgi"
@@ -22,7 +23,10 @@ module Profiler
 
           storage = MCP::SlaveSupport.resolve_storage(params)
           profile = if token == "latest"
-            storage.list(limit: 1).first
+            # Loaded by its token: a slave adds its own routes and ENV to what it serves then,
+            # never to the profiles it lists.
+            latest = storage.list(limit: 1).first
+            latest && (storage.load(latest.token) || latest)
           else
             storage.load(token)
           end
@@ -50,6 +54,9 @@ module Profiler
         def self.format_profile_detail(profile, params = {})
           requested = params["sections"]&.map(&:to_s)
           want = ->(name) { requested.nil? || requested.include?(name) }
+          # The route table and ENV are the process's, not stored in the profile. A slave's
+          # profile comes with the slave's: this process's would be another process's.
+          Profiler::ProcessSnapshot.hydrate(profile) unless params["slave"]
 
           lines = []
           lines += section_overview(profile)              if want.("overview")

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" }
 

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" }
 

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"]

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" }