rack-mini-profiler 3.3.0 → 4.0.0

data/lib/mini_profiler/profiling_methods.rb

@@ -4,7 +4,7 @@ module Rack
   class MiniProfiler
     module ProfilingMethods
 
-      def record_sql(query, elapsed_ms, params = nil)
+      def record_sql(query, elapsed_ms, params = nil, cached = nil)
         return unless current && current.current_timer
         c = current
         c.current_timer.add_sql(
@@ -13,7 +13,8 @@ module Rack
           c.page_struct,
           redact_sql_queries? ? nil : params,
           c.skip_backtrace,
-          c.full_backtrace
+          c.full_backtrace,
+          cached
         )
       end
 

data/lib/mini_profiler/snapshots_transporter.rb

@@ -9,9 +9,11 @@ class ::Rack::MiniProfiler::SnapshotsTransporter
     def transported_snapshots_count
       @@transported_snapshots_count
     end
+
     def successful_http_requests_count
       @@successful_http_requests_count
     end
+
     def failed_http_requests_count
       @@failed_http_requests_count
     end

data/lib/mini_profiler/storage/file_store.rb

@@ -91,8 +91,6 @@ module Rack
         end
 
         at_exit { t[:should_exit] = true }
-
-        t
       end
 
       def save(page_struct)

data/lib/mini_profiler/storage/memcache_store.rb

@@ -42,7 +42,7 @@ module Rack
         @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
         MAX_RETRIES.times do
           break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
-            ids << id unless ids.include?(id)
+            ids << id if !ids.include?(id)
             ids
           end
         end

data/lib/mini_profiler/timer_struct/base.rb

@@ -22,7 +22,6 @@ module Rack
 
         def []=(name, val)
           attributes[name] = val
-          self
         end
 
         def to_json(*a)

data/lib/mini_profiler/timer_struct/page.rb

@@ -59,13 +59,12 @@ module Rack
 
         def initialize(env)
           timer_id     = MiniProfiler.generate_id
-          page_name    = env['PATH_INFO']
           started_at   = (Time.now.to_f * 1000).to_i
           started      = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i
           machine_name = env['SERVER_NAME']
           super(
             id: timer_id,
-            name: page_name,
+            name: page_name(env),
             started: started,
             started_at: started_at,
             machine_name: machine_name,
@@ -79,6 +78,7 @@ module Rack
             trivial_duration_threshold_milliseconds: 2,
             head: nil,
             sql_count: 0,
+            cached_sql_count: 0,
             duration_milliseconds_in_sql: 0,
             has_sql_timings: true,
             has_duplicate_sql_timings: false,
@@ -93,7 +93,7 @@ module Rack
           )
           self[:request_method] = env['REQUEST_METHOD']
           self[:request_path] = env['PATH_INFO']
-          name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+          name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{page_name(env)}"
           self[:root] = TimerStruct::Request.createRoot(name, self)
         end
 
@@ -101,6 +101,14 @@ module Rack
           @attributes[:name]
         end
 
+        def page_name(env)
+          if env['QUERY_STRING'] && env['QUERY_STRING'] != ""
+            env['PATH_INFO'] + "?" + env['QUERY_STRING']
+          else
+            env['PATH_INFO']
+          end
+        end
+
         def duration_ms
           @attributes[:root][:duration_milliseconds]
         end

data/lib/mini_profiler/timer_struct/request.rb

@@ -101,14 +101,15 @@ module Rack
           end
         end
 
-        def add_sql(query, elapsed_ms, page, params = nil, skip_backtrace = false, full_backtrace = false)
-          TimerStruct::Sql.new(query, elapsed_ms, page, self, params, skip_backtrace, full_backtrace).tap do |timer|
+        def add_sql(query, elapsed_ms, page, params = nil, skip_backtrace = false, full_backtrace = false, cached = false)
+          TimerStruct::Sql.new(query, elapsed_ms, page, self, params, skip_backtrace, full_backtrace, cached).tap do |timer|
             self[:sql_timings].push(timer)
             timer[:parent_timing_id] = self[:id]
             self[:has_sql_timings]   = true
             self[:sql_timings_duration_milliseconds] += elapsed_ms
             page[:duration_milliseconds_in_sql]      += elapsed_ms
             page[:sql_count] += 1
+            page[:cached_sql_count] += 1 if cached
           end
         end
 

data/lib/mini_profiler/timer_struct/sql.rb

@@ -10,7 +10,7 @@ module Rack
       class Sql < TimerStruct::Base
         attr_accessor :parent
 
-        def initialize(query, duration_ms, page, parent, params = nil, skip_backtrace = false, full_backtrace = false)
+        def initialize(query, duration_ms, page, parent, params = nil, skip_backtrace = false, full_backtrace = false, cached = false)
 
           stack_trace = nil
           unless skip_backtrace || duration_ms < Rack::MiniProfiler.config.backtrace_threshold_ms
@@ -46,7 +46,10 @@ module Rack
             duration_milliseconds: duration_ms,
             first_fetch_duration_milliseconds: duration_ms,
             parameters: query ? trim_binds(params) : nil,
+            row_count: 0,
+            class_name: nil,
             parent_timing_id: nil,
+            cached: cached,
             is_duplicate: false
           )
         end

data/lib/mini_profiler/version.rb

@@ -2,7 +2,7 @@
 
 module Rack
   class MiniProfiler
-    VERSION = '3.3.0'
-    SOURCE_CODE_URI = 'https://github.com/MiniProfiler/rack-mini-profiler'
+    VERSION = "4.0.0"
+    SOURCE_CODE_URI = "https://github.com/MiniProfiler/rack-mini-profiler"
   end
 end

data/lib/mini_profiler/views.rb

@@ -28,7 +28,7 @@ module Rack
       # 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)
+      def get_profile_script(env, response_headers = {})
         path = public_base_path(env)
         version = MiniProfiler::ASSET_VERSION
         if @config.assets_url
@@ -39,7 +39,12 @@ module Rack
         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 ||
+        configured_nonce = @config.content_security_policy_nonce
+        if configured_nonce && !configured_nonce.is_a?(String)
+          configured_nonce = configured_nonce.call(env, response_headers)
+        end
+
+        content_security_policy_nonce = configured_nonce ||
                                         env["action_dispatch.content_security_policy_nonce"] ||
                                         env["secure_headers_content_security_policy_nonce"]
 
@@ -77,7 +82,7 @@ module Rack
         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}\\}")
+          regex = Regexp.new("\\{#{k}\\}")
           script.gsub!(regex, v.to_s)
         end
 
@@ -105,7 +110,7 @@ module Rack
       end
 
       def flamegraph(graph, path, env)
-        headers = { 'Content-Type' => 'text/html' }
+        headers = { 'content-type' => 'text/html' }
         iframe_src = "#{public_base_path(env)}speedscope/index.html"
         html = <<~HTML
           <!DOCTYPE html>
@@ -136,7 +141,7 @@ module Rack
       end
 
       def help(client_settings, env)
-        headers = { 'Content-Type' => 'text/html' }
+        headers = { 'content-type' => 'text/html' }
         html = <<~HTML
           <!DOCTYPE html>
           <html>

data/lib/mini_profiler.rb

@@ -296,8 +296,8 @@ module Rack
 
             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
+            if mode_match_data && [:cpu, :wall, :object, :custom].include?(mode_match_data.to_sym)
+              mode = mode_match_data.to_sym
             else
               mode = config.flamegraph_mode
             end
@@ -329,7 +329,7 @@ module Rack
             )
           end
         elsif path == '/rack-mini-profiler/requests'
-          status, headers, body = [200, { 'Content-Type' => 'text/html' }, [blank_page_html]]
+          status, headers, body = [200, { 'Content-Type' => 'text/html' }, [blank_page_html.dup]] # important to dup here!
         else
           status, headers, body = @app.call(env)
         end
@@ -417,7 +417,7 @@ module Rack
     end
 
     def action_parameters(env)
-      query_params = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+      Rack::Utils.parse_nested_query(env['QUERY_STRING'])
     end
 
     def inject_profiler(env, status, headers, body)
@@ -436,11 +436,12 @@ module Rack
       # inject header
       if headers.is_a? Hash
         headers['X-MiniProfiler-Ids'] = ids_comma_separated(env)
+        headers['X-MiniProfiler-Flamegraph-Path'] = flamegraph_path(env) if current.page_struct[:has_flamegraph]
       end
 
       if current.inject_js && content_type =~ /text\/html/
         response = Rack::Response.new([], status, headers)
-        script   = self.get_profile_script(env)
+        script   = self.get_profile_script(env, headers)
 
         if String === body
           response.write inject(body, script)
@@ -605,6 +606,10 @@ module Rack
       ids(env).join(",")
     end
 
+    def flamegraph_path(env)
+      @config.base_url_path + 'flamegraph?id=' + current.page_struct[:id]
+    end
+
     # cancels automatic injection of profile script for the current page
     def cancel_auto_inject(env)
       current.inject_js = false

data/lib/mini_profiler_rails/railtie.rb

@@ -111,7 +111,8 @@ module Rack::MiniProfilerRails
           Rack::MiniProfiler.record_sql(
             payload[:sql],
             (finish - start) * 1000,
-            Rack::MiniProfiler.binds_to_params(payload[:binds])
+            Rack::MiniProfiler.binds_to_params(payload[:binds]),
+            payload[:cached]
           )
         end
 

data/lib/patches/db/pg/alias_method.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+class PG::Result
+  alias_method :each_without_profiling, :each
+  alias_method :values_without_profiling, :values
+
+  def values(*args, &blk)
+    return values_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
+    mp_report_sql do
+      values_without_profiling(*args , &blk)
+    end
+  end
+
+  def each(*args, &blk)
+    return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
+    mp_report_sql do
+      each_without_profiling(*args, &blk)
+    end
+  end
+
+  def mp_report_sql(&block)
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = yield
+    elapsed_time = SqlPatches.elapsed_time(start)
+    @miniprofiler_sql_id.report_reader_duration(elapsed_time)
+    result
+  end
+end
+
+class PG::Connection
+  alias_method :exec_without_profiling, :exec
+  alias_method :async_exec_without_profiling, :async_exec
+  alias_method :exec_prepared_without_profiling, :exec_prepared
+  alias_method :send_query_prepared_without_profiling, :send_query_prepared
+  alias_method :prepare_without_profiling, :prepare
+
+  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+    alias_method :exec_params_without_profiling, :exec_params
+  end
+
+  def prepare(*args, &blk)
+    # we have no choice but to do this here,
+    # if we do the check for profiling first, our cache may miss critical stuff
+
+    @prepare_map ||= {}
+    @prepare_map[args[0]] = args[1]
+    # dont leak more than 10k ever
+    @prepare_map = {} if @prepare_map.length > 1000
+
+    return prepare_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+    prepare_without_profiling(*args, &blk)
+  end
+
+  def exec(*args, &blk)
+    return exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = exec_without_profiling(*args, &blk)
+    elapsed_time = SqlPatches.elapsed_time(start)
+    record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+    result
+  end
+
+  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+    def exec_params(*args, &blk)
+      return exec_params_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = exec_params_without_profiling(*args, &blk)
+      elapsed_time = SqlPatches.elapsed_time(start)
+      record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+  end
+
+  def exec_prepared(*args, &blk)
+    return exec_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = exec_prepared_without_profiling(*args, &blk)
+    elapsed_time = SqlPatches.elapsed_time(start)
+    mapped       = args[0]
+    mapped       = @prepare_map[mapped] || args[0] if @prepare_map
+    record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+    result
+  end
+
+  def send_query_prepared(*args, &blk)
+    return send_query_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = send_query_prepared_without_profiling(*args, &blk)
+    elapsed_time = SqlPatches.elapsed_time(start)
+    mapped       = args[0]
+    mapped       = @prepare_map[mapped] || args[0] if @prepare_map
+    record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+    result
+  end
+
+  def async_exec(*args, &blk)
+    return async_exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = exec_without_profiling(*args, &blk)
+    elapsed_time = SqlPatches.elapsed_time(start)
+    record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+    result
+  end
+
+  alias_method :query, :exec
+end

data/lib/patches/db/pg/prepend.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+class PG::Result
+  module MiniProfiler
+    def values(*args, &blk)
+      return super unless defined?(@miniprofiler_sql_id)
+      mp_report_sql do
+        super
+      end
+    end
+
+    def each(*args, &blk)
+      return super unless defined?(@miniprofiler_sql_id)
+      mp_report_sql do
+        super
+      end
+    end
+
+    def mp_report_sql(&block)
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = yield
+      elapsed_time = SqlPatches.elapsed_time(start)
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
+      result
+    end
+  end
+
+  prepend MiniProfiler
+end
+
+class PG::Connection
+  module MiniProfiler
+    def prepare(*args, &blk)
+      # we have no choice but to do this here,
+      # if we do the check for profiling first, our cache may miss critical stuff
+
+      @prepare_map ||= {}
+      @prepare_map[args[0]] = args[1]
+      # dont leak more than 10k ever
+      @prepare_map = {} if @prepare_map.length > 1000
+
+      return super unless SqlPatches.should_measure?
+      super
+    end
+
+    def exec(*args, &blk)
+      return super unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = super
+      elapsed_time = SqlPatches.elapsed_time(start)
+      record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+
+    if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+      def exec_params(*args, &blk)
+        return super unless SqlPatches.should_measure?
+
+        start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result       = super
+        elapsed_time = SqlPatches.elapsed_time(start)
+        record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+        result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+        result
+      end
+    end
+
+    def exec_prepared(*args, &blk)
+      return super unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = super
+      elapsed_time = SqlPatches.elapsed_time(start)
+      mapped       = args[0]
+      mapped       = @prepare_map[mapped] || args[0] if @prepare_map
+      record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+
+    def send_query_prepared(*args, &blk)
+      return super unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = super
+      elapsed_time = SqlPatches.elapsed_time(start)
+      mapped       = args[0]
+      mapped       = @prepare_map[mapped] || args[0] if @prepare_map
+      record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+
+    def async_exec(*args, &blk)
+      return super unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = super
+      elapsed_time = SqlPatches.elapsed_time(start)
+      record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+  end
+
+  prepend MiniProfiler
+  alias_method :query, :exec
+end

data/lib/patches/db/pg.rb

@@ -1,122 +1,7 @@
 # frozen_string_literal: true
 
-# PG patches, keep in mind exec and async_exec have a exec{|r| } semantics that is yet to be implemented
-class PG::Result
-  alias_method :each_without_profiling, :each
-  alias_method :values_without_profiling, :values
-
-  def values(*args, &blk)
-    return values_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
-    mp_report_sql do
-      values_without_profiling(*args , &blk)
-    end
-  end
-
-  def each(*args, &blk)
-    return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
-    mp_report_sql do
-      each_without_profiling(*args, &blk)
-    end
-  end
-
-  def mp_report_sql(&block)
-    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = yield
-    elapsed_time = SqlPatches.elapsed_time(start)
-    @miniprofiler_sql_id.report_reader_duration(elapsed_time)
-    result
-  end
-end
-
-class PG::Connection
-  alias_method :exec_without_profiling, :exec
-  alias_method :async_exec_without_profiling, :async_exec
-  alias_method :exec_prepared_without_profiling, :exec_prepared
-  alias_method :send_query_prepared_without_profiling, :send_query_prepared
-  alias_method :prepare_without_profiling, :prepare
-
-  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
-    alias_method :exec_params_without_profiling, :exec_params
-  end
-
-  def prepare(*args, &blk)
-    # we have no choice but to do this here,
-    # if we do the check for profiling first, our cache may miss critical stuff
-
-    @prepare_map ||= {}
-    @prepare_map[args[0]] = args[1]
-    # dont leak more than 10k ever
-    @prepare_map = {} if @prepare_map.length > 1000
-
-    return prepare_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-    prepare_without_profiling(*args, &blk)
-  end
-
-  def exec(*args, &blk)
-    return exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-
-    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = exec_without_profiling(*args, &blk)
-    elapsed_time = SqlPatches.elapsed_time(start)
-    record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
-    result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-    result
-  end
-
-  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
-    def exec_params(*args, &blk)
-      return exec_params_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-
-      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      result       = exec_params_without_profiling(*args, &blk)
-      elapsed_time = SqlPatches.elapsed_time(start)
-      record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
-      result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-      result
-    end
-  end
-
-  def exec_prepared(*args, &blk)
-    return exec_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-
-    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = exec_prepared_without_profiling(*args, &blk)
-    elapsed_time = SqlPatches.elapsed_time(start)
-    mapped       = args[0]
-    mapped       = @prepare_map[mapped] || args[0] if @prepare_map
-    record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
-    result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-    result
-  end
-
-  def send_query_prepared(*args, &blk)
-    return send_query_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-
-    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = send_query_prepared_without_profiling(*args, &blk)
-    elapsed_time = SqlPatches.elapsed_time(start)
-    mapped       = args[0]
-    mapped       = @prepare_map[mapped] || args[0] if @prepare_map
-    record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
-    result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-    result
-  end
-
-  def async_exec(*args, &blk)
-    return async_exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-
-    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = exec_without_profiling(*args, &blk)
-    elapsed_time = SqlPatches.elapsed_time(start)
-    record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
-    result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-    result
-  end
-
-  alias_method :query, :exec
+if defined?(Rack::MINI_PROFILER_PREPEND_PG_PATCH)
+  require "patches/db/pg/prepend"
+else
+  require "patches/db/pg/alias_method"
 end

data/lib/prepend_pg_patch.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rack
+  MINI_PROFILER_PREPEND_PG_PATCH = true
+end

data/rack-mini-profiler.gemspec

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(lib) if !$LOAD_PATH.include?(lib)
 require 'mini_profiler/version'
 
 Gem::Specification.new do |s|
@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
     "CHANGELOG.md"
   ]
   s.add_runtime_dependency 'rack', '>= 1.2.0'
-  s.required_ruby_version = '>= 2.7.0'
+  s.required_ruby_version = '>= 3.1.0'
 
   s.metadata = {
     'source_code_uri' => Rack::MiniProfiler::SOURCE_CODE_URI,
@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rubocop-discourse'
   s.add_development_dependency 'listen'
   s.add_development_dependency 'webpacker'
-  s.add_development_dependency 'rails', '~> 6.0'
+  s.add_development_dependency 'rails', '>= 7.1'
   s.add_development_dependency 'webmock', '3.9.1'
   s.add_development_dependency 'rubyzip'