rails-profiler 0.31.2 → 0.31.3

data/lib/profiler/process_snapshot.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "redaction"
+
+module Profiler
+  # What is the same for every request of a process, kept out of the profiles: the route table
+  # and ENV. A profile stores the route its request matched; the Routes and Env tabs, the
+  # toolbar and the MCP tools get the table and the variables from the process that displays the
+  # profile (#hydrate).
+  #
+  # The route table is built once and built again when the routes are reloaded, in development
+  # (reload_routes!, or a change picked up by the reloader): the routes are new objects then.
+  # ENV is read when the profile is displayed, masked as it always was: it can change while the
+  # process runs, through the profiler's own env overrides among others.
+  module ProcessSnapshot
+    @mutex = Mutex.new
+    @routes = nil # [fingerprint, table, routes by [controller, action]]
+
+    class << self
+      # The application's routes, the engine's and Rails' own left out, as the Routes tab lists
+      # them: { name:, pattern:, verb:, controller_action: }.
+      def route_table
+        routes_snapshot[1]
+      end
+
+      # The route of the table a request to +path+ with +method+ is dispatched to, or nil.
+      def matched_route(path, method)
+        return nil unless rails_routes?
+
+        recognized = Rails.application.routes.recognize_path(path, method: method)
+        candidates = routes_snapshot[2][[recognized[:controller], recognized[:action]]]
+        return nil unless candidates
+
+        # A PUT goes to the action of the PATCH route too: give the route of the request's verb.
+        verb = method.to_s.upcase == "HEAD" ? "GET" : method.to_s.upcase
+        candidates.find { |route| route[:verb].split("|").include?(verb) } ||
+          candidates.find { |route| route[:verb] == "ANY" } ||
+          candidates.first
+      rescue StandardError
+        nil
+      end
+
+      # ENV as the Env tab shows it.
+      def env_variables
+        Redaction.hide_credentials(Redaction.env_snapshot)
+      end
+
+      # Puts the route table and ENV back into +profile+'s data for display. A profile saved by
+      # an earlier version has its own table and variables, and is left as it is.
+      def hydrate(profile)
+        # A job, a console expression or a test ran in another process, whose ENV its profile keeps.
+        return profile unless profile && profile.profile_type.to_s == "http"
+
+        data = profile.collectors_data
+        if (routes = data["routes"]) && !key?(routes, :routes)
+          data["routes"] = with_route_table(routes)
+        end
+        if (env = data["env"]) && !key?(env, :variables)
+          variables = env_variables
+          data["env"] = merge(env, variables: variables, total: variables.size)
+        end
+        profile
+      rescue StandardError => e
+        warn "Profiler: could not add the routes and ENV to profile #{profile.token}: #{e.message}"
+        profile
+      end
+
+      private
+
+      def rails_routes?
+        defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+      end
+
+      def routes_snapshot
+        return [nil, [].freeze, {}.freeze] unless rails_routes?
+
+        journey = Rails.application.routes.routes
+        list = journey.respond_to?(:routes) ? journey.routes : journey.to_a
+        fingerprint = [journey.object_id, list.size, list.first&.object_id, list.last&.object_id]
+        snapshot = @routes
+        return snapshot if snapshot && snapshot[0] == fingerprint
+
+        @mutex.synchronize do
+          @routes = build_snapshot(fingerprint, list) unless @routes && @routes[0] == fingerprint
+          @routes
+        end
+      rescue StandardError
+        [nil, [].freeze, {}.freeze]
+      end
+
+      def build_snapshot(fingerprint, list)
+        index = {}
+        table = list.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/")
+
+          verb = route.verb
+          entry = {
+            name: route.name,
+            pattern: route.path.spec.to_s.sub(/\(\.:format\)$/, ""),
+            verb: (verb && !verb.empty?) ? verb : "ANY",
+            controller_action: controller_action(controller, action)
+          }.freeze
+          (index[[controller, action]] ||= []) << entry
+          entry
+        end
+        [fingerprint, table.freeze, index.each_value(&:freeze).freeze]
+      end
+
+      def controller_action(controller, action)
+        return nil unless action
+
+        "#{controller.split("/").map { |s| ActiveSupport::Inflector.camelize(s) }.join("::")}Controller##{action}"
+      end
+
+      def with_route_table(routes)
+        matched = fetch(routes, :matched)
+        table = route_table.map { |route| route.merge(matched: same_route?(route, matched)) }
+        merge(routes, routes: table, total: table.size)
+      end
+
+      # Every route of the matched action, as the table always marked them.
+      def same_route?(route, matched)
+        return false unless matched.is_a?(Hash)
+
+        action = fetch(matched, :controller_action)
+        action ? route[:controller_action] == action : route[:pattern] == fetch(matched, :pattern)
+      end
+
+      # Collector data has symbol keys as collected, string keys once read back from storage.
+      def key?(hash, key)
+        hash.key?(key) || hash.key?(key.to_s)
+      end
+
+      def fetch(hash, key)
+        hash.key?(key) ? hash[key] : hash[key.to_s]
+      end
+
+      def merge(hash, values)
+        strings = hash.keys.first.is_a?(String)
+        hash.merge(strings ? deep_stringify(values) : values)
+      end
+
+      def deep_stringify(value)
+        case value
+        when Hash then value.to_h { |k, v| [k.to_s, deep_stringify(v)] }
+        when Array then value.map { |v| deep_stringify(v) }
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.31.2"
+  VERSION = "0.31.3"
 end

data/lib/profiler.rb

@@ -16,6 +16,9 @@ module Profiler
     attr_accessor :function_profiling_max_frames
     attr_accessor :function_profiling_mode
     attr_accessor :function_profiling_clock
+    # Without stackprof, the function profiler stays off unless this is true: it then traces
+    # every method call of the request's thread with a TracePoint, several times slower.
+    attr_accessor :function_profiling_tracepoint_fallback
 
     def configuration
       @configuration ||= Configuration.new
@@ -114,6 +117,7 @@ module Profiler
   self.function_profiling_max_frames = 2000
   self.function_profiling_mode = "lite"
   self.function_profiling_clock = "wall"
+  self.function_profiling_tracepoint_fallback = false
 end
 
 # Require core components
@@ -138,6 +142,7 @@ require_relative "profiler/storage/token"
 require_relative "profiler/storage/private_files"
 require_relative "profiler/env_override_store"
 require_relative "profiler/instrumentation/thread_context_propagation"
+require_relative "profiler/instrumentation/executor_context_propagation"
 require_relative "profiler/sse/event_bus"
 require_relative "profiler/sse/redis_event_bus"
 require_relative "profiler/sse/bus"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.31.2
+  version: 0.31.3
 platform: ruby
 authors:
 - Sébastien Duplessy
@@ -158,6 +158,7 @@ files:
 - lib/profiler/collectors/mailer_collector.rb
 - lib/profiler/collectors/request_collector.rb
 - lib/profiler/collectors/routes_collector.rb
+- lib/profiler/collectors/scoped_notifications.rb
 - lib/profiler/collectors/test_collector.rb
 - lib/profiler/collectors/view_collector.rb
 - lib/profiler/configuration.rb
@@ -167,8 +168,10 @@ files:
 - lib/profiler/env_override_store.rb
 - lib/profiler/explain_runner.rb
 - lib/profiler/instrumentation/active_job_instrumentation.rb
+- lib/profiler/instrumentation/executor_context_propagation.rb
 - lib/profiler/instrumentation/irb_instrumentation.rb
 - lib/profiler/instrumentation/net_http_instrumentation.rb
+- lib/profiler/instrumentation/request_context.rb
 - lib/profiler/instrumentation/sidekiq_middleware.rb
 - lib/profiler/instrumentation/thread_context_propagation.rb
 - lib/profiler/job_profiler.rb
@@ -215,6 +218,7 @@ files:
 - lib/profiler/models/profile.rb
 - lib/profiler/models/sql_query.rb
 - lib/profiler/models/timeline_event.rb
+- lib/profiler/process_snapshot.rb
 - lib/profiler/railtie.rb
 - lib/profiler/redaction.rb
 - lib/profiler/sql_statement.rb