rack-mini-profiler 3.1.0 → 3.3.0

data/lib/mini_profiler.rb

@@ -12,11 +12,15 @@ require 'mini_profiler/context'
 require 'mini_profiler/client_settings'
 require 'mini_profiler/gc_profiler'
 require 'mini_profiler/snapshots_transporter'
+require 'mini_profiler/views'
+require 'mini_profiler/actions'
 
 module Rack
   class MiniProfiler
-    class << self
+    include Actions
+    include Views
 
+    class << self
       include Rack::MiniProfiler::ProfilingMethods
       attr_accessor :subscribe_sql_active_record
 
@@ -37,14 +41,6 @@ module Rack
         @config ||= Config.default
       end
 
-      def resources_root
-        @resources_root ||= ::File.expand_path("../html", __FILE__)
-      end
-
-      def share_template
-        @share_template ||= ERB.new(::File.read(::File.expand_path("html/share.html", ::File.dirname(__FILE__))))
-      end
-
       def current
         Thread.current[:mini_profiler_private]
       end
@@ -138,70 +134,6 @@ module Rack
       @config.user_provider.call(env)
     end
 
-    def serve_results(env)
-      request     = Rack::Request.new(env)
-      id          = request.params['id']
-      group_name  = request.params['group']
-      is_snapshot = group_name && group_name.size > 0
-      if is_snapshot
-        page_struct = @storage.load_snapshot(id, group_name)
-      else
-        page_struct = @storage.load(id)
-      end
-      if !page_struct && is_snapshot
-        id = ERB::Util.html_escape(id)
-        return [404, {}, ["Snapshot with id '#{id}' not found"]]
-      elsif !page_struct
-        @storage.set_viewed(user(env), id)
-        id        = ERB::Util.html_escape(id)
-        user_info = ERB::Util.html_escape(user(env))
-        return [404, {}, ["Request not found: #{id} - user #{user_info}"]]
-      end
-      if !page_struct[:has_user_viewed] && !is_snapshot
-        page_struct[:client_timings]  = TimerStruct::Client.init_from_form_data(env, page_struct)
-        page_struct[:has_user_viewed] = true
-        @storage.save(page_struct)
-        @storage.set_viewed(user(env), id)
-      end
-
-      # If we're an XMLHttpRequest, serve up the contents as JSON
-      if request.xhr?
-        result_json = page_struct.to_json
-        [200, { 'Content-Type' => 'application/json' }, [result_json]]
-      else
-        # Otherwise give the HTML back
-        html = generate_html(page_struct, env)
-        [200, { 'Content-Type' => 'text/html' }, [html]]
-      end
-    end
-
-    def generate_html(page_struct, env, result_json = page_struct.to_json)
-      # double-assigning to suppress "assigned but unused variable" warnings
-      path = path = "#{env['RACK_MINI_PROFILER_ORIGINAL_SCRIPT_NAME']}#{@config.base_url_path}"
-      version = version = MiniProfiler::ASSET_VERSION
-      json = json = result_json
-      includes = includes = get_profile_script(env)
-      name = name = page_struct[:name]
-      duration = duration = page_struct.duration_ms.round(1).to_s
-
-      MiniProfiler.share_template.result(binding)
-    end
-
-    def serve_html(env)
-      path      = env['PATH_INFO'].sub('//', '/')
-      file_name = path.sub(@config.base_url_path, '')
-
-      return serve_results(env) if file_name.eql?('results')
-      return handle_snapshots_request(env) if file_name.eql?('snapshots')
-      return serve_flamegraph(env) if file_name.eql?('flamegraph')
-
-      resources_env = env.dup
-      resources_env['PATH_INFO'] = file_name
-
-      rack_file = Rack::File.new(MiniProfiler.resources_root, 'Cache-Control' => "max-age=#{cache_control_value}")
-      rack_file.call(resources_env)
-    end
-
     def current
       MiniProfiler.current
     end
@@ -228,13 +160,12 @@ module Rack
       MiniProfiler.deauthorize_request if @config.authorization_mode == :allow_authorized
 
       status = headers = body = nil
-      query_string = env['QUERY_STRING']
       path         = env['PATH_INFO'].sub('//', '/')
 
       # Someone (e.g. Rails engine) could change the SCRIPT_NAME so we save it
       env['RACK_MINI_PROFILER_ORIGINAL_SCRIPT_NAME'] = ENV['PASSENGER_BASE_URI'] || env['SCRIPT_NAME']
 
-      skip_it = /#{@config.profile_parameter}=skip/.match?(query_string) || (
+      skip_it = matches_action?('skip', env) || (
         @config.skip_paths &&
         @config.skip_paths.any? do |p|
           if p.instance_of?(String)
@@ -262,15 +193,29 @@ module Rack
       end
 
       # handle all /mini-profiler requests here
-      return client_settings.handle_cookie(serve_html(env)) if path.start_with? @config.base_url_path
+      if path.start_with? @config.base_url_path
+        file_name = path.sub(@config.base_url_path, '')
+
+        case file_name
+        when 'results'
+          return serve_results(env)
+        when 'snapshots'
+          self.current = nil
+          return serve_snapshot(env)
+        when 'flamegraph'
+          return serve_flamegraph(env)
+        end
+
+        return client_settings.handle_cookie(serve_file(env, file_name: file_name))
+      end
 
       has_disable_cookie = client_settings.disable_profiling?
       # manual session disable / enable
-      if query_string =~ /#{@config.profile_parameter}=disable/ || has_disable_cookie
+      if matches_action?('disable', env) || has_disable_cookie
         skip_it = true
       end
 
-      if query_string =~ /#{@config.profile_parameter}=enable/
+      if matches_action?('enable', env)
         skip_it = false
         config.enabled = true
       end
@@ -279,54 +224,32 @@ module Rack
         status, headers, body = @app.call(env)
         client_settings.disable_profiling = true
         return client_settings.handle_cookie([status, headers, body])
-      else
-        client_settings.disable_profiling = false
       end
 
+      # remember that profiling is not disabled (ie enabled)
+      client_settings.disable_profiling = false
+
       # profile gc
-      if query_string =~ /#{@config.profile_parameter}=profile-gc/
-        return tool_disabled_message(client_settings) if !advanced_debugging_enabled?
+      if matches_action?('profile-gc', env)
         current.measure = false if current
-        return client_settings.handle_cookie(Rack::MiniProfiler::GCProfiler.new.profile_gc(@app, env))
+        return serve_profile_gc(env, client_settings)
       end
 
       # profile memory
-      if query_string =~ /#{@config.profile_parameter}=profile-memory/
-        return tool_disabled_message(client_settings) if !advanced_debugging_enabled?
-
-        unless defined?(MemoryProfiler) && MemoryProfiler.respond_to?(:report)
-          message = "Please install the memory_profiler gem and require it: add gem 'memory_profiler' to your Gemfile"
-          status, headers, body = @app.call(env)
-          body.close if body.respond_to? :close
-
-          return client_settings.handle_cookie(
-            text_result(message, status: 500, headers: headers)
-          )
-        end
-
-        query_params = Rack::Utils.parse_nested_query(query_string)
-        options = {
-          ignore_files: query_params['memory_profiler_ignore_files'],
-          allow_files: query_params['memory_profiler_allow_files'],
-        }
-        options[:top] = Integer(query_params['memory_profiler_top']) if query_params.key?('memory_profiler_top')
-        result = StringIO.new
-        report = MemoryProfiler.report(options) do
-          _, _, body = @app.call(env)
-          body.close if body.respond_to? :close
-        end
-        report.pretty_print(result)
-        return client_settings.handle_cookie(text_result(result.string))
+      if matches_action?('profile-memory', env)
+        return serve_profile_memory(env, client_settings)
       end
 
+      # any other requests past this point are going to the app to be profiled
+
       MiniProfiler.create_current(env, @config)
 
-      if query_string =~ /#{@config.profile_parameter}=normal-backtrace/
+      if matches_action?('normal-backtrace', env)
         client_settings.backtrace_level = ClientSettings::BACKTRACE_DEFAULT
-      elsif query_string =~ /#{@config.profile_parameter}=no-backtrace/
+      elsif matches_action?('no-backtrace', env)
         current.skip_backtrace = true
         client_settings.backtrace_level = ClientSettings::BACKTRACE_NONE
-      elsif query_string =~ /#{@config.profile_parameter}=full-backtrace/ || client_settings.backtrace_full?
+      elsif matches_action?('full-backtrace', env) || client_settings.backtrace_full?
         current.full_backtrace = true
         client_settings.backtrace_level = ClientSettings::BACKTRACE_FULL
       elsif client_settings.backtrace_none?
@@ -335,7 +258,7 @@ module Rack
 
       flamegraph = nil
 
-      trace_exceptions = query_string =~ /#{@config.profile_parameter}=trace-exceptions/ && defined? TracePoint
+      trace_exceptions = matches_action?('trace-exceptions', env) && defined? TracePoint
       status, headers, body, exceptions, trace = nil
 
       if trace_exceptions
@@ -359,11 +282,11 @@ module Rack
         # Prevent response body from being compressed
         env['HTTP_ACCEPT_ENCODING'] = 'identity' if config.suppress_encoding
 
-        if query_string =~ /pp=(async-)?flamegraph/ || env['HTTP_REFERER'] =~ /pp=async-flamegraph/
+        if matches_action?('flamegraph', env) || matches_action?('async-flamegraph', env) || env['HTTP_REFERER'] =~ /pp=async-flamegraph/
           if defined?(StackProf) && StackProf.respond_to?(:run)
             # do not sully our profile with mini profiler timings
             current.measure = false
-            match_data      = query_string.match(/flamegraph_sample_rate=([\d\.]+)/)
+            match_data      = action_parameters(env)['flamegraph_sample_rate']
 
             if match_data && !match_data[1].to_f.zero?
               sample_rate = match_data[1].to_f
@@ -371,7 +294,7 @@ module Rack
               sample_rate = config.flamegraph_sample_rate
             end
 
-            mode_match_data = query_string.match(/flamegraph_mode=([a-zA-Z]+)/)
+            mode_match_data = action_parameters(env)['flamegraph_mode']
 
             if mode_match_data && [:cpu, :wall, :object, :custom].include?(mode_match_data[1].to_sym)
               mode = mode_match_data[1].to_sym
@@ -379,11 +302,20 @@ module Rack
               mode = config.flamegraph_mode
             end
 
+            ignore_gc_match_data = action_parameters(env)['flamegraph_ignore_gc']
+
+            if ignore_gc_match_data
+              ignore_gc = ignore_gc_match_data == 'true'
+            else
+              ignore_gc = config.flamegraph_ignore_gc
+            end
+
             flamegraph = StackProf.run(
               mode: mode,
               raw: true,
               aggregate: false,
-              interval: (sample_rate * 1000).to_i
+              interval: (sample_rate * 1000).to_i,
+              ignore_gc: ignore_gc
             ) do
               status, headers, body = @app.call(env)
             end
@@ -397,18 +329,7 @@ module Rack
             )
           end
         elsif path == '/rack-mini-profiler/requests'
-          blank_page_html = <<~HTML
-            <!DOCTYPE html>
-            <html>
-              <head>
-                <title>Rack::MiniProfiler Requests</title>
-              </head>
-              <body>
-              </body>
-            </html>
-          HTML
-
-          status, headers, body = [200, { 'Content-Type' => 'text/html' }, [blank_page_html.dup]]
+          status, headers, body = [200, { 'Content-Type' => 'text/html' }, [blank_page_html]]
         else
           status, headers, body = @app.call(env)
         end
@@ -429,7 +350,7 @@ module Rack
       if trace_exceptions
         body.close if body.respond_to? :close
 
-        query_params = Rack::Utils.parse_nested_query(query_string)
+        query_params = action_parameters(env)
         trace_exceptions_filter = query_params['trace_exceptions_filter']
         if trace_exceptions_filter
           trace_exceptions_regex = Regexp.new(trace_exceptions_filter)
@@ -439,19 +360,19 @@ module Rack
         return client_settings.handle_cookie(dump_exceptions exceptions)
       end
 
-      if query_string =~ /#{@config.profile_parameter}=env/
+      if matches_action?("env", env)
         return tool_disabled_message(client_settings) if !advanced_debugging_enabled?
         body.close if body.respond_to? :close
         return client_settings.handle_cookie(dump_env env)
       end
 
-      if query_string =~ /#{@config.profile_parameter}=analyze-memory/
+      if matches_action?("analyze-memory", env)
         return tool_disabled_message(client_settings) if !advanced_debugging_enabled?
         body.close if body.respond_to? :close
         return client_settings.handle_cookie(analyze_memory)
       end
 
-      if query_string =~ /#{@config.profile_parameter}=help/
+      if matches_action?("help", env)
         body.close if body.respond_to? :close
         return client_settings.handle_cookie(help(client_settings, env))
       end
@@ -460,9 +381,9 @@ module Rack
       page_struct[:user] = user(env)
       page_struct[:root].record_time((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000)
 
-      if flamegraph && query_string =~ /#{@config.profile_parameter}=flamegraph/
+      if flamegraph && matches_action?("flamegraph", env)
         body.close if body.respond_to? :close
-        return client_settings.handle_cookie(self.flamegraph(flamegraph, path))
+        return client_settings.handle_cookie(self.flamegraph(flamegraph, path, env))
       elsif flamegraph # async-flamegraph
         page_struct[:has_flamegraph] = true
         page_struct[:flamegraph] = flamegraph
@@ -485,12 +406,20 @@ module Rack
       end
 
       client_settings.handle_cookie([status, headers, body])
-
     ensure
       # Make sure this always happens
       self.current = nil
     end
 
+    def matches_action?(action, env)
+      env['QUERY_STRING'] =~ /#{@config.profile_parameter}=#{action}/ ||
+        env['HTTP_X_RACK_MINI_PROFILER'] == action
+    end
+
+    def action_parameters(env)
+      query_params = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+    end
+
     def inject_profiler(env, status, headers, body)
       # mini profiler is meddling with stuff, we can not cache cause we will get incorrect data
       # Rack::ETag has already inserted some nonesense in the chain
@@ -663,78 +592,6 @@ module Rack
       [status, headers, [body]]
     end
 
-    def make_link(postfix, env)
-      link = env["PATH_INFO"] + "?" + env["QUERY_STRING"].sub("#{@config.profile_parameter}=help", "#{@config.profile_parameter}=#{postfix}")
-      "#{@config.profile_parameter}=<a href='#{ERB::Util.html_escape(link)}'>#{postfix}</a>"
-    end
-
-    def help(client_settings, env)
-      headers = { 'Content-Type' => 'text/html' }
-      html = <<~HTML
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <title>Rack::MiniProfiler Help</title>
-          </head>
-          <body>
-            <pre style='line-height: 30px; font-size: 16px'>
-              This is the help menu of the <a href='#{Rack::MiniProfiler::SOURCE_CODE_URI}'>rack-mini-profiler</a> gem, append the following to your query string for more options:
-
-              #{make_link "help", env} : display this screen
-              #{make_link "env", env} : display the rack environment
-              #{make_link "skip", env} : skip mini profiler for this request
-              #{make_link "no-backtrace", env} #{"(*) " if client_settings.backtrace_none?}: don't collect stack traces from all the SQL executed (sticky, use #{@config.profile_parameter}=normal-backtrace to enable)
-              #{make_link "normal-backtrace", env} #{"(*) " if client_settings.backtrace_default?}: collect stack traces from all the SQL executed and filter normally
-              #{make_link "full-backtrace", env} #{"(*) " if client_settings.backtrace_full?}: enable full backtraces for SQL executed (use #{@config.profile_parameter}=normal-backtrace to disable)
-              #{make_link "disable", env} : disable profiling for this session
-              #{make_link "enable", env} : enable profiling for this session (if previously disabled)
-              #{make_link "profile-gc", env} : perform gc profiling on this request, analyzes ObjectSpace generated by request
-              #{make_link "profile-memory", env} : requires the memory_profiler gem, new location based report
-              #{make_link "flamegraph", env} : a graph representing sampled activity (requires the stackprof gem).
-              #{make_link "async-flamegraph", env} : store flamegraph data for this page and all its AJAX requests. Flamegraph links will be available in the mini-profiler UI (requires the stackprof gem).
-              #{make_link "flamegraph&flamegraph_sample_rate=1", env}: creates a flamegraph with the specified sample rate (in ms). Overrides value set in config
-              #{make_link "flamegraph&flamegraph_mode=cpu", env}: creates a flamegraph with the specified mode (one of cpu, wall, object, or custom). Overrides value set in config
-              #{make_link "flamegraph_embed", env} : a graph representing sampled activity (requires the stackprof gem), embedded resources for use on an intranet.
-              #{make_link "trace-exceptions", env} : will return all the spots where your application raises exceptions
-              #{make_link "analyze-memory", env} : will perform basic memory analysis of heap
-            </pre>
-          </body>
-        </html>
-      HTML
-
-      [200, headers, [html]]
-    end
-
-    def flamegraph(graph, path)
-      headers = { 'Content-Type' => 'text/html' }
-      html = <<~HTML
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <title>Rack::MiniProfiler Flamegraph</title>
-            <style>
-              body { margin: 0; height: 100vh; }
-              #speedscope-iframe { width: 100%; height: 100%; border: none; }
-            </style>
-          </head>
-          <body>
-            <script type="text/javascript">
-              var graph = #{JSON.generate(graph)};
-              var json = JSON.stringify(graph);
-              var blob = new Blob([json], { type: 'text/plain' });
-              var objUrl = encodeURIComponent(URL.createObjectURL(blob));
-              var iframe = document.createElement('IFRAME');
-              iframe.setAttribute('id', 'speedscope-iframe');
-              document.body.appendChild(iframe);
-              var iframeUrl = '#{@config.base_url_path}speedscope/index.html#profileURL=' + objUrl + '&title=' + 'Flamegraph for #{CGI.escape(path)}';
-              iframe.setAttribute('src', iframeUrl);
-            </script>
-          </body>
-        </html>
-      HTML
-      [200, headers, [html]]
-    end
-
     def ids(env)
       all = ([current.page_struct[:id]] + (@storage.get_unviewed_ids(user(env)) || [])).uniq
       if all.size > @config.max_traces_to_show
@@ -748,69 +605,6 @@ module Rack
       ids(env).join(",")
     end
 
-    # get_profile_script returns script to be injected inside current html page
-    # By default, profile_script is appended to the end of all html requests automatically.
-    # Calling get_profile_script cancels automatic append for the current page
-    # Use it when:
-    # * you have disabled auto append behaviour throught :auto_inject => false flag
-    # * you do not want script to be automatically appended for the current page. You can also call cancel_auto_inject
-    def get_profile_script(env)
-      path = "#{env['RACK_MINI_PROFILER_ORIGINAL_SCRIPT_NAME']}#{@config.base_url_path}"
-      version = MiniProfiler::ASSET_VERSION
-      if @config.assets_url
-        url = @config.assets_url.call('rack-mini-profiler.js', version, env)
-        css_url = @config.assets_url.call('rack-mini-profiler.css', version, env)
-      end
-
-      url = "#{path}includes.js?v=#{version}" if !url
-      css_url = "#{path}includes.css?v=#{version}" if !css_url
-
-      content_security_policy_nonce = @config.content_security_policy_nonce ||
-                                      env["action_dispatch.content_security_policy_nonce"] ||
-                                      env["secure_headers_content_security_policy_nonce"]
-
-      settings = {
-       path: path,
-       url: url,
-       cssUrl: css_url,
-       version: version,
-       verticalPosition: @config.vertical_position,
-       horizontalPosition: @config.horizontal_position,
-       showTrivial: @config.show_trivial,
-       showChildren: @config.show_children,
-       maxTracesToShow: @config.max_traces_to_show,
-       showControls: @config.show_controls,
-       showTotalSqlCount: @config.show_total_sql_count,
-       authorized: true,
-       toggleShortcut: @config.toggle_shortcut,
-       startHidden: @config.start_hidden,
-       collapseResults: @config.collapse_results,
-       htmlContainer: @config.html_container,
-       hiddenCustomFields: @config.snapshot_hidden_custom_fields.join(','),
-       cspNonce: content_security_policy_nonce,
-       hotwireTurboDriveSupport: @config.enable_hotwire_turbo_drive_support,
-      }
-
-      if current && current.page_struct
-        settings[:ids]       = ids_comma_separated(env)
-        settings[:currentId] = current.page_struct[:id]
-      else
-        settings[:ids]       = []
-        settings[:currentId] = ""
-      end
-
-      # TODO : cache this snippet
-      script = ::File.read(::File.expand_path('html/profile_handler.js', ::File.dirname(__FILE__)))
-      # replace the variables
-      settings.each do |k, v|
-        regex = Regexp.new("\\{#{k.to_s}\\}")
-        script.gsub!(regex, v.to_s)
-      end
-
-      current.inject_js = false if current
-      script
-    end
-
     # cancels automatic injection of profile script for the current page
     def cancel_auto_inject(env)
       current.inject_js = false
@@ -822,74 +616,6 @@ module Rack
 
     private
 
-    def handle_snapshots_request(env)
-      self.current = nil
-      MiniProfiler.authorize_request
-      status = 200
-      headers = { 'Content-Type' => 'text/html' }
-      qp = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
-      if group_name = qp["group_name"]
-        list = @storage.snapshots_group(group_name)
-        list.each do |snapshot|
-          snapshot[:url] = url_for_snapshot(snapshot[:id], group_name)
-        end
-        data = {
-          group_name: group_name,
-          list: list
-        }
-      else
-        list = @storage.snapshots_overview
-        list.each do |group|
-          group[:url] = url_for_snapshots_group(group[:name])
-        end
-        data = {
-          page: "overview",
-          list: list
-        }
-      end
-      data_html = <<~HTML
-        <div style="display: none;" id="snapshots-data">
-        #{data.to_json}
-        </div>
-      HTML
-      response = Rack::Response.new([], status, headers)
-
-      response.write <<~HTML
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <title>Rack::MiniProfiler Snapshots</title>
-          </head>
-          <body class="mp-snapshots">
-      HTML
-      response.write(data_html)
-      script = self.get_profile_script(env)
-      response.write(script)
-      response.write <<~HTML
-          </body>
-        </html>
-      HTML
-      response.finish
-    end
-
-    def serve_flamegraph(env)
-      request     = Rack::Request.new(env)
-      id          = request.params['id']
-      page_struct = @storage.load(id)
-
-      if !page_struct
-        id        = ERB::Util.html_escape(id)
-        user_info = ERB::Util.html_escape(user(env))
-        return [404, {}, ["Request not found: #{id} - user #{user_info}"]]
-      end
-
-      if !page_struct[:flamegraph]
-        return [404, {}, ["No flamegraph available for #{ERB::Util.html_escape(id)}"]]
-      end
-
-      self.flamegraph(page_struct[:flamegraph], page_struct[:request_path])
-    end
-
     def rails_route_from_path(path, method)
       if defined?(Rails) && defined?(ActionController::RoutingError)
         hash = Rails.application.routes.recognize_path(path, method: method)
@@ -901,16 +627,6 @@ module Rack
       nil
     end
 
-    def url_for_snapshots_group(group_name)
-      qs = Rack::Utils.build_query({ group_name: group_name })
-      "/#{@config.base_url_path.gsub('/', '')}/snapshots?#{qs}"
-    end
-
-    def url_for_snapshot(id, group_name)
-      qs = Rack::Utils.build_query({ id: id, group: group_name })
-      "/#{@config.base_url_path.gsub('/', '')}/results?#{qs}"
-    end
-
     def take_snapshot?(path)
       @config.snapshot_every_n_requests > 0 &&
       !path.start_with?(@config.base_url_path) &&

data/lib/mini_profiler_rails/railtie.rb

@@ -75,7 +75,8 @@ module Rack::MiniProfilerRails
         next if !should_measure?
 
         current = Rack::MiniProfiler.current
-        description = "Executing action: #{payload[:action]}"
+        controller_name = payload[:controller].sub(/Controller\z/, '').downcase
+        description = "Executing: #{controller_name}##{payload[:action]}"
         Thread.current[get_key(payload)] = current.current_timer
         Rack::MiniProfiler.current.current_timer = current.current_timer.add_child(description)
       end
@@ -113,6 +114,16 @@ module Rack::MiniProfilerRails
             Rack::MiniProfiler.binds_to_params(payload[:binds])
           )
         end
+
+        subscribe("instantiation.active_record") do |name, start, finish, id, payload|
+          next if !should_measure?
+
+          Rack::MiniProfiler.report_reader_duration(
+            (finish - start) * 1000,
+            payload[:record_count],
+            payload[:class_name]
+          )
+        end
       end
     end
     @already_initialized = true

data/lib/mini_profiler_rails/railtie_methods.rb

@@ -52,7 +52,7 @@ module Rack::MiniProfilerRailsMethods
   end
 
   def get_webpacker_assets_path
-    if defined?(Webpacker) && Webpacker.config.config_path.exist?
+    if defined?(Webpacker) && Webpacker.try(:config)&.config_path&.exist?
       Webpacker.config.public_output_path.to_s.gsub(Webpacker.config.public_path.to_s, "")
     end
   end

data/lib/patches/sql_patches.rb

@@ -30,8 +30,8 @@ class SqlPatches
   def self.sql_patches
     patches = []
 
-    patches << 'mysql2' if defined?(Mysql2::Client) && Mysql2::Client.class == Class
-    patches << 'pg' if defined?(PG::Result) && PG::Result.class == Class
+    patches << 'mysql2' if defined?(Mysql2::Client) && Mysql2::Client.class == Class && patch_rails?
+    patches << 'pg' if defined?(PG::Result) && PG::Result.class == Class && patch_rails?
     patches << 'oracle_enhanced' if defined?(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter) && ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class == Class &&
                                     SqlPatches.correct_version?('~> 1.5.0', ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter) &&
                                     patch_rails?

data/rack-mini-profiler.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
     "CHANGELOG.md"
   ]
   s.add_runtime_dependency 'rack', '>= 1.2.0'
-  s.required_ruby_version = '>= 2.6.0'
+  s.required_ruby_version = '>= 2.7.0'
 
   s.metadata = {
     'source_code_uri' => Rack::MiniProfiler::SOURCE_CODE_URI,