rack-mini-profiler 2.3.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ff9200889e574b3f90f901b90b88fe05f0c48993c945fc5dac37c2f1d86e693
-  data.tar.gz: bdca4fb3ada1b7c56525753b9eaa6430389f309a76152e3f8a7e0c9297463bea
+  metadata.gz: cde7281c7a63d3d3ac5bc7605ba2cf81dedf6b598ff17ed568610a54a50b517f
+  data.tar.gz: 7af763d5136493c71cc4321fe54db79372e5b9aaac4c10d31bc2f27d22f324b7
 SHA512:
-  metadata.gz: 43b8c69b37ba90c80c31d8d410b05dda421322d5c6d1f45654807b526f7d990bec54eaa711aa34bbf43141831453a75543b3a27189103ea3f3bcbac7f3f4101a
-  data.tar.gz: bed607b319c32d85838767f7de608031411d7513fcbd8866d2d67feb44253b997e389671a903b192be07e04d1c018069ab835536de47ada14ad3af8bf89739d9
+  metadata.gz: abb415f975552a1256753e15ba9d6623aeb55fe4b058c775701f2b7d3a955f62d2a906a93929f1a22545f8558750d48c78f3b7e185f774c224d12e6a256a69a6
+  data.tar.gz: f5ff03170537e5dc17a826909d9b77609bc8d6f2390f42b29be9ff1af538332eaa33c269f7433d87142ba7e05315741b3ea5b4c69fcc76980a56c225338d843c

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 3.0.0 - 2022-02-24
+
+- PERF: Improve snapshots page performance (#518) (introduces breaking changes to the API of `AbstractStore`, `MemoryStore` and `RedisStore`, and removes the `snapshots_limit` config option.)
+
+## 2.3.4 - 2022-02-23
+
+- [FEATURE] Add cookie path support for subfolder sites
+- [FIX] Remove deprecated uses of Redis#pipelined
+
 ## 2.3.3 - 2021-08-30
 
 - [FEATURE] Introduce `pp=flamegraph_mode`

data/README.md

@@ -166,14 +166,11 @@ export RACK_MINI_PROFILER_PATCH="false"
 
 ### Flamegraphs
 
-To generate [flamegraphs](http://samsaffron.com/archive/2013/03/19/flame-graphs-in-ruby-miniprofiler):
+To generate [flamegraphs](http://samsaffron.com/archive/2013/03/19/flame-graphs-in-ruby-miniprofiler), add the [**stackprof**](https://rubygems.org/gems/stackprof) gem to your Gemfile.
 
-* add the [**stackprof**](https://rubygems.org/gems/stackprof) gem to your Gemfile
-* visit a page in your app with `?pp=flamegraph`
+Then, to view the flamegraph as a direct HTML response from your request, just visit any page in your app with `?pp=flamegraph` appended to the URL. 
 
-To store flamegraph data for later viewing, append the `?pp=async-flamegraph` parameter. The request will return as normal.
-Flamegraph data for this request, and all subsequent requests made by this page (based on the `REFERER` header) will be stored.
-'flamegraph' links will appear for these requests in the MiniProfiler UI.
+Conversely, if you want your regular response instead (which is specially useful for JSON and/or XHR requests), just append the `?pp=async-flamegraph` parameter to your request/fetch URL; the request will then return as normal, and the flamegraph data will be stored for later *async* viewing, both for this request and for all subsequent requests made by this page (based on the `REFERER` header). For viewing these async flamegraphs, use the 'flamegraph' link that will appear inside the MiniProfiler UI for these requests.
 
 Note: Mini Profiler will not record SQL timings for a request if it asks for a flamegraph. The rationale behind this is to keep
 Mini Profiler's methods that are responsible for generating the timings data out of the flamegraph.
@@ -210,7 +207,7 @@ After enabling snapshots sampling, you can see the snapshots that have been coll
 
 Access to the snapshots page is restricted to only those who can see the speed badge on their own requests, see the section below this one about access control.
 
-Mini Profiler will keep a maximum of 1000 snapshots by default, and you can change that via the `snapshots_limit` config. When snapshots reach the configured limit, Mini Profiler will save a new snapshot only if it's worse than at least one of the existing snapshots and delete the best one (i.e. the snapshot whose request took the least time compared to other snapshots).
+Mini Profiler will keep a maximum of 50 snapshot groups and a maximum of 15 snapshots per group making the default maximum number of snapshots in the system 750. The default group and per group limits can be changed via the `max_snapshot_groups` and `max_snapshots_per_group` configuration options, see the configurations table below.
 
 #### Snapshots Transporter
 
@@ -350,19 +347,41 @@ Single page applications built using Ember, Angular or other frameworks need som
 On route transition always call:
 
 ```
-window.MiniProfiler.pageTransition();
+if (window.MiniProfiler !== undefined) {
+  window.MiniProfiler.pageTransition();
+}
 ```
 
 This method will remove profiling information that was related to previous page and clear aggregate statistics.
 
 #### MiniProfiler's speed badge on pages that are not generated via Rails
-You need to inject the following in your SPA to load MiniProfiler's speed badge ([extra details surrounding this script](https://github.com/MiniProfiler/rack-mini-profiler/issues/139#issuecomment-192880706)):
+You need to inject the following in your SPA to load MiniProfiler's speed badge ([extra details surrounding this script](https://github.com/MiniProfiler/rack-mini-profiler/issues/139#issuecomment-192880706) and [credit for the script tag](https://github.com/MiniProfiler/rack-mini-profiler/issues/479#issue-782488320) to [@ivanyv](https://github.com/ivanyv)):
 
 ```html
- <script async type="text/javascript" id="mini-profiler" src="/mini-profiler-resources/includes.js?v=12b4b45a3c42e6e15503d7a03810ff33" data-version="12b4b45a3c42e6e15503d7a03810ff33" data-path="/mini-profiler-resources/" data-current-id="redo66j4g1077kto8uh3" data-ids="redo66j4g1077kto8uh3" data-horizontal-position="left" data-vertical-position="top" data-trivial="false" data-children="false" data-max-traces="10" data-controls="false" data-authorized="true" data-toggle-shortcut="Alt+P" data-start-hidden="false" data-collapse-results="true"></script>
-```
-
-_Note:_ The GUID (`data-version` and the `?v=` parameter on the `src`) will change with each release of `rack_mini_profiler`. The MiniProfiler's speed badge will continue to work, although you will have to change the GUID to expire the script to fetch the most recent version.
+ <script type="text/javascript" id="mini-profiler"
+        src="/mini-profiler-resources/includes.js?v=12b4b45a3c42e6e15503d7a03810ff33"
+        data-css-url="/mini-profiler-resources/includes.css?v=12b4b45a3c42e6e15503d7a03810ff33"
+        data-version="12b4b45a3c42e6e15503d7a03810ff33"
+        data-path="/mini-profiler-resources/"
+        data-horizontal-position="left"
+        data-vertical-position="top"
+        data-ids=""
+        data-trivial="false"
+        data-children="false"
+        data-max-traces="20"
+        data-controls="false"
+        data-total-sql-count="false"
+        data-authorized="true"
+        data-toggle-shortcut="alt+p"
+        data-start-hidden="false"
+        data-collapse-results="true"
+        data-html-container="body"
+        data-hidden-custom-fields></script>
+```
+
+See an [example of how to do this in a React useEffect](https://gist.github.com/katelovescode/01cfc2b962c165193b160fd10af6c4d5).
+
+_Note:_ The GUID (`data-version` and the `?v=` parameter on the `src` and `data-css-url`) will change with each release of `rack_mini_profiler`. The MiniProfiler's speed badge will continue to work, although you will have to change the GUID to expire the script to fetch the most recent version.
 
 #### Using MiniProfiler's built in route for apps without HTML responses
 MiniProfiler also ships with a `/rack-mini-profiler/requests` route that displays the speed badge on a blank HTML page. This can be useful when profiling an application that does not render HTML.
@@ -403,14 +422,16 @@ backtrace_threshold_ms|`0`|Minimum SQL query elapsed time before a backtrace is
 flamegraph_sample_rate|`0.5`|How often to capture stack traces for flamegraphs in milliseconds.
 flamegraph_mode|`:wall`|The [StackProf mode](https://github.com/tmm1/stackprof#all-options) to pass to `StackProf.run`.
 base_url_path|`'/mini-profiler-resources/'`|Path for assets; added as a prefix when naming assets and sought when responding to requests.
+cookie_path|`'/'`|Set-Cookie header path for profile cookie
 collapse_results|`true`|If multiple timing results exist in a single page, collapse them till clicked.
 max_traces_to_show|20|Maximum number of mini profiler timing blocks to show on one page
 html_container|`body`|The HTML container (as a jQuery selector) to inject the mini_profiler UI into
 show_total_sql_count|`false`|Displays the total number of SQL executions.
-enable_advanced_debugging_tools|`false`|Enables sensitive debugging tools that can be used via the UI. In production we recommend keeping this disabled as memory and environment debugging tools can expose contents of memory that may contain passwords.
+enable_advanced_debugging_tools|`false`|Enables sensitive debugging tools that can be used via the UI. In production we recommend keeping this disabled as memory and environment debugging tools can expose contents of memory that may contain passwords. Defaults to `true` in development.
 assets_url|`nil`|See the "Register MiniProfiler's assets in the Rails assets pipeline" section above.
 snapshot_every_n_requests|`-1`|Determines how frequently snapshots are taken. See the "Snapshots Sampling" above for more details.
-snapshots_limit|`1000`|Determines how many snapshots Mini Profiler is allowed to keep.
+max_snapshot_groups|`50`|Determines how many snapshot groups Mini Profiler is allowed to keep.
+max_snapshots_per_group|`15`|Determines how many snapshots per group Mini Profiler is allowed to keep.
 snapshot_hidden_custom_fields|`[]`|Each snapshot custom field will have a dedicated column in the UI by default. Use this config to exclude certain custom fields from having their own columns.
 snapshots_transport_destination_url|`nil`|Set this config to a valid URL to enable snapshots transporter which will `POST` snapshots to the given URL. The transporter requires `snapshots_transport_auth_key` config to be set as well.
 snapshots_transport_auth_key|`nil`|`POST` requests made by the snapshots transporter to the destination URL will have a `Mini-Profiler-Transport-Auth` header with the value of this config. Make sure you use a secure and random key for this config.

data/lib/mini_profiler/client_settings.rb

@@ -74,7 +74,7 @@ module Rack
           settings["bt"] = @backtrace_level     if @backtrace_level
           settings["a"] = @allowed_tokens.join("|") if @allowed_tokens && MiniProfiler.request_authorized?
           settings_string = settings.map { |k, v| "#{k}=#{v}" }.join(",")
-          cookie = { value: settings_string, path: '/', httponly: true }
+          cookie = { value: settings_string, path: MiniProfiler.config.cookie_path, httponly: true }
           cookie[:secure] = true if @request.ssl?
           cookie[:same_site] = 'Lax'
           Rack::Utils.set_cookie_header!(headers, COOKIE_NAME, cookie)
@@ -83,7 +83,7 @@ module Rack
 
       def discard_cookie!(headers)
         if @cookie
-          Rack::Utils.delete_cookie_header!(headers, COOKIE_NAME, path: '/')
+          Rack::Utils.delete_cookie_header!(headers, COOKIE_NAME, path: MiniProfiler.config.cookie_path)
         end
       end
 

data/lib/mini_profiler/config.rb

@@ -17,6 +17,7 @@ module Rack
         new.instance_eval {
           @auto_inject      = true # automatically inject on every html page
           @base_url_path    = "/mini-profiler-resources/".dup
+          @cookie_path      = "/".dup
           @disable_caching  = true
           # called prior to rack chain, to ensure we are allowed to profile
           @pre_authorize_cb = lambda { |env| true }
@@ -39,7 +40,8 @@ module Rack
           @skip_sql_param_names = /password/ # skips parameters with the name password by default
           @enable_advanced_debugging_tools = false
           @snapshot_every_n_requests = -1
-          @snapshots_limit = 1000
+          @max_snapshot_groups = 50
+          @max_snapshots_per_group = 15
 
           # ui parameters
           @autorized            = true
@@ -66,7 +68,7 @@ module Rack
 
       attr_accessor :authorization_mode, :auto_inject, :backtrace_ignores,
         :backtrace_includes, :backtrace_remove, :backtrace_threshold_ms,
-        :base_url_path, :disable_caching, :enabled,
+        :base_url_path, :cookie_path, :disable_caching, :enabled,
         :flamegraph_sample_rate, :logger, :pre_authorize_cb, :skip_paths,
         :skip_schema_queries, :storage, :storage_failure, :storage_instance,
         :storage_options, :user_provider, :enable_advanced_debugging_tools,
@@ -80,10 +82,10 @@ module Rack
         :start_hidden, :toggle_shortcut, :html_container
 
       # snapshot related config
-      attr_accessor :snapshot_every_n_requests, :snapshots_limit,
+      attr_accessor :snapshot_every_n_requests, :max_snapshots_per_group,
         :snapshot_hidden_custom_fields, :snapshots_transport_destination_url,
         :snapshots_transport_auth_key, :snapshots_redact_sql_queries,
-        :snapshots_transport_gzip_requests
+        :snapshots_transport_gzip_requests, :max_snapshot_groups
 
       # Deprecated options
       attr_accessor :use_existing_jquery

data/lib/mini_profiler/profiler.rb

@@ -130,10 +130,10 @@ module Rack
     def serve_results(env)
       request     = Rack::Request.new(env)
       id          = request.params['id']
-      is_snapshot = request.params['snapshot']
-      is_snapshot = [true, "true"].include?(is_snapshot)
+      group_name  = request.params['group']
+      is_snapshot = group_name && group_name.size > 0
       if is_snapshot
-        page_struct = @storage.load_snapshot(id)
+        page_struct = @storage.load_snapshot(id, group_name)
       else
         page_struct = @storage.load(id)
       end
@@ -773,7 +773,7 @@ This is the help menu of the <a href='#{Rack::MiniProfiler::SOURCE_CODE_URI}'>ra
       end
 
       # TODO : cache this snippet
-      script = IO.read(::File.expand_path('../html/profile_handler.js', ::File.dirname(__FILE__)))
+      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}\\}")
@@ -802,16 +802,16 @@ This is the help menu of the <a href='#{Rack::MiniProfiler::SOURCE_CODE_URI}'>ra
       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 = @storage.snapshots_group(group_name)
         list.each do |snapshot|
-          snapshot[:url] = url_for_snapshot(snapshot[:id])
+          snapshot[:url] = url_for_snapshot(snapshot[:id], group_name)
         end
         data = {
           group_name: group_name,
           list: list
         }
       else
-        list = @storage.snapshot_groups_overview
+        list = @storage.snapshots_overview
         list.each do |group|
           group[:url] = url_for_snapshots_group(group[:name])
         end
@@ -864,7 +864,7 @@ This is the help menu of the <a href='#{Rack::MiniProfiler::SOURCE_CODE_URI}'>ra
       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]}"
+          "#{hash[:controller]}##{hash[:action]}"
         end
       end
     rescue ActionController::RoutingError
@@ -876,8 +876,8 @@ This is the help menu of the <a href='#{Rack::MiniProfiler::SOURCE_CODE_URI}'>ra
       "/#{@config.base_url_path.gsub('/', '')}/snapshots?#{qs}"
     end
 
-    def url_for_snapshot(id)
-      qs = Rack::Utils.build_query({ id: id, snapshot: true })
+    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
 
@@ -902,8 +902,12 @@ This is the help menu of the <a href='#{Rack::MiniProfiler::SOURCE_CODE_URI}'>ra
         if Rack::MiniProfiler.snapshots_transporter?
           Rack::MiniProfiler::SnapshotsTransporter.transport(page_struct)
         else
+          group_name = rails_route_from_path(page_struct[:request_path], page_struct[:request_method])
+          group_name ||= page_struct[:request_path]
+          group_name = "#{page_struct[:request_method]} #{group_name}"
           @storage.push_snapshot(
             page_struct,
+            group_name,
             @config
           )
         end

data/lib/mini_profiler/storage/abstract_store.rb

@@ -45,80 +45,53 @@ module Rack
         raise NotImplementedError.new("should_take_snapshot? is not implemented")
       end
 
-      def push_snapshot(page_struct, config)
+      def push_snapshot(page_struct, group_name, config)
         raise NotImplementedError.new("push_snapshot is not implemented")
       end
 
-      def fetch_snapshots(batch_size: 200, &blk)
-        raise NotImplementedError.new("fetch_snapshots is not implemented")
+      # returns a hash where the keys are group names and the values
+      # are hashes that contain 3 keys:
+      #   1. `:worst_score` => the duration of the worst/slowest snapshot in the group (float)
+      #   2. `:best_score` => the duration of the best/fastest snapshot in the group (float)
+      #   3. `:snapshots_count` => the number of snapshots in the group (integer)
+      def fetch_snapshots_overview
+        raise NotImplementedError.new("fetch_snapshots_overview is not implemented")
       end
 
-      def snapshot_groups_overview
-        groups = {}
-        fetch_snapshots do |batch|
-          batch.each do |snapshot|
-            group_name = default_snapshot_grouping(snapshot)
-            hash = groups[group_name] ||= {}
-            hash[:snapshots_count] ||= 0
-            hash[:snapshots_count] += 1
-            if !hash[:worst_score] || hash[:worst_score] < snapshot.duration_ms
-              groups[group_name][:worst_score] = snapshot.duration_ms
-            end
-            if !hash[:best_score] || hash[:best_score] > snapshot.duration_ms
-              groups[group_name][:best_score] = snapshot.duration_ms
-            end
-          end
-        end
-        groups = groups.to_a
+      # @param group_name [String]
+      # @return [Array<Rack::MiniProfiler::TimerStruct::Page>] list of snapshots of the group. Blank array if the group doesn't exist.
+      def fetch_snapshots_group(group_name)
+        raise NotImplementedError.new("fetch_snapshots_group is not implemented")
+      end
+
+      def load_snapshot(id, group_name)
+        raise NotImplementedError.new("load_snapshot is not implemented")
+      end
+
+      def snapshots_overview
+        groups = fetch_snapshots_overview.to_a
         groups.sort_by! { |name, hash| hash[:worst_score] }
         groups.reverse!
         groups.map! { |name, hash| hash.merge(name: name) }
         groups
       end
 
-      def find_snapshots_group(group_name)
+      def snapshots_group(group_name)
+        snapshots = fetch_snapshots_group(group_name)
         data = []
-        fetch_snapshots do |batch|
-          batch.each do |snapshot|
-            snapshot_group_name = default_snapshot_grouping(snapshot)
-            if group_name == snapshot_group_name
-              data << {
-                id: snapshot[:id],
-                duration: snapshot.duration_ms,
-                sql_count: snapshot[:sql_count],
-                timestamp: snapshot[:started_at],
-                custom_fields: snapshot[:custom_fields]
-              }
-            end
-          end
+        snapshots.each do |snapshot|
+          data << {
+            id: snapshot[:id],
+            duration: snapshot.duration_ms,
+            sql_count: snapshot[:sql_count],
+            timestamp: snapshot[:started_at],
+            custom_fields: snapshot[:custom_fields]
+          }
         end
         data.sort_by! { |s| s[:duration] }
         data.reverse!
         data
       end
-
-      def load_snapshot(id)
-        raise NotImplementedError.new("load_snapshot is not implemented")
-      end
-
-      private
-
-      def default_snapshot_grouping(snapshot)
-        group_name = rails_route_from_path(snapshot[:request_path], snapshot[:request_method])
-        group_name ||= snapshot[:request_path]
-        "#{snapshot[:request_method]} #{group_name}"
-      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]
-            "#{hash[:controller]}##{hash[:action]}"
-          end
-        end
-      rescue ActionController::RoutingError
-        nil
-      end
     end
   end
 end

data/lib/mini_profiler/storage/file_store.rb

@@ -17,7 +17,9 @@ module Rack
         def [](key)
           begin
             data = ::File.open(path(key), "rb") { |f| f.read }
+            # rubocop:disable Security/MarshalLoad
             Marshal.load data
+            # rubocop:enable Security/MarshalLoad
           rescue
             nil
           end

data/lib/mini_profiler/storage/memcache_store.rb

@@ -24,7 +24,9 @@ module Rack
 
       def load(id)
         raw = @client.get("#{@prefix}#{id}")
-        Marshal::load(raw) if raw
+        # rubocop:disable Security/MarshalLoad
+        Marshal.load(raw) if raw
+        # rubocop:enable Security/MarshalLoad
       end
 
       def set_unviewed(user, id)
@@ -65,14 +67,16 @@ module Rack
         key1, key2, cycle_at = nil
 
         if token_info
-          key1, key2, cycle_at = Marshal::load(token_info)
+          # rubocop:disable Security/MarshalLoad
+          key1, key2, cycle_at = Marshal.load(token_info)
+          # rubocop:enable Security/MarshalLoad
 
-           key1 = nil unless key1 && key1.length == 32
-           key2 = nil unless key2 && key2.length == 32
+          key1 = nil unless key1 && key1.length == 32
+          key2 = nil unless key2 && key2.length == 32
 
-           if key1 && cycle_at && (cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
-             return [key1, key2].compact
-           end
+          if key1 && cycle_at && (cycle_at > Process.clock_gettime(Process::CLOCK_MONOTONIC))
+            return [key1, key2].compact
+          end
         end
 
         timeout = Rack::MiniProfiler::AbstractStore::MAX_TOKEN_AGE

data/lib/mini_profiler/storage/memory_store.rb

@@ -53,6 +53,7 @@ module Rack
 
         @token1, @token2, @cycle_at = nil
         @snapshots_cycle = 0
+        @snapshot_groups = {}
         @snapshots = []
 
         initialize_locks
@@ -152,28 +153,69 @@ module Rack
         end
       end
 
-      def push_snapshot(page_struct, config)
+      def push_snapshot(page_struct, group_name, config)
         @snapshots_lock.synchronize do
-          @snapshots << page_struct
-          @snapshots.sort_by! { |s| s.duration_ms }
-          @snapshots.reverse!
-          if @snapshots.size > config.snapshots_limit
-            @snapshots.slice!(-1)
+          group = @snapshot_groups[group_name]
+          if !group
+            @snapshot_groups[group_name] = {
+              worst_score: page_struct.duration_ms,
+              best_score: page_struct.duration_ms,
+              snapshots: [page_struct]
+            }
+            if @snapshot_groups.size > config.max_snapshot_groups
+              group_keys = @snapshot_groups.keys
+              group_keys.sort_by! do |key|
+                @snapshot_groups[key][:worst_score]
+              end
+              group_keys.reverse!
+              group_keys.pop(group_keys.size - config.max_snapshot_groups)
+              @snapshot_groups = @snapshot_groups.slice(*group_keys)
+            end
+          else
+            snapshots = group[:snapshots]
+            snapshots << page_struct
+            snapshots.sort_by!(&:duration_ms)
+            snapshots.reverse!
+            if snapshots.size > config.max_snapshots_per_group
+              snapshots.pop(snapshots.size - config.max_snapshots_per_group)
+            end
+            group[:worst_score] = snapshots[0].duration_ms
+            group[:best_score] = snapshots[-1].duration_ms
           end
         end
       end
 
-      def fetch_snapshots(batch_size: 200, &blk)
+      def fetch_snapshots_overview
         @snapshots_lock.synchronize do
-          @snapshots.each_slice(batch_size) do |batch|
-            blk.call(batch)
+          groups = {}
+          @snapshot_groups.each do |name, group|
+            groups[name] = {
+              worst_score: group[:worst_score],
+              best_score: group[:best_score],
+              snapshots_count: group[:snapshots].size
+            }
           end
+          groups
         end
       end
 
-      def load_snapshot(id)
+      def fetch_snapshots_group(group_name)
         @snapshots_lock.synchronize do
-          @snapshots.find { |s| s[:id] == id }
+          group = @snapshot_groups[group_name]
+          if group
+            group[:snapshots].dup
+          else
+            []
+          end
+        end
+      end
+
+      def load_snapshot(id, group_name)
+        @snapshots_lock.synchronize do
+          group = @snapshot_groups[group_name]
+          if group
+            group[:snapshots].find { |s| s[:id] == id }
+          end
         end
       end
 
@@ -182,7 +224,7 @@ module Rack
       # used in tests only
       def wipe_snapshots_data
         @snapshots_cycle = 0
-        @snapshots = []
+        @snapshot_groups = {}
       end
     end
   end

data/lib/mini_profiler/storage/redis_store.rb

@@ -25,7 +25,9 @@ module Rack
         key = prefixed_id(id)
         raw = redis.get key
         begin
-          Marshal::load(raw) if raw
+          # rubocop:disable Security/MarshalLoad
+          Marshal.load(raw) if raw
+          # rubocop:enable Security/MarshalLoad
         rescue
           # bad format, junk old data
           redis.del key
@@ -131,81 +133,127 @@ unviewed_ids: #{get_unviewed_ids(user)}
         )
       end
 
-      def push_snapshot(page_struct, config)
-        zset_key = snapshot_zset_key()
-        hash_key = snapshot_hash_key()
+      def push_snapshot(page_struct, group_name, config)
+        group_zset_key = group_snapshot_zset_key(group_name)
+        group_hash_key = group_snapshot_hash_key(group_name)
+        overview_zset_key = snapshot_overview_zset_key
 
         id = page_struct[:id]
-        score = page_struct.duration_ms
-        limit = config.snapshots_limit
+        score = page_struct.duration_ms.to_s
+
+        per_group_limit = config.max_snapshots_per_group.to_s
+        groups_limit = config.max_snapshot_groups.to_s
         bytes = Marshal.dump(page_struct)
 
         lua = <<~LUA
-          local zset_key = KEYS[1]
-          local hash_key = KEYS[2]
+          local group_zset_key = KEYS[1]
+          local group_hash_key = KEYS[2]
+          local overview_zset_key = KEYS[3]
+
           local id = ARGV[1]
           local score = tonumber(ARGV[2])
-          local bytes = ARGV[3]
-          local limit = tonumber(ARGV[4])
-          redis.call("ZADD", zset_key, score, id)
-          redis.call("HSET", hash_key, id, bytes)
-          if redis.call("ZCARD", zset_key) > limit then
-            local lowest_snapshot_id = redis.call("ZRANGE", zset_key, 0, 0)[1]
-            redis.call("ZREM", zset_key, lowest_snapshot_id)
-            redis.call("HDEL", hash_key, lowest_snapshot_id)
+          local group_name = ARGV[3]
+          local per_group_limit = tonumber(ARGV[4])
+          local groups_limit = tonumber(ARGV[5])
+          local prefix = ARGV[6]
+          local bytes = ARGV[7]
+
+          local current_group_score = redis.call("ZSCORE", overview_zset_key, group_name)
+          if current_group_score == false or score > tonumber(current_group_score) then
+            redis.call("ZADD", overview_zset_key, score, group_name)
+          end
+
+          local do_save = true
+          local overview_size = redis.call("ZCARD", overview_zset_key)
+          while (overview_size > groups_limit) do
+            local lowest_group = redis.call("ZRANGE", overview_zset_key, 0, 0)[1]
+            redis.call("ZREM", overview_zset_key, lowest_group)
+            if lowest_group == group_name then
+              do_save = false
+            else
+              local lowest_group_zset_key = prefix .. "-mp-group-snapshot-zset-key-" .. lowest_group
+              local lowest_group_hash_key = prefix .. "-mp-group-snapshot-hash-key-" .. lowest_group
+              redis.call("DEL", lowest_group_zset_key, lowest_group_hash_key)
+            end
+            overview_size = overview_size - 1
+          end
+
+          if do_save then
+            redis.call("ZADD", group_zset_key, score, id)
+            local group_size = redis.call("ZCARD", group_zset_key)
+            while (group_size > per_group_limit) do
+              local lowest_snapshot_id = redis.call("ZRANGE", group_zset_key, 0, 0)[1]
+              redis.call("ZREM", group_zset_key, lowest_snapshot_id)
+              if lowest_snapshot_id == id then
+                do_save = false
+              else
+                redis.call("HDEL", group_hash_key, lowest_snapshot_id)
+              end
+              group_size = group_size - 1
+            end
+            if do_save then
+              redis.call("HSET", group_hash_key, id, bytes)
+            end
           end
         LUA
         redis.eval(
           lua,
-          keys: [zset_key, hash_key],
-          argv: [id, score, bytes, limit]
+          keys: [group_zset_key, group_hash_key, overview_zset_key],
+          argv: [id, score, group_name, per_group_limit, groups_limit, @prefix, bytes]
         )
       end
 
-      def fetch_snapshots(batch_size: 200, &blk)
-        zset_key = snapshot_zset_key()
-        hash_key = snapshot_hash_key()
-        iteration = 0
-        corrupt_snapshots = []
-        while true
-          ids = redis.zrange(
-            zset_key,
-            batch_size * iteration,
-            batch_size * iteration + batch_size - 1
-          )
-          break if ids.size == 0
-          batch = redis.mapped_hmget(hash_key, *ids).to_a
-          batch.map! do |id, bytes|
-            begin
-              Marshal.load(bytes)
-            rescue
-              corrupt_snapshots << id
-              nil
-            end
+      def fetch_snapshots_overview
+        overview_zset_key = snapshot_overview_zset_key
+        groups = redis
+          .zrange(overview_zset_key, 0, -1, withscores: true)
+          .map { |(name, worst_score)| [name, { worst_score: worst_score }] }
+
+        prefixed_group_names = groups.map { |(group_name, _)| group_snapshot_zset_key(group_name) }
+        metadata = redis.eval(<<~LUA, keys: prefixed_group_names)
+          local metadata = {}
+          for i, k in ipairs(KEYS) do
+            local best = redis.call("ZRANGE", k, 0, 0, "WITHSCORES")[2]
+            local count = redis.call("ZCARD", k)
+            metadata[i] = {best, count}
           end
-          batch.compact!
-          blk.call(batch) if batch.size != 0
-          break if ids.size < batch_size
-          iteration += 1
+          return metadata
+        LUA
+        groups.each.with_index do |(_, hash), index|
+          best, count = metadata[index]
+          hash[:best_score] = best.to_f
+          hash[:snapshots_count] = count.to_i
+        end
+        groups.to_h
+      end
+
+      def fetch_snapshots_group(group_name)
+        group_hash_key = group_snapshot_hash_key(group_name)
+        snapshots = []
+        corrupt_snapshots = []
+        redis.hgetall(group_hash_key).each do |id, bytes|
+          # rubocop:disable Security/MarshalLoad
+          snapshots << Marshal.load(bytes)
+          # rubocop:enable Security/MarshalLoad
+        rescue
+          corrupt_snapshots << id
         end
         if corrupt_snapshots.size > 0
-          redis.pipelined do
-            redis.zrem(zset_key, corrupt_snapshots)
-            redis.hdel(hash_key, corrupt_snapshots)
-          end
+          cleanup_corrupt_snapshots(corrupt_snapshots, group_name)
         end
+        snapshots
       end
 
-      def load_snapshot(id)
-        hash_key = snapshot_hash_key()
-        bytes = redis.hget(hash_key, id)
+      def load_snapshot(id, group_name)
+        group_hash_key = group_snapshot_hash_key(group_name)
+        bytes = redis.hget(group_hash_key, id)
+        return if !bytes
         begin
+          # rubocop:disable Security/MarshalLoad
           Marshal.load(bytes)
+          # rubocop:enable Security/MarshalLoad
         rescue
-          redis.pipelined do
-            redis.zrem(snapshot_zset_key(), id)
-            redis.hdel(hash_key, id)
-          end
+          cleanup_corrupt_snapshots([id], group_name)
           nil
         end
       end
@@ -231,12 +279,20 @@ unviewed_ids: #{get_unviewed_ids(user)}
         @snapshot_counter_key ||= "#{@prefix}-mini-profiler-snapshots-counter"
       end
 
-      def snapshot_zset_key
-        @snapshot_zset_key ||= "#{@prefix}-mini-profiler-snapshots-zset"
+      def group_snapshot_zset_key(group_name)
+        # if you change this key, remember to change it in the LUA script in
+        # the push_snapshot method as well
+        "#{@prefix}-mp-group-snapshot-zset-key-#{group_name}"
       end
 
-      def snapshot_hash_key
-        @snapshot_hash_key ||= "#{@prefix}-mini-profiler-snapshots-hash"
+      def group_snapshot_hash_key(group_name)
+        # if you change this key, remember to change it in the LUA script in
+        # the push_snapshot method as well
+        "#{@prefix}-mp-group-snapshot-hash-key-#{group_name}"
+      end
+
+      def snapshot_overview_zset_key
+        "#{@prefix}-mp-overviewgroup-snapshot-zset-key"
       end
 
       def cached_redis_eval(script, script_sha, reraise: true, argv: [], keys: [])
@@ -251,13 +307,45 @@ unviewed_ids: #{get_unviewed_ids(user)}
         end
       end
 
+      def cleanup_corrupt_snapshots(corrupt_snapshots_ids, group_name)
+        group_hash_key = group_snapshot_hash_key(group_name)
+        group_zset_key = group_snapshot_zset_key(group_name)
+        overview_zset_key = snapshot_overview_zset_key
+        lua = <<~LUA
+          local group_hash_key = KEYS[1]
+          local group_zset_key = KEYS[2]
+          local overview_zset_key = KEYS[3]
+          local group_name = ARGV[1]
+          for i, k in ipairs(ARGV) do
+            if k ~= group_name then
+              redis.call("HDEL", group_hash_key, k)
+              redis.call("ZREM", group_zset_key, k)
+            end
+          end
+          if redis.call("ZCARD", group_zset_key) == 0 then
+            redis.call("ZREM", overview_zset_key, group_name)
+            redis.call("DEL", group_hash_key, group_zset_key)
+          else
+            local worst_score = tonumber(redis.call("ZRANGE", group_zset_key, -1, -1, "WITHSCORES")[2])
+            redis.call("ZADD", overview_zset_key, worst_score, group_name)
+          end
+        LUA
+        redis.eval(
+          lua,
+          keys: [group_hash_key, group_zset_key, overview_zset_key],
+          argv: [group_name, *corrupt_snapshots_ids]
+        )
+      end
+
       # only used in tests
       def wipe_snapshots_data
-        redis.pipelined do
-          redis.del(snapshot_counter_key())
-          redis.del(snapshot_zset_key())
-          redis.del(snapshot_hash_key())
-        end
+        keys = redis.keys(group_snapshot_hash_key('*'))
+        keys += redis.keys(group_snapshot_zset_key('*'))
+        redis.del(
+          keys,
+          snapshot_overview_zset_key,
+          snapshot_counter_key
+        )
       end
     end
   end

data/lib/mini_profiler/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 3.0.0
 platform: ruby
 authors:
 - Sam Saffron
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-30 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack