rack-mini-profiler 0.10.6 → 2.3.0

data/lib/mini_profiler/profiler.rb

@@ -1,8 +1,17 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
 module Rack
   class MiniProfiler
     class << self
 
       include Rack::MiniProfiler::ProfilingMethods
+      attr_accessor :subscribe_sql_active_record
+
+      def patch_rails?
+        !!defined?(Rack::MINI_PROFILER_ENABLE_RAILS_PATCHES)
+      end
 
       def generate_id
         rand(36**20).to_s(36)
@@ -31,15 +40,27 @@ module Rack
 
       def current=(c)
         # we use TLS cause we need access to this from sql blocks and code blocks that have no access to env
+        Thread.current[:mini_profiler_snapshot_custom_fields] = nil
+        Thread.current[:mp_ongoing_snapshot] = nil
         Thread.current[:mini_profiler_private] = c
       end
 
+      def add_snapshot_custom_field(key, value)
+        thread_var_key = :mini_profiler_snapshot_custom_fields
+        Thread.current[thread_var_key] ||= {}
+        Thread.current[thread_var_key][key] = value
+      end
+
+      def get_snapshot_custom_fields
+        Thread.current[:mini_profiler_snapshot_custom_fields]
+      end
+
       # discard existing results, don't track this request
       def discard_results
         self.current.discard = true if current
       end
 
-      def create_current(env={}, options={})
+      def create_current(env = {}, options = {})
         # profiling the request
         context               = Context.new
         context.inject_js     = config.auto_inject && (!env['HTTP_X_REQUESTED_WITH'].eql? 'XMLHttpRequest')
@@ -60,6 +81,32 @@ module Rack
         Thread.current[:mp_authorized]
       end
 
+      def advanced_tools_message
+        <<~TEXT
+          This feature is disabled by default, to enable set the enable_advanced_debugging_tools option to true in Mini Profiler config.
+        TEXT
+      end
+
+      def binds_to_params(binds)
+        return if binds.nil? || config.max_sql_param_length == 0
+        # map ActiveRecord::Relation::QueryAttribute to [name, value]
+        params = binds.map { |c| c.kind_of?(Array) ? [c.first, c.last] : [c.name, c.value] }
+        if (skip = config.skip_sql_param_names)
+          params.map { |(n, v)| n =~ skip ? [n, nil] : [n, v] }
+        else
+          params
+        end
+      end
+
+      def snapshots_transporter?
+        !!config.snapshots_transport_destination_url &&
+        !!config.snapshots_transport_auth_key
+      end
+
+      def redact_sql_queries?
+        Thread.current[:mp_ongoing_snapshot] == true &&
+        Rack::MiniProfiler.config.snapshots_redact_sql_queries
+      end
     end
 
     #
@@ -69,7 +116,7 @@ module Rack
       MiniProfiler.config.merge!(config)
       @config = MiniProfiler.config
       @app    = app
-      @config.base_url_path << "/" unless @config.base_url_path.end_with? "/"
+      @config.base_url_path += "/" unless @config.base_url_path.end_with? "/"
       unless @config.storage_instance
         @config.storage_instance = @config.storage.new(@config.storage_options)
       end
@@ -82,15 +129,24 @@ module Rack
 
     def serve_results(env)
       request     = Rack::Request.new(env)
-      id          = request[:id]
-      page_struct = @storage.load(id)
-      unless page_struct
+      id          = request.params['id']
+      is_snapshot = request.params['snapshot']
+      is_snapshot = [true, "true"].include?(is_snapshot)
+      if is_snapshot
+        page_struct = @storage.load_snapshot(id)
+      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(request['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
-      unless page_struct[:has_user_viewed]
+      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)
@@ -100,21 +156,22 @@ module Rack
       # 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]]
+        [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]]
+        [200, { 'Content-Type' => 'text/html' }, [html]]
       end
     end
 
     def generate_html(page_struct, env, result_json = page_struct.to_json)
-      path = "#{env['RACK_MINI_PROFILER_ORIGINAL_SCRIPT_NAME']}#{@config.base_url_path}"
-      version = MiniProfiler::ASSET_VERSION
-      json = result_json
-      includes = get_profile_script(env)
-      name = page_struct[:name]
-      duration = page_struct.duration_ms.round(1).to_s
+      # 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
@@ -124,15 +181,15 @@ module Rack
       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')
 
       resources_env = env.dup
       resources_env['PATH_INFO'] = file_name
 
-      rack_file = Rack::File.new(MiniProfiler.resources_root, {'Cache-Control' => 'max-age:86400'})
+      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
@@ -141,15 +198,20 @@ module Rack
       MiniProfiler.current = c
     end
 
-
     def config
       @config
     end
 
+    def advanced_debugging_enabled?
+      config.enable_advanced_debugging_tools
+    end
 
-    def call(env)
+    def tool_disabled_message(client_settings)
+      client_settings.handle_cookie(text_result(Rack::MiniProfiler.advanced_tools_message))
+    end
 
-      start = Time.now
+    def call(env)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       client_settings = ClientSettings.new(env, @storage, start)
       MiniProfiler.deauthorize_request if @config.authorization_mode == :whitelist
 
@@ -160,15 +222,31 @@ module Rack
       # 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.pre_authorize_cb && !@config.pre_authorize_cb.call(env)) ||
-                (@config.skip_paths && @config.skip_paths.any?{ |p| path.start_with?(p) }) ||
-                query_string =~ /pp=skip/
+      skip_it = /pp=skip/.match?(query_string) || (
+        @config.skip_paths &&
+        @config.skip_paths.any? do |p|
+          if p.instance_of?(String)
+            path.start_with?(p)
+          elsif p.instance_of?(Regexp)
+            p.match?(path)
+          end
+        end
+      )
+      if skip_it
+        return client_settings.handle_cookie(@app.call(env))
+      end
+
+      skip_it = (@config.pre_authorize_cb && !@config.pre_authorize_cb.call(env))
 
       if skip_it || (
         @config.authorization_mode == :whitelist &&
         !client_settings.has_valid_cookie?
       )
-        return client_settings.handle_cookie(@app.call(env))
+        if take_snapshot?(path)
+          return client_settings.handle_cookie(take_snapshot(env, start))
+        else
+          return client_settings.handle_cookie(@app.call(env))
+        end
       end
 
       # handle all /mini-profiler requests here
@@ -186,30 +264,32 @@ module Rack
       end
 
       if skip_it || !config.enabled
-        status,headers,body = @app.call(env)
+        status, headers, body = @app.call(env)
         client_settings.disable_profiling = true
-        return client_settings.handle_cookie([status,headers,body])
+        return client_settings.handle_cookie([status, headers, body])
       else
         client_settings.disable_profiling = false
       end
 
       # profile gc
       if query_string =~ /pp=profile-gc/
+        return tool_disabled_message(client_settings) if !advanced_debugging_enabled?
         current.measure = false if current
         return client_settings.handle_cookie(Rack::MiniProfiler::GCProfiler.new.profile_gc(@app, env))
       end
 
       # profile memory
       if query_string =~ /pp=profile-memory/
+        return tool_disabled_message(client_settings) if !advanced_debugging_enabled?
         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'],
+          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')
+        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 = @app.call(env)
           body.close if body.respond_to? :close
         end
         report.pretty_print(result)
@@ -233,8 +313,7 @@ module Rack
       flamegraph = nil
 
       trace_exceptions = query_string =~ /pp=trace-exceptions/ && defined? TracePoint
-      status, headers, body, exceptions,trace = nil
-
+      status, headers, body, exceptions, trace = nil
 
       if trace_exceptions
         exceptions = []
@@ -258,28 +337,40 @@ module Rack
         env['HTTP_ACCEPT_ENCODING'] = 'identity' if config.suppress_encoding
 
         if query_string =~ /pp=flamegraph/
-          unless defined?(Flamegraph) && Flamegraph.respond_to?(:generate)
+          unless defined?(StackProf) && StackProf.respond_to?(:run)
 
-            flamegraph = "Please install the flamegraph gem and require it: add gem 'flamegraph' to your Gemfile"
-            status,headers,body = @app.call(env)
+            flamegraph = "Please install the stackprof gem and require it: add gem 'stackprof' to your Gemfile"
+            status, headers, body = @app.call(env)
           else
             # do not sully our profile with mini profiler timings
             current.measure = false
             match_data      = query_string.match(/flamegraph_sample_rate=([\d\.]+)/)
 
-            mode = query_string =~ /mode=c/ ? :c : :ruby
-
             if match_data && !match_data[1].to_f.zero?
               sample_rate = match_data[1].to_f
             else
               sample_rate = config.flamegraph_sample_rate
             end
-            flamegraph = Flamegraph.generate(nil, :fidelity => sample_rate, :embed_resources => query_string =~ /embed/, :mode => mode) do
-              status,headers,body = @app.call(env)
+            flamegraph = StackProf.run(
+              mode: :wall,
+              raw: true,
+              aggregate: false,
+              interval: (sample_rate * 1000).to_i
+            ) do
+              status, headers, body = @app.call(env)
             end
           end
+        elsif path == '/rack-mini-profiler/requests'
+          blank_page_html = <<~HTML
+            <html>
+              <head></head>
+              <body></body>
+            </html>
+          HTML
+
+          status, headers, body = [200, { 'Content-Type' => 'text/html' }, [blank_page_html.dup]]
         else
-          status,headers,body = @app.call(env)
+          status, headers, body = @app.call(env)
         end
       ensure
         trace.disable if trace
@@ -292,7 +383,7 @@ module Rack
         skip_it = true
       end
 
-      return client_settings.handle_cookie([status,headers,body]) if skip_it
+      return client_settings.handle_cookie([status, headers, body]) if skip_it
 
       # we must do this here, otherwise current[:discard] is not being properly treated
       if trace_exceptions
@@ -308,12 +399,14 @@ module Rack
         return client_settings.handle_cookie(dump_exceptions exceptions)
       end
 
-      if query_string =~ /pp=env/ && !config.disable_env_dump
+      if query_string =~ /pp=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 =~ /pp=analyze-memory/
+        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
@@ -325,14 +418,13 @@ module Rack
 
       page_struct = current.page_struct
       page_struct[:user] = user(env)
-      page_struct[:root].record_time((Time.now - start) * 1000)
+      page_struct[:root].record_time((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000)
 
       if flamegraph
         body.close if body.respond_to? :close
-        return client_settings.handle_cookie(self.flamegraph(flamegraph))
+        return client_settings.handle_cookie(self.flamegraph(flamegraph, path))
       end
 
-
       begin
         @storage.save(page_struct)
         # no matter what it is, it should be unviewed, otherwise we will miss POST
@@ -340,7 +432,7 @@ module Rack
 
         # inject headers, script
         if status >= 200 && status < 300
-          result = inject_profiler(env,status,headers,body)
+          result = inject_profiler(env, status, headers, body)
           return client_settings.handle_cookie(result) if result
         end
       rescue Exception => e
@@ -356,7 +448,7 @@ module Rack
       self.current = nil
     end
 
-    def inject_profiler(env,status,headers,body)
+    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
       content_type = headers['Content-Type']
@@ -366,12 +458,12 @@ module Rack
         headers.delete('Date')
       end
 
-      headers['X-MiniProfiler-Original-Cache-Control'] = headers['Cache-Control']
+      headers['X-MiniProfiler-Original-Cache-Control'] = headers['Cache-Control'] unless headers['Cache-Control'].nil?
       headers['Cache-Control'] = "#{"no-store, " if config.disable_caching}must-revalidate, private, max-age=0"
 
       # inject header
       if headers.is_a? Hash
-        headers['X-MiniProfiler-Ids'] = ids_json(env)
+        headers['X-MiniProfiler-Ids'] = ids_comma_separated(env)
       end
 
       if current.inject_js && content_type =~ /text\/html/
@@ -379,7 +471,7 @@ module Rack
         script   = self.get_profile_script(env)
 
         if String === body
-          response.write inject(body,script)
+          response.write inject(body, script)
         else
           body.each { |fragment| response.write inject(fragment, script) }
         end
@@ -399,38 +491,44 @@ module Rack
         if script.respond_to?(:encoding) && script.respond_to?(:force_encoding)
           script = script.force_encoding(fragment.encoding)
         end
-        fragment.insert(index, script)
+
+        safe_script = script
+        if script.respond_to?(:html_safe)
+          safe_script = script.html_safe
+        end
+
+        fragment.insert(index, safe_script)
       else
         fragment
       end
     end
 
     def dump_exceptions(exceptions)
-      body = "Exceptions raised during request\n\n"
+      body = "Exceptions raised during request\n\n".dup
       if exceptions.empty?
         body << "No exceptions raised"
       else
         body << "Exceptions: (#{exceptions.size} total)\n"
-        exceptions.group_by(&:class).each do |klass, exceptions|
-          body << "  #{klass.name} (#{exceptions.size})\n"
+        exceptions.group_by(&:class).each do |klass, exceptions_per_class|
+          body << "  #{klass.name} (#{exceptions_per_class.size})\n"
         end
 
         body << "\nBacktraces\n"
         exceptions.each_with_index do |e, i|
-          body << "##{i+1}: #{e.class} - \"#{e.message}\"\n  #{e.backtrace.join("\n  ")}\n\n"
+          body << "##{i + 1}: #{e.class} - \"#{e.message}\"\n  #{e.backtrace.join("\n  ")}\n\n"
         end
       end
       text_result(body)
     end
 
     def dump_env(env)
-      body = "Rack Environment\n---------------\n"
-      env.each do |k,v|
+      body = "Rack Environment\n---------------\n".dup
+      env.each do |k, v|
         body << "#{k}: #{v}\n"
       end
 
       body << "\n\nEnvironment\n---------------\n"
-      ENV.each do |k,v|
+      ENV.each do |k, v|
         body << "#{k}: #{v}\n"
       end
 
@@ -446,9 +544,9 @@ module Rack
     end
 
     def trim_strings(strings, max_size)
-      strings.sort!{|a,b| b[1] <=> a[1]}
+      strings.sort! { |a, b| b[1] <=> a[1] }
       i = 0
-      strings.delete_if{|_| (i+=1) > max_size}
+      strings.delete_if { |_| (i += 1) > max_size }
     end
 
     def analyze_memory
@@ -467,22 +565,22 @@ module Rack
 
           unless str.valid_encoding?
             # work around bust string with a double conversion
-            str.encode!("utf-16","utf-8",:invalid => :replace)
-            str.encode!("utf-8","utf-16")
+            str.encode!("utf-16", "utf-8", invalid: :replace)
+            str.encode!("utf-8", "utf-16")
           end
         end
 
         str
       end
 
-      body = "ObjectSpace stats:\n\n"
+      body = "ObjectSpace stats:\n\n".dup
 
       counts = ObjectSpace.count_objects
       total_strings = counts[:T_STRING]
 
       body << counts
-        .sort{|a,b| b[1] <=> a[1]}
-        .map{|k,v| "#{k}: #{v}"}
+        .sort { |a, b| b[1] <=> a[1] }
+        .map { |k, v| "#{k}: #{v}" }
         .join("\n")
 
       strings = []
@@ -506,29 +604,29 @@ module Rack
       trim_strings(strings, max_size)
 
       body << "\n\n\n1000 Largest strings:\n\n"
-      body << strings.map{|s,len| "#{s[0..1000]}\n(len: #{len})\n\n"}.join("\n")
+      body << strings.map { |s, len| "#{s[0..1000]}\n(len: #{len})\n\n" }.join("\n")
 
       body << "\n\n\n1000 Sample strings:\n\n"
-      body << sample_strings.map{|s,len| "#{s[0..1000]}\n(len: #{len})\n\n"}.join("\n")
+      body << sample_strings.map { |s, len| "#{s[0..1000]}\n(len: #{len})\n\n" }.join("\n")
 
       body << "\n\n\n1000 Most common strings:\n\n"
-      body << string_counts.sort{|a,b| b[1] <=> a[1]}[0..max_size].map{|s,len| "#{trunc.call(s)}\n(x #{len})\n\n"}.join("\n")
+      body << string_counts.sort { |a, b| b[1] <=> a[1] }[0..max_size].map { |s, len| "#{trunc.call(s)}\n(x #{len})\n\n" }.join("\n")
 
       text_result(body)
     end
 
     def text_result(body)
-      headers = {'Content-Type' => 'text/plain'}
+      headers = { 'Content-Type' => 'text/plain' }
       [200, headers, [body]]
     end
 
     def make_link(postfix, env)
       link = env["PATH_INFO"] + "?" + env["QUERY_STRING"].sub("pp=help", "pp=#{postfix}")
-      "pp=<a href='#{link}'>#{postfix}</a>"
+      "pp=<a href='#{ERB::Util.html_escape(link)}'>#{postfix}</a>"
     end
 
     def help(client_settings, env)
-      headers = {'Content-Type' => 'text/html'}
+      headers = { 'Content-Type' => 'text/html' }
       body = "<html><body>
 <pre style='line-height: 30px; font-size: 16px;'>
 Append the following to your query string:
@@ -543,9 +641,9 @@ Append the following to your query string:
   #{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 (ruby 1.9.3 only)
   #{make_link "profile-memory", env} : requires the memory_profiler gem, new location based report
-  #{make_link "flamegraph", env} : works best on Ruby 2.0, a graph representing sampled activity (requires the flamegraph gem).
+  #{make_link "flamegraph", env} : requires Ruby 2.2, a graph representing sampled activity (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_embed", env} : works best on Ruby 2.0, a graph representing sampled activity (requires the flamegraph gem), embedded resources for use on an intranet.
+  #{make_link "flamegraph_embed", env} : requires Ruby 2.2, a graph representing sampled activity (requires the stackprof gem), embedded resources for use on an intranet.
   #{make_link "trace-exceptions", env} : requires Ruby 2.0, will return all the spots where your application raises exceptions
   #{make_link "analyze-memory", env} : requires Ruby 2.0, will perform basic memory analysis of heap
 </pre>
@@ -556,9 +654,37 @@ Append the following to your query string:
       [200, headers, [body]]
     end
 
-    def flamegraph(graph)
-      headers = {'Content-Type' => 'text/html'}
-      [200, headers, [graph]]
+    def flamegraph(graph, path)
+      headers = { 'Content-Type' => 'text/html' }
+      if Hash === graph
+        html = <<~HTML
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <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]]
+      else
+        [200, headers, [graph]]
+      end
     end
 
     def ids(env)
@@ -570,10 +696,6 @@ Append the following to your query string:
       all
     end
 
-    def ids_json(env)
-      ::JSON.generate(ids(env))
-    end
-
     def ids_comma_separated(env)
       ids(env).join(",")
     end
@@ -586,21 +708,33 @@ Append the following to your query string:
     # * 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
 
       settings = {
-       :path               => path,
-       :version            => MiniProfiler::ASSET_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,
-       :authorized         => true,
-       :toggleShortcut     => @config.toggle_shortcut,
-       :startHidden        => @config.start_hidden,
-       :collapseResults    => @config.collapse_results,
-       :htmlContainer      => @config.html_container
+       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(',')
       }
 
       if current && current.page_struct
@@ -614,7 +748,7 @@ Append the following to your query string:
       # TODO : cache this snippet
       script = IO.read(::File.expand_path('../html/profile_handler.js', ::File.dirname(__FILE__)))
       # replace the variables
-      settings.each do |k,v|
+      settings.each do |k, v|
         regex = Regexp.new("\\{#{k.to_s}\\}")
         script.gsub!(regex, v.to_s)
       end
@@ -628,5 +762,109 @@ Append the following to your query string:
       current.inject_js = false
     end
 
+    def cache_control_value
+      86400
+    end
+
+    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.find_snapshots_group(group_name)
+        list.each do |snapshot|
+          snapshot[:url] = url_for_snapshot(snapshot[:id])
+        end
+        data = {
+          group_name: group_name,
+          list: list
+        }
+      else
+        list = @storage.snapshot_groups_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
+        <html>
+          <head></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 rails_route_from_path(path, method)
+      if defined?(Rails) && defined?(ActionController::RoutingError)
+        hash = Rails.application.routes.recognize_path(path, method: method)
+        if hash && hash[:controller] && hash[:action]
+          "#{method} #{hash[:controller]}##{hash[:action]}"
+        end
+      end
+    rescue ActionController::RoutingError
+      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)
+      qs = Rack::Utils.build_query({ id: id, snapshot: true })
+      "/#{@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) &&
+      @storage.should_take_snapshot?(@config.snapshot_every_n_requests)
+    end
+
+    def take_snapshot(env, start)
+      MiniProfiler.create_current(env, @config)
+      Thread.current[:mp_ongoing_snapshot] = true
+      results = @app.call(env)
+      status = results[0].to_i
+      if status >= 200 && status < 300
+        page_struct = current.page_struct
+        page_struct[:root].record_time(
+          (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+        )
+        custom_fields = MiniProfiler.get_snapshot_custom_fields
+        page_struct[:custom_fields] = custom_fields if custom_fields
+        if Rack::MiniProfiler.snapshots_transporter?
+          Rack::MiniProfiler::SnapshotsTransporter.transport(page_struct)
+        else
+          @storage.push_snapshot(
+            page_struct,
+            @config
+          )
+        end
+      end
+      self.current = nil
+      results
+    end
   end
 end