rails-profiler 0.31.1 → 0.31.3

data/lib/profiler/middleware/toolbar_injector.rb

@@ -129,17 +129,10 @@ module Profiler
         end
       end
 
+      # The middleware hands over the page it has already read: an Array of parts, or a String.
+      # Never a body to iterate, which would drain a stream and close it.
       def extract_content(body)
-        if body.respond_to?(:body)
-          body.body
-        elsif body.respond_to?(:each)
-          parts = []
-          body.each { |part| parts << part }
-          body.close if body.respond_to?(:close)
-          parts.join
-        else
-          body.to_s
-        end
+        body.is_a?(String) ? body : Array(body).join
       end
 
       def toolbar_html

data/lib/profiler/models/profile.rb

@@ -5,17 +5,21 @@ require "securerandom"
 require "json"
 require "zlib"
 require_relative "../redaction"
+require_relative "../allocation_counter"
 
 module Profiler
   module Models
     class Profile
       attr_reader :path
-      attr_accessor :token, :method, :status, :duration, :memory,
+      attr_accessor :token, :method, :status, :duration, :allocated_objects,
                     :started_at, :finished_at, :params, :headers,
                     :response_headers, :collectors_data, :collectors_metadata,
                     :parent_token, :is_ajax, :profile_type,
                     :request_body, :request_body_encoding,
                     :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,
                     :gem_version
 
       def initialize(request = nil)
@@ -35,13 +39,32 @@ module Profiler
         end
       end
 
-      def set_bodies(request_body:, response_body:, req_content_type:, resp_content_type:)
+      # The sizes are those of the whole bodies, when a body was cut at max_captured_body_bytes;
+      # *_size_is_minimum when the whole size is not known (no Content-Length, a stream that
+      # stopped), only that it is at least that.
+      def set_bodies(request_body:, response_body:, req_content_type:, resp_content_type:,
+                     request_body_size: nil, response_body_size: nil,
+                     request_body_size_is_minimum: false, response_body_size_is_minimum: false)
         req  = process_body(request_body, req_content_type)
         resp = process_body(response_body, resp_content_type)
         @request_body          = req[:body]
         @request_body_encoding = req[:encoding]
         @response_body         = resp[:body]
         @response_body_encoding = resp[:encoding]
+        @request_body_size, @request_body_truncated = body_size(request_body, request_body_size)
+        @response_body_size, @response_body_truncated = body_size(response_body, response_body_size)
+        @request_body_size_is_minimum = request_body_size_is_minimum ? true : false
+        @response_body_size_is_minimum = response_body_size_is_minimum ? true : false
+      end
+
+      # Deprecated: the number of allocated objects times 40, the figure earlier versions
+      # reported as bytes. Still written in to_h, for the readers that only know it.
+      def memory
+        @allocated_objects&.*(AllocationCounter::LEGACY_BYTES_PER_OBJECT)
+      end
+
+      def memory=(value)
+        @allocated_objects = value && value / AllocationCounter::LEGACY_BYTES_PER_OBJECT
       end
 
       def finish(status, response_headers = {})
@@ -67,8 +90,20 @@ module Profiler
       end
 
       def add_collector_metadata(collector)
+        @collectors_metadata << collector_metadata(collector)
+      end
+
+      # A collector collected again, after the profile's tabs were listed (a streamed response
+      # that failed part way): its tab keeps its place, with what it now has.
+      def refresh_collector_metadata(collector)
+        entry = collector_metadata(collector)
+        index = @collectors_metadata.index { |tab| tab[:key] == entry[:key] }
+        index ? @collectors_metadata[index] = entry : @collectors_metadata << entry
+      end
+
+      def collector_metadata(collector)
         config = collector.tab_config
-        @collectors_metadata << {
+        {
           key: config[:key],
           label: config[:label],
           icon: config[:icon],
@@ -79,6 +114,7 @@ module Profiler
           has_data: collector.has_data?
         }
       end
+      private :collector_metadata
 
       def to_h
         req_body,  req_enc  = decode_body(@request_body,  @request_body_encoding)
@@ -92,7 +128,8 @@ module Profiler
           method: @method,
           status: @status,
           duration: @duration,
-          memory: @memory,
+          allocated_objects: @allocated_objects,
+          memory: memory,
           started_at: @started_at&.iso8601,
           finished_at: @finished_at&.iso8601,
           params: @params,
@@ -102,6 +139,13 @@ module Profiler
           request_body_encoding: req_enc,
           response_body: resp_body,
           response_body_encoding: resp_enc,
+          request_body_size: @request_body_size,
+          request_body_truncated: @request_body_truncated,
+          request_body_size_is_minimum: @request_body_size_is_minimum,
+          response_body_size: @response_body_size,
+          response_body_truncated: @response_body_truncated,
+          response_body_size_is_minimum: @response_body_size_is_minimum,
+          collectors_released_after_seconds: @collectors_released_after_seconds,
           collectors_data: @collectors_data,
           tabs: @collectors_metadata,
           parent_token: @parent_token,
@@ -125,7 +169,12 @@ module Profiler
         profile.method = data[:method]
         profile.status = data[:status]
         profile.duration = data[:duration]
-        profile.memory = data[:memory]
+        # A profile saved before allocated_objects only carries memory, the count times 40.
+        if data.key?(:allocated_objects)
+          profile.allocated_objects = data[:allocated_objects]
+        else
+          profile.memory = data[:memory]
+        end
         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]
@@ -135,6 +184,15 @@ module Profiler
         profile.request_body_encoding = data[:request_body_encoding] || "text"
         profile.response_body = data[:response_body]
         profile.response_body_encoding = data[:response_body_encoding] || "text"
+        profile.request_body_size = data[:request_body_size]
+        # Left nil when the store did not keep them (SqliteStore rebuilds a profile from its
+        # columns): the request collector's data still has them.
+        profile.request_body_truncated = data[:request_body_truncated]
+        profile.request_body_size_is_minimum = data[:request_body_size_is_minimum]
+        profile.response_body_size = data[:response_body_size]
+        profile.response_body_truncated = data[:response_body_truncated]
+        profile.response_body_size_is_minimum = data[:response_body_size_is_minimum]
+        profile.collectors_released_after_seconds = data[:collectors_released_after_seconds]
         profile.parent_token = data[:parent_token]
         profile.is_ajax = data[:is_ajax] || false
         profile.profile_type = data[:profile_type] || "http"
@@ -181,6 +239,12 @@ module Profiler
         end
       end
 
+      def body_size(captured, total)
+        captured_size = captured.to_s.bytesize
+        total ||= captured_size
+        [total, total > captured_size]
+      end
+
       def compress_body?(text)
         Profiler.configuration.compress_bodies &&
           text.bytesize > Profiler.configuration.compress_body_threshold

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

@@ -88,6 +88,16 @@ module Profiler
         text.length > max ? "#{text[0, max]}#{ellipsis}" : text
       end
 
+      # The first +max+ bytes of +text+, a body kept only in part. A credential cut in two by the
+      # limit would escape the masking by value, which runs later on what is kept: the bytes
+      # that could start one are left out as well. Text no longer than +max+ is returned whole.
+      def cut_bytes(text, max)
+        return text if text.bytesize <= max
+
+        cut = text.byteslice(0, max)
+        cut.byteslice(0, cut.bytesize - held_back_bytes(cut))
+      end
+
       # How many trailing bytes of +text+, a stream read in pieces, could be
       # the start of a credential and have to wait for the next piece: the
       # longest end of the text that is also the beginning of a credential,

data/lib/profiler/test_profiler.rb

@@ -56,7 +56,7 @@ module Profiler
 
       exception_collector = collectors.find { |c| c.is_a?(Collectors::ExceptionCollector) }
 
-      memory_before = current_memory if Profiler.configuration.track_memory
+      allocations_before = AllocationCounter.current if Profiler.configuration.track_memory
 
       test_status = "passed"
       error_message = nil
@@ -103,7 +103,7 @@ module Profiler
         Profiler::CurrentContext.token = previous_token
 
         if Profiler.configuration.track_memory
-          profile.memory = current_memory - memory_before
+          profile.allocated_objects = AllocationCounter.current - allocations_before
         end
 
         test_collector.update_status(test_status, error_message)
@@ -124,20 +124,5 @@ module Profiler
       # After collect, and also when collect or the storage failed.
       Collectors::Lifecycle.release_all(collectors)
     end
-
-    private
-
-    def current_memory
-      return 0 unless defined?(GC.stat)
-
-      stats = GC.stat
-      if stats.key?(:total_allocated_size)
-        stats[:total_allocated_size]
-      elsif stats.key?(:total_allocated_objects)
-        stats[:total_allocated_objects] * 40
-      else
-        0
-      end
-    end
   end
 end

data/lib/profiler/version.rb

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

data/lib/profiler.rb

@@ -5,6 +5,7 @@ require_relative "profiler/boot_env"
 require_relative "profiler/version"
 require_relative "profiler/configuration"
 require_relative "profiler/redaction"
+require_relative "profiler/allocation_counter"
 
 module Profiler
   class Error < StandardError; end
@@ -15,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
@@ -113,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
@@ -137,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.1
+  version: 0.31.3
 platform: ruby
 authors:
 - Sébastien Duplessy
@@ -133,6 +133,7 @@ files:
 - config/routes.rb
 - exe/profiler-mcp
 - lib/profiler.rb
+- lib/profiler/allocation_counter.rb
 - lib/profiler/boot_env.rb
 - lib/profiler/cluster/master_client.rb
 - lib/profiler/cluster/security.rb
@@ -157,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
@@ -166,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
@@ -206,12 +210,15 @@ files:
 - lib/profiler/mcp/tools/reset_env_var.rb
 - lib/profiler/mcp/tools/run_tests.rb
 - lib/profiler/mcp/tools/set_env_var.rb
+- lib/profiler/middleware/capturing_body.rb
 - lib/profiler/middleware/cors_middleware.rb
 - lib/profiler/middleware/profiler_middleware.rb
+- lib/profiler/middleware/streamed_profile.rb
 - lib/profiler/middleware/toolbar_injector.rb
 - 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
@@ -235,13 +242,13 @@ files:
 - lib/profiler/test_runner/run_store.rb
 - lib/profiler/test_runner/runner.rb
 - lib/profiler/version.rb
-homepage: https://git.duplessy.eu/sebastien/rails-profiler-gem
+homepage: https://github.com/Pepsit36/rails-profiler
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://git.duplessy.eu/sebastien/rails-profiler-gem
-  source_code_uri: https://git.duplessy.eu/sebastien/rails-profiler-gem
-  changelog_uri: https://git.duplessy.eu/sebastien/rails-profiler-gem/-/blob/master/CHANGELOG.md
+  homepage_uri: https://github.com/Pepsit36/rails-profiler
+  source_code_uri: https://github.com/Pepsit36/rails-profiler
+  changelog_uri: https://github.com/Pepsit36/rails-profiler/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: