rails-profiler 0.31.1 → 0.31.3

data/lib/profiler/collectors/database_collector.rb

@@ -6,10 +6,24 @@ require_relative "../models/sql_query"
 module Profiler
   module Collectors
     class DatabaseCollector < BaseCollector
+      BACKTRACE_DEPTH = 10
+      MAX_SCANNED_FRAMES = 100
+      FRAMES_PAST_APPLICATION = 15
+
+
+      # Frames between the application's code and the subscriber: the profiler itself, the
+      # notifications bus and Active Record.
+      INTERNAL_FRAMES = [
+        File.expand_path("..", __dir__) + "/",
+        "/active_support/notifications",
+        "/active_record/"
+      ].freeze
+
       def initialize(profile)
         super
         @queries = []
-        @subscription = nil
+        @subscriptions = []
+        @seen_statements = {}
       end
 
       def icon
@@ -34,7 +48,10 @@ module Profiler
       def subscribe
         return unless defined?(ActiveSupport::Notifications)
 
-        @subscription = ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, started, finished, unique_id, payload|
+        @backtrace_mode = Profiler.configuration.sql_backtrace&.to_sym
+        @slow_query_threshold = Profiler.configuration.slow_query_threshold
+
+        @subscriptions << subscribe_notification("sql.active_record") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2) # milliseconds
 
           # Skip schema queries and internal Rails queries
@@ -47,7 +64,7 @@ module Profiler
             binds: extract_binds(payload[:binds]),
             name: payload[:name],
             connection: payload[:connection],
-            backtrace: extract_backtrace
+            backtrace: backtrace?(payload[:sql], duration) ? extract_backtrace : []
           )
 
           @queries << query
@@ -68,11 +85,13 @@ module Profiler
         store_data(data)
       end
 
-      def unsubscribe
-        return unless @subscription
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
 
-        ActiveSupport::Notifications.unsubscribe(@subscription)
-        @subscription = nil
+      def unsubscribe
+        unsubscribe_notifications(@subscriptions)
       end
 
       def toolbar_summary
@@ -113,10 +132,114 @@ module Profiler
         binds.map { Profiler::Redaction::MASK }
       end
 
+      # Capturing the caller costs tens of microseconds. The first run of a statement locates
+      # it, an N+1 loop included (its repeats are the same statement with other values); a slow
+      # query is always located.
+      def backtrace?(sql, duration)
+        case @backtrace_mode
+        when :all then true
+        when :none then false
+        else
+          key = statement_key(sql)
+          first = !@seen_statements.key?(key)
+          @seen_statements[key] = true if first
+          first || duration > @slow_query_threshold
+        end
+      end
+
+      # The statement with its values left out, exactly as the N+1 detection of the Database tab
+      # (DatabaseTab.tsx) and of the MCP (Resources::N1Patterns) groups queries: the first query
+      # of each group is then always one whose caller was captured, values inlined in the SQL
+      # (MySQL) included.
+      def statement_key(sql)
+        sql.to_s
+           .gsub(/\$\d+/, "?")
+           .gsub(/\b\d+\b/, "?")
+           .gsub(/'[^']*'/, "?")
+           .gsub(/"[^"]*"/, "?")
+           .strip
+      end
+
+      # The code that ran the query: the frames Rails.backtrace_cleaner keeps, as the exception
+      # tab shows them, or without Rails, the frames outside gems and Ruby itself. Whatever stands
+      # in between (the profiler, Active Support, Active Record, the driver, other gems) is left
+      # out, so that the first frames are the application's.
       def extract_backtrace
-        caller_locations(5, 10)
-          .reject { |loc| loc.path.include?("active_record") }
-          .map { |loc| "#{loc.path}:#{loc.lineno}:in `#{loc.label}`" }
+        cleaner = rails_backtrace_cleaner
+        cleaned = []
+        plain = []
+        scanned = 0
+        last_kept = nil
+        while scanned < MAX_SCANNED_FRAMES && cleaned.size < BACKTRACE_DEPTH
+          chunk = caller_locations(1 + scanned, 25)
+          break if chunk.nil? || chunk.empty?
+
+          chunk.each do |loc|
+            scanned += 1
+            path = loc.path.to_s
+            next if INTERNAL_FRAMES.any? { |internal| path.include?(internal) }
+            # Gems and Ruby are never the application's code, and Rails' cleaner silences them
+            # too: a string test spares it most frames.
+            next if library_frame?(path)
+
+            line = "#{path}:#{loc.lineno}:in `#{loc.label}`"
+            if cleaner && (kept = clean_frame(cleaner, line))
+              cleaned << kept
+              last_kept = scanned
+            end
+            plain << line if plain.size < BACKTRACE_DEPTH
+            break if cleaned.size == BACKTRACE_DEPTH
+          end
+          # Without Rails, the first frames outside gems are enough; with it, the application's
+          # frames come together: a few frames past the last one kept, the rest is the framework.
+          break if cleaner.nil? && plain.size >= BACKTRACE_DEPTH
+          break if last_kept && scanned - last_kept > FRAMES_PAST_APPLICATION
+        end
+
+        frames = cleaned.empty? ? plain : cleaned
+        frames.empty? ? fallback_backtrace : frames
+      end
+
+      def rails_backtrace_cleaner
+        Rails.backtrace_cleaner if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+      rescue StandardError
+        nil
+      end
+
+      # The frame as the cleaner shows it, or nil when it silences it.
+      def clean_frame(cleaner, line)
+        cleaner.respond_to?(:clean_frame) ? cleaner.clean_frame(line) : cleaner.clean([line]).first
+      rescue StandardError
+        nil
+      end
+
+      def fallback_backtrace
+        (caller_locations(1, BACKTRACE_DEPTH + 20) || []).filter_map do |loc|
+          path = loc.path.to_s
+          "#{path}:#{loc.lineno}:in `#{loc.label}`" unless INTERNAL_FRAMES.any? { |internal| path.include?(internal) }
+        end.first(BACKTRACE_DEPTH)
+      end
+
+      # Ruby itself and the directories gems are installed in; an application that lives under a
+      # directory called gems is not one.
+      def library_frame?(path)
+        path.start_with?("<internal:") || library_prefixes.any? { |dir| path.start_with?(dir) }
+      end
+
+      def library_prefixes
+        @library_prefixes ||= begin
+          dirs = [RbConfig::CONFIG["rubylibdir"], RbConfig::CONFIG["rubyarchdir"], RbConfig::CONFIG["bindir"]]
+          dirs.concat(Gem.path) if defined?(Gem)
+          dirs << bundle_path
+          dirs.compact.reject(&:empty?).map { |dir| File.join(File.expand_path(dir), "") }.uniq.freeze
+        end
+      end
+
+      # Bundler raises without a Gemfile.
+      def bundle_path
+        Bundler.bundle_path.to_s if defined?(Bundler) && Bundler.respond_to?(:bundle_path)
+      rescue StandardError
+        nil
       end
     end
   end

data/lib/profiler/collectors/env_collector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_collector"
+require_relative "../process_snapshot"
 
 module Profiler
   module Collectors
@@ -24,14 +25,21 @@ module Profiler
         }
       end
 
+      # ENV is the process's, not the request's: an HTTP profile keeps none of it, and the Env tab
+      # shows the variables of the process that displays the profile, which is the one that served
+      # the request (ProcessSnapshot). A job, a console expression or a test runs in another
+      # process (Sidekiq, the console, rspec): its profile keeps that process's ENV, masked.
       def collect
-        variables = Profiler::Redaction.env_snapshot
-        store_data({ variables: variables, total: variables.size })
+        if @profile.profile_type.to_s == "http"
+          store_data({ scope: "process" })
+        else
+          variables = Profiler::Redaction.env_snapshot
+          store_data({ variables: variables, total: variables.size })
+        end
       end
 
       def toolbar_summary
-        data = panel_content
-        { text: "#{data[:total] || 0} vars", color: "gray" }
+        { text: "#{ENV.size} vars", color: "gray" }
       end
     end
   end

data/lib/profiler/collectors/exception_collector.rb

@@ -31,11 +31,12 @@ module Profiler
       def subscribe
         @exception_data = nil
 
-        @subscriber = ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
-          event = ActiveSupport::Notifications::Event.new(*args)
-          ex = event.payload[:exception_object]
-          capture_exception(ex) if ex && @exception_data.nil?
-        end
+        @subscriptions = [
+          subscribe_notification("process_action.action_controller") do |_name, _started, _finished, _id, payload|
+            ex = payload[:exception_object]
+            capture_exception(ex) if ex && @exception_data.nil?
+          end
+        ]
       end
 
       def capture(ex)
@@ -48,11 +49,13 @@ module Profiler
         store_data(@exception_data || {})
       end
 
-      def unsubscribe
-        return unless @subscriber
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
 
-        ActiveSupport::Notifications.unsubscribe(@subscriber)
-        @subscriber = nil
+      def unsubscribe
+        unsubscribe_notifications(@subscriptions) if @subscriptions
       end
 
       def has_data?

data/lib/profiler/collectors/flamegraph_collector.rb

@@ -38,7 +38,7 @@ module Profiler
         claim_thread_slot(:profiler_flamegraph_collector, self)
 
         # Controller action
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("process_action.action_controller") do |_name, started, finished, _unique_id, payload|
+        @subscriptions << subscribe_notification("process_action.action_controller") do |_name, started, finished, _unique_id, payload|
           add_event Models::TimelineEvent.new(
             name: "#{payload[:controller]}##{payload[:action]}",
             started_at: started,
@@ -56,7 +56,7 @@ module Profiler
         end
 
         # Template rendering
-        @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|
           identifier = short_identifier(payload[:identifier])
           add_event Models::TimelineEvent.new(
             name: "Render: #{identifier}",
@@ -68,7 +68,7 @@ module Profiler
         end
 
         # Partial rendering
-        @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|
           identifier = short_identifier(payload[:identifier])
           add_event Models::TimelineEvent.new(
             name: "Partial: #{identifier}",
@@ -80,7 +80,7 @@ module Profiler
         end
 
         # SQL queries
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |_name, started, finished, _unique_id, payload|
+        @subscriptions << subscribe_notification("sql.active_record") do |_name, started, finished, _unique_id, payload|
           next if payload[:name] == "SCHEMA"
           next if payload[:sql] =~ /^(BEGIN|COMMIT|ROLLBACK|SAVEPOINT)/i
 
@@ -96,7 +96,7 @@ module Profiler
 
         # Cache operations
         %w[cache_read.active_support cache_write.active_support cache_delete.active_support].each do |event_name|
-          @subscriptions << ActiveSupport::Notifications.monotonic_subscribe(event_name) do |name, started, finished, _unique_id, payload|
+          @subscriptions << subscribe_notification(event_name) do |name, started, finished, _unique_id, payload|
             op = name.split(".").first.sub("cache_", "")
             key = payload[:key].to_s
             add_event Models::TimelineEvent.new(
@@ -144,6 +144,11 @@ module Profiler
         })
       end
 
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
+
       def unsubscribe
         unsubscribe_notifications(@subscriptions)
         restore_thread_slots

data/lib/profiler/collectors/function_profiler_collector.rb

@@ -5,7 +5,7 @@ require_relative "base_collector"
 begin
   require "stackprof"
 rescue LoadError
-  # stackprof not available — lite mode will fall back to TracePoint without memory tracking
+  # stackprof not available: lite mode stays off, unless Profiler.function_profiling_tracepoint_fallback
 end
 
 module Profiler
@@ -55,6 +55,20 @@ module Profiler
 
         mode  = Profiler.function_profiling_mode
         clock = Profiler.function_profiling_clock
+
+        # Sampling needs stackprof, which the gem does not depend on. Tracing every method call
+        # instead costs several times the rest of the profiler: only when asked for.
+        if stackprof_missing?(mode)
+          store_data({
+            enabled:    false,
+            reason:     "stackprof_missing",
+            max_frames: Profiler.function_profiling_max_frames,
+            mode:       mode,
+            clock:      clock
+          })
+          return
+        end
+
         @subscribed = true
         claim_thread_slot(:fn_profiler_mode, mode)
         claim_thread_slot(:fn_profiler_clock, clock)
@@ -119,6 +133,7 @@ module Profiler
 
       def toolbar_summary
         return { text: "off", color: "gray" } unless Profiler.function_profiling_enabled
+        return { text: "off", color: "gray" } if stackprof_missing?(Profiler.function_profiling_mode)
         case Profiler.function_profiling_mode
         when "lite" then { text: "sampling on", color: "blue" }
         else             { text: "fn profiling on", color: "purple" }
@@ -127,6 +142,10 @@ module Profiler
 
       private
 
+      def stackprof_missing?(mode)
+        mode == "lite" && !defined?(StackProf) && !Profiler.function_profiling_tracepoint_fallback
+      end
+
       # ── StackProf (lite mode) ──────────────────────────────────────────────────
 
       def store_sampler_busy(mode, clock)
@@ -297,10 +316,9 @@ module Profiler
         claim_thread_slot(:fn_profiler_depth, Hash.new(0))
 
         @trace = TracePoint.new(:call, :return) do |tp|
-          next unless tp.path&.start_with?(app_root)
-
           stack = Thread.current[:fn_profiler_stack]
           next unless stack
+          next unless tp.path&.start_with?(app_root)
 
           case tp.event
           when :call
@@ -339,7 +357,13 @@ module Profiler
           end
         end
 
-        @trace.enable
+        # On the request's thread only: a TracePoint enabled for the whole process slows down
+        # every other thread, other requests included.
+        begin
+          @trace.enable(target_thread: Thread.current)
+        rescue ArgumentError
+          @trace.enable # a Ruby without target_thread: the hook returns at once on other threads
+        end
       end
 
       def collect_tracepoint(mode)

data/lib/profiler/collectors/http_collector.rb

@@ -39,6 +39,11 @@ module Profiler
         claim_thread_slot(:profiler_http_collector, self)
       end
 
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
+
       # The Net::HTTP patch installed by subscribe stays: it is installed once per process and
       # records nothing when no collector holds the thread-local slot.
       def unsubscribe

data/lib/profiler/collectors/log_collector.rb

@@ -93,6 +93,11 @@ module Profiler
         warn "LogCollector#subscribe failed: #{e.message}"
       end
 
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
+
       def unsubscribe
         if @capture_logger
           @broadcaster.stop_broadcasting_to(@capture_logger) if @broadcaster.respond_to?(:stop_broadcasting_to)

data/lib/profiler/collectors/mailer_collector.rb

@@ -40,15 +40,10 @@ module Profiler
         return unless defined?(ActiveSupport::Notifications)
         return unless Profiler.configuration.track_mailers
 
-        # Capture the subscriber thread so notifications from other threads (e.g. async
-        # job threads delivering mail enqueued via deliver_later) are ignored by this collector.
-        @subscriber_thread = Thread.current
-
         # Use a stack so multiple deliver_later calls in the same request are all tracked.
         claim_thread_slot(:profiler_pending_processes, [])
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("process.action_mailer") do |_name, started, finished, _id, payload|
-          next unless Thread.current.equal?(@subscriber_thread)
+        @subscriptions << subscribe_notification("process.action_mailer") do |_name, started, finished, _id, payload|
           next if rails_preview_request?
 
           mailer_class = payload[:mailer].to_s
@@ -64,8 +59,7 @@ module Profiler
           }
         end
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("deliver.action_mailer") do |_name, started, finished, _id, payload|
-          next unless Thread.current.equal?(@subscriber_thread)
+        @subscriptions << subscribe_notification("deliver.action_mailer") do |_name, started, finished, _id, payload|
           next unless payload[:perform_deliveries]
           next if rails_preview_request?
 

data/lib/profiler/collectors/request_collector.rb

@@ -30,7 +30,8 @@ module Profiler
           method: @profile.method,
           status: @profile.status,
           duration: @profile.duration,
-          memory: @profile.memory,
+          allocated_objects: @profile.allocated_objects,
+          memory: @profile.memory, # deprecated, see Profile#memory
           params: @profile.params,
           headers: @profile.headers,
           response_headers: @profile.response_headers,
@@ -38,6 +39,14 @@ module Profiler
           request_body_encoding: @profile.request_body_encoding,
           response_body: @profile.response_body,
           response_body_encoding: @profile.response_body_encoding,
+          request_body_size: @profile.request_body_size,
+          request_body_truncated: @profile.request_body_truncated || false,
+          request_body_size_is_minimum: @profile.request_body_size_is_minimum || false,
+          response_body_size: @profile.response_body_size,
+          response_body_truncated: @profile.response_body_truncated || false,
+          response_body_size_is_minimum: @profile.response_body_size_is_minimum || false,
+          # A streamed response whose collectors were released before its body was closed.
+          collectors_released_after_seconds: @profile.collectors_released_after_seconds,
           started_at: @profile.started_at&.iso8601,
           finished_at: @profile.finished_at&.iso8601
         }
@@ -59,7 +68,7 @@ module Profiler
           text: "#{@profile.method} #{@profile.status}",
           color: status_color,
           duration: @profile.duration,
-          memory: format_memory(@profile.memory)
+          allocated_objects: format_allocations(@profile.allocated_objects)
         }
       end
 
@@ -98,16 +107,10 @@ module Profiler
         {}
       end
 
-      def format_memory(bytes)
-        return "0 B" unless bytes
+      def format_allocations(count)
+        return "0 objects" unless count
 
-        if bytes < 1024
-          "#{bytes} B"
-        elsif bytes < 1024 * 1024
-          "#{(bytes / 1024.0).round(2)} KB"
-        else
-          "#{(bytes / 1024.0 / 1024.0).round(2)} MB"
-        end
+        "#{count.to_s.reverse.scan(/\d{1,3}/).join(",").reverse} objects"
       end
     end
   end

data/lib/profiler/collectors/routes_collector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_collector"
+require_relative "../process_snapshot"
 
 module Profiler
   module Collectors
@@ -24,65 +25,21 @@ module Profiler
         }
       end
 
+      # The route the request matched, and the size of the table: the table itself is the same
+      # for every request, and is added back when the profile is displayed (ProcessSnapshot).
       def collect
-        unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
-          return store_data({ routes: [], total: 0 })
-        end
-
-        matched_controller, matched_action = recognize_current_route
-        routes = build_routes_list(matched_controller, matched_action)
-        matched_route = routes.find { |r| r[:matched] }
+        matched = ProcessSnapshot.matched_route(@profile.path, @profile.method)
 
         store_data({
-          total: routes.size,
-          matched: matched_route,
-          routes: routes
+          total: ProcessSnapshot.route_table.size,
+          matched: matched && matched.merge(matched: true)
         })
       end
 
       def toolbar_summary
         data = panel_content
         matched = data[:matched]
-        { text: matched ? matched[:pattern] : "—", color: "blue" }
-      end
-
-      private
-
-      def recognize_current_route
-        recognized = Rails.application.routes.recognize_path(@profile.path, method: @profile.method)
-        [recognized[:controller], recognized[:action]]
-      rescue StandardError
-        [nil, nil]
-      end
-
-      def build_routes_list(matched_controller, matched_action)
-        Rails.application.routes.routes.filter_map do |route|
-          next if route.respond_to?(:internal) && route.internal
-
-          controller = route.defaults[:controller]
-          action = route.defaults[:action]
-          next if controller.nil?
-          next if controller.start_with?("rails/", "profiler/")
-
-          name = route.name
-          pattern = route.path.spec.to_s.sub(/\(\.:format\)$/, "")
-          v = route.verb
-          verb = (v && !v.empty?) ? v : "ANY"
-
-          controller_action = if controller && action
-            "#{controller.split("/").map { |s| ActiveSupport::Inflector.camelize(s) }.join("::")}Controller##{action}"
-          end
-
-          {
-            name: name,
-            pattern: pattern,
-            verb: verb,
-            controller_action: controller_action,
-            matched: controller == matched_controller && action == matched_action
-          }
-        end
-      rescue StandardError
-        []
+        { text: matched ? matched[:pattern] : "\u2014", color: "blue" }
       end
     end
   end