rails-profiler 0.31.2 → 0.31.4

data/lib/profiler/storage/memory_store.rb

@@ -2,19 +2,38 @@
 
 require "concurrent-ruby"
 require_relative "base_store"
+require_relative "summary"
 require_relative "../models/profile"
 
 module Profiler
   module Storage
+    # Keeps the profiles in the process, as the Hashes of Profile#to_h, at most max_profiles of
+    # them (100 when neither the option nor config.max_profiles sets it: this store always has a
+    # cap). Beside them, the start time, type and parent of each, and the children of each parent,
+    # so that listing, finding the children and evicting deserialize only what they return.
     class MemoryStore < BaseStore
+      Entry = Struct.new(:at, :type, :parent, :sequence)
+
       def initialize(options = {})
         @profiles = Concurrent::Hash.new
         @max_profiles = options[:max_profiles] || Profiler.configuration.max_profiles || 100
+        @mutex = Mutex.new
+        @entries = {}
+        @children = {}
+        @sequence = 0
+        @sorted = nil
       end
 
       def do_save(token, profile)
-        cleanup_if_needed
-        @profiles[token] = serialize_profile(profile)
+        data = serialize_profile(profile)
+        @mutex.synchronize do
+          cleanup_if_needed unless @profiles.key?(token)
+          remove_entry(token)
+          @profiles[token] = data
+          @entries[token] = Entry.new(profile.started_at.to_f, data[:profile_type].to_s, profile.parent_token, @sequence += 1)
+          (@children[profile.parent_token] ||= {})[token] = true if profile.parent_token
+          @sorted = nil
+        end
         token
       end
 
@@ -27,65 +46,75 @@ module Profiler
         deserialize_profile(data)
       end
 
-      def list(limit: 50, offset: 0)
-        @profiles.values
-                .map { |data| deserialize_profile(data) }
-                .sort_by { |p| p.started_at }
-                .reverse
-                .drop(offset)
-                .take(limit)
+      # Newest first; summary: true leaves the bodies, headers and nested collector data out.
+      def list(limit: 50, offset: 0, type: nil, summary: false)
+        page = @mutex.synchronize do
+          tokens = sorted_tokens
+          tokens = tokens.select { |token| @entries[token].type == type.to_s } if type
+          tokens.drop(offset).first(limit).filter_map { |token| @profiles[token] }
+        end
+        page.map { |data| summary ? Summary.to_profile(Summary.build(data)) : deserialize_profile(data) }
       end
 
       def cleanup(older_than: 24 * 60 * 60)
-        cutoff_time = Time.now - older_than
-        @profiles.delete_if do |_token, data|
-          profile = deserialize_profile(data)
-          profile.started_at < cutoff_time
+        cutoff = (Time.now - older_than).to_f
+        @mutex.synchronize do
+          @entries.select { |_, entry| entry.at < cutoff }.each_key { |token| remove(token) }
         end
       end
 
       def find_by_parent(parent_token)
         return [] unless Token.valid?(parent_token)
 
-        @profiles.values
-                .map { |data| deserialize_profile(data) }
-                .select { |profile| profile.parent_token == parent_token }
-                .sort_by { |profile| profile.started_at }
+        children = @mutex.synchronize { (@children[parent_token] || {}).keys.filter_map { |token| @profiles[token] } }
+        children.map { |data| deserialize_profile(data) }.sort_by(&:started_at)
       end
 
       def delete(token)
         return unless Token.valid?(token)
 
-        @profiles.delete(token)
+        @mutex.synchronize { remove(token) }
       end
 
       def clear(type: nil)
-        if type.nil?
-          @profiles.clear
-        else
-          @profiles.delete_if do |_token, data|
-            deserialize_profile(data).profile_type == type.to_s
-          end
+        @mutex.synchronize do
+          @entries.select { |_, entry| type.nil? || entry.type == type.to_s }.each_key { |token| remove(token) }
         end
       end
 
       private
 
+      # Called before a new profile is added: removes the first saved down to 80% of the cap, in the
+      # order of the saves (@entries keeps it), not of the starts: a job saved when it ends is new.
       def cleanup_if_needed
         return if @profiles.size < @max_profiles
 
-        # Remove oldest profiles until we're under the limit
         profiles_to_remove = @profiles.size - (@max_profiles * 0.8).to_i
         return if profiles_to_remove <= 0
 
-        sorted_tokens = @profiles.map do |token, data|
-          profile = deserialize_profile(data)
-          [token, profile.started_at]
-        end.sort_by { |_, time| time }.map(&:first)
+        @entries.keys.first(profiles_to_remove).each { |token| remove(token) }
+      end
 
-        sorted_tokens.take(profiles_to_remove).each do |token|
-          @profiles.delete(token)
+      def remove(token)
+        removed = @profiles.delete(token)
+        remove_entry(token)
+        removed
+      end
+
+      def remove_entry(token)
+        entry = @entries.delete(token)
+        return unless entry
+
+        if entry.parent && (siblings = @children[entry.parent])
+          siblings.delete(token)
+          @children.delete(entry.parent) if siblings.empty?
         end
+        @sorted = nil
+      end
+
+      # Newest first; two profiles started in the same instant, the one saved last first.
+      def sorted_tokens
+        @sorted ||= @entries.sort_by { |_, entry| [-entry.at, -entry.sequence] }.map(&:first)
       end
 
       def serialize_profile(profile)

data/lib/profiler/storage/private_files.rb

@@ -70,6 +70,19 @@ module Profiler
         FileUtils.rm_f(tmp) if tmp
       end
 
+      # Appends data to path in one write, creating it 0600 when missing: lines appended by
+      # several processes this way do not interleave.
+      def append(path, data)
+        File.open(path.to_s, File::WRONLY | File::APPEND | File::CREAT | nofollow, new_file_mode) do |file|
+          file.write(data)
+        end
+      end
+
+      # Opens path for reading, refusing a symbolic link while the modes are restricted.
+      def open_for_reading(path, &block)
+        File.open(path.to_s, File::RDONLY | nofollow, &block)
+      end
+
       # Opens path for reading and writing, creating it 0600 when missing.
       def open(path, &block)
         File.open(path.to_s, File::RDWR | File::CREAT | nofollow, new_file_mode, &block)

data/lib/profiler/storage/redis_store.rb

@@ -2,13 +2,38 @@
 
 require "redis"
 require "json"
+require "securerandom"
+require "time"
 require_relative "base_store"
+require_relative "summary"
 require_relative "../models/profile"
 
 module Profiler
   module Storage
+    # Profiles as JSON strings with a TTL, listed by a sorted set scored by start time. Beside
+    # them: a sorted set per profile type, a set of children per parent and the summary each list
+    # shows, so that listing one type, a page of summaries or the children of a page reads only
+    # what it returns; and at most max_profiles profiles, the oldest evicted first. Data written by
+    # a version without these indexes is indexed once, on first use.
     class RedisStore < BaseStore
       DEFAULT_TTL = 24 * 60 * 60 # 24 hours
+      INDEX_VERSION = "1"
+      # Past max_profiles, the first saved profiles are evicted down to this share of it.
+      LOW_WATER = 0.8
+      # Indexing the data of an earlier version: tokens read per batch, and how long one process
+      # holds the right to do it.
+      INDEX_BATCH = 500
+      INDEX_LOCK_SECONDS = 60
+      # Past the cap, a save removes at most this many profiles itself; a larger backlog (the data
+      # of an earlier version) is removed by one process, under a lock, by batches of INDEX_BATCH.
+      EVICT_BATCH = 100
+      EVICT_LOCK_SECONDS = 60
+      # Deletes a lock only while it still holds the value its owner set: one that expired and was
+      # taken by another process is left to it.
+      RELEASE_LOCK = <<~LUA
+        if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) end
+        return 0
+      LUA
 
       attr_reader :redis
 
@@ -16,15 +41,17 @@ module Profiler
         @redis = options[:redis] || build_redis_client(options)
         @ttl = options[:ttl] || DEFAULT_TTL
         @key_prefix = options[:key_prefix] || "profiler"
+        @max_profiles = options.key?(:max_profiles) ? options[:max_profiles] : Profiler.configuration.max_profiles
+        @indexed = false
       end
 
       def do_save(token, profile)
-        key = profile_key(token)
-        @redis.setex(key, @ttl, profile.to_json)
-
-        # Add to sorted set for listing
-        @redis.zadd(list_key, profile.started_at.to_f, token)
-
+        ensure_index
+        data = profile.to_h
+        unindex(token, read_summary(token))
+        @redis.setex(profile_key(token), @ttl, data.to_json)
+        index(token, profile.started_at.to_f, Summary.build(data))
+        evict_first_saved(token)
         token
       end
 
@@ -41,50 +68,47 @@ module Profiler
         nil
       end
 
-      def list(limit: 50, offset: 0)
-        tokens = @redis.zrevrange(list_key, offset, offset + limit - 1)
-        tokens.map { |token| load(token) }.compact
+      # Newest first. summary: true reads the summaries only.
+      def list(limit: 50, offset: 0, type: nil, summary: false)
+        ensure_index
+        tokens = @redis.zrevrange(type ? type_list_key(type) : list_key, offset, offset + limit - 1)
+        return tokens.filter_map { |token| load(token) } unless summary
+
+        summaries = tokens.empty? ? [] : @redis.mget(*tokens.map { |token| summary_key(token) })
+        tokens.zip(summaries).filter_map do |token, json|
+          next Summary.to_profile(JSON.parse(json)) if json
+
+          profile = load(token)
+          profile && Summary.to_profile(Summary.build(profile))
+        end
       end
 
       def cleanup(older_than: 24 * 60 * 60)
+        ensure_index
         cutoff_time = Time.now.to_f - older_than
-        @redis.zremrangebyscore(list_key, "-inf", cutoff_time)
+        @redis.zrangebyscore(list_key, "-inf", cutoff_time).each_slice(INDEX_BATCH) { |tokens| remove_tokens(tokens) }
       end
 
       def find_by_parent(parent_token)
         return [] unless Token.valid?(parent_token)
 
-        # Get all tokens from the sorted set
-        tokens = @redis.zrange(list_key, 0, -1)
-
-        # Load each profile and filter by parent_token
-        tokens.map { |token| load(token) }
-              .compact
+        ensure_index
+        @redis.smembers(children_key(parent_token))
+              .filter_map { |token| load(token) if Token.valid?(token) }
               .select { |profile| profile.parent_token == parent_token }
-              .sort_by { |profile| profile.started_at }
+              .sort_by(&:started_at)
       end
 
       def delete(token)
         return unless Token.valid?(token)
 
-        @redis.del(profile_key(token))
-        @redis.zrem(list_key, token)
+        ensure_index
+        remove(token)
       end
 
       def clear(type: nil)
-        tokens = @redis.zrange(list_key, 0, -1)
-        tokens.each do |token|
-          if type.nil?
-            @redis.del(profile_key(token))
-            @redis.zrem(list_key, token)
-          else
-            profile = load(token)
-            if profile&.profile_type == type.to_s
-              @redis.del(profile_key(token))
-              @redis.zrem(list_key, token)
-            end
-          end
-        end
+        ensure_index
+        @redis.zrange(type ? type_list_key(type) : list_key, 0, -1).each_slice(INDEX_BATCH) { |tokens| remove_tokens(tokens) }
       end
 
       private
@@ -94,6 +118,169 @@ module Profiler
         Redis.new(url: url)
       end
 
+      # score: the start time, the order of the lists. saved_at: the order of the saves, which the
+      # eviction follows.
+      def index(token, score, summary, saved_at: Time.now.to_f, client: @redis)
+        type = (summary[:profile_type] || summary["profile_type"] || "http").to_s
+        parent = summary[:parent_token] || summary["parent_token"]
+        client.setex(summary_key(token), @ttl, JSON.generate(summary))
+        client.zadd(list_key, score, token)
+        client.zadd(type_list_key(type), score, token)
+        client.zadd(saved_key, saved_at, token)
+        client.sadd(types_key, type)
+        return unless Token.valid?(parent)
+
+        client.sadd(children_key(parent), token)
+        client.expire(children_key(parent), @ttl)
+      end
+
+      # Takes token out of the type list and the children set its previous save put it in.
+      def unindex(token, summary)
+        return unless summary
+
+        @redis.zrem(type_list_key(summary["profile_type"] || "http"), token)
+        parent = summary["parent_token"]
+        @redis.srem(children_key(parent), token) if Token.valid?(parent)
+      end
+
+      def remove(token)
+        remove_tokens([token])
+      end
+
+      # Removes tokens and their index entries in three round trips, whatever their number: their
+      # summaries (type and parent), the types when a summary is missing, then one pipeline.
+      def remove_tokens(tokens)
+        tokens = tokens.select { |token| Token.valid?(token) }
+        return if tokens.empty?
+
+        summaries = @redis.mget(*tokens.map { |token| summary_key(token) }).map { |json| parse_summary(json) }
+        types = summaries.all? ? [] : @redis.smembers(types_key)
+        @redis.pipelined do |pipe|
+          tokens.zip(summaries).each do |token, summary|
+            if summary
+              pipe.zrem(type_list_key(summary["profile_type"] || "http"), token)
+              parent = summary["parent_token"]
+              pipe.srem(children_key(parent), token) if Token.valid?(parent)
+            else
+              types.each { |type| pipe.zrem(type_list_key(type), token) }
+            end
+            pipe.del(profile_key(token), summary_key(token))
+          end
+          pipe.zrem(list_key, tokens)
+          pipe.zrem(saved_key, tokens)
+        end
+      end
+
+      def parse_summary(json)
+        json && JSON.parse(json)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def read_summary(token)
+        parse_summary(@redis.get(summary_key(token)))
+      end
+
+      # In the order of the saves, not of the starts: a job saved when it ends is a new profile,
+      # and the one just saved (keep) is never evicted. ZCARD is O(1): the eviction costs nothing
+      # until the cap is passed. A backlog larger than EVICT_BATCH is removed by one process, under
+      # a lock, by batches; meanwhile the other saves remove EVICT_BATCH profiles each at most.
+      def evict_first_saved(keep)
+        return unless @max_profiles
+
+        target = [(@max_profiles * LOW_WATER).floor, 1].max
+        excess = @redis.zcard(saved_key) - target
+        return if excess <= @max_profiles - target
+
+        if excess <= EVICT_BATCH
+          remove_tokens(@redis.zrange(saved_key, 0, excess - 1) - [keep])
+        else
+          evicted_all = with_lock(evict_lock_key, EVICT_LOCK_SECONDS) do
+            loop do
+              excess = @redis.zcard(saved_key) - target
+              break if excess <= 0
+
+              batch = @redis.zrange(saved_key, 0, [excess, INDEX_BATCH].min - 1) - [keep]
+              break if batch.empty?
+
+              remove_tokens(batch)
+            end
+          end
+          remove_tokens(@redis.zrange(saved_key, 0, EVICT_BATCH - 1) - [keep]) unless evicted_all
+        end
+      end
+
+      # Runs the block holding key, set to a value of this call's own; false, without running it,
+      # when another process holds it.
+      def with_lock(key, seconds)
+        owner = SecureRandom.hex(16)
+        return false unless @redis.set(key, owner, nx: true, ex: seconds)
+
+        begin
+          yield
+        ensure
+          @redis.eval(RELEASE_LOCK, keys: [key], argv: [owner])
+        end
+        true
+      end
+
+      # Indexes, once, the profiles saved by a version that kept only the list, which it never
+      # pruned: the tokens started long before the TTL first, then the others read by batches.
+      # One process does it, under a lock; the others go on meanwhile, with the list alone.
+      def ensure_index
+        return if @indexed
+        return @indexed = true if @redis.get(index_version_key) == INDEX_VERSION
+
+        with_lock(index_lock_key, INDEX_LOCK_SECONDS) do
+          # An hour of margin for a profile saved long after it started.
+          @redis.zremrangebyscore(list_key, "-inf", Time.now.to_f - @ttl - 3600)
+          tokens = @redis.zrange(list_key, 0, -1)
+          # Past the cap, the first saved would be evicted right after: removed without indexing.
+          if @max_profiles && tokens.size > @max_profiles
+            target = [(@max_profiles * LOW_WATER).floor, 1].max
+            tokens.first(tokens.size - target).each_slice(INDEX_BATCH) { |batch| drop_unindexed(batch) }
+            tokens = tokens.last(target)
+          end
+          tokens.each_slice(INDEX_BATCH) { |batch| index_batch(batch) }
+          @redis.set(index_version_key, INDEX_VERSION)
+          @indexed = true
+        end
+      end
+
+      # Profiles of an earlier version, which only the list and their own key know.
+      def drop_unindexed(tokens)
+        @redis.pipelined do |pipe|
+          tokens.each { |token| pipe.del(profile_key(token)) if Token.valid?(token) }
+          pipe.zrem(list_key, tokens)
+        end
+      end
+
+      def index_batch(tokens)
+        tokens = tokens.select { |token| Token.valid?(token) }
+        return if tokens.empty?
+
+        expired = []
+        profiles = tokens.zip(@redis.mget(*tokens.map { |token| profile_key(token) })).filter_map do |token, json|
+          if json.nil?
+            expired << token
+            next
+          end
+
+          # The summary from the parsed JSON, without building the Profile (and inflating its bodies).
+          data = JSON.parse(json, symbolize_names: true)
+          [token, data[:started_at] ? Time.parse(data[:started_at]).to_f : 0.0, Summary.build(data)]
+        rescue StandardError => e
+          warn "RedisStore: could not index profile #{token}: #{e.message}"
+          nil
+        end
+        @redis.pipelined do |pipe|
+          profiles.each do |token, started_at, summary|
+            index(token, started_at, summary, saved_at: started_at, client: pipe)
+          end
+        end
+        @redis.zrem(list_key, expired) unless expired.empty?
+      end
+
       def profile_key(token)
         "#{@key_prefix}:#{token}"
       end
@@ -101,6 +288,38 @@ module Profiler
       def list_key
         "#{@key_prefix}:list"
       end
+
+      def type_list_key(type)
+        "#{@key_prefix}:list:#{type}"
+      end
+
+      def types_key
+        "#{@key_prefix}:types"
+      end
+
+      def summary_key(token)
+        "#{@key_prefix}:summary:#{token}"
+      end
+
+      def children_key(parent_token)
+        "#{@key_prefix}:children:#{parent_token}"
+      end
+
+      def index_version_key
+        "#{@key_prefix}:index_version"
+      end
+
+      def index_lock_key
+        "#{@key_prefix}:index_lock"
+      end
+
+      def evict_lock_key
+        "#{@key_prefix}:evict_lock"
+      end
+
+      def saved_key
+        "#{@key_prefix}:saved"
+      end
     end
   end
 end

data/lib/profiler/storage/sqlite_store.rb

@@ -5,15 +5,21 @@ require "fileutils"
 require_relative "base_store"
 require_relative "blob_store"
 require_relative "private_files"
+require_relative "summary"
 require_relative "token"
 require_relative "../models/profile"
 
 module Profiler
   module Storage
     class SqliteStore < BaseStore
+      # Past max_profiles, the oldest profiles are evicted down to this share of it.
+      LOW_WATER = 0.8
+
       def initialize(options = {})
         require "sqlite3"
 
+        @max_profiles = options.key?(:max_profiles) ? options[:max_profiles] : Profiler.configuration.max_profiles
+
         db_path = (options[:database] || default_db_path).to_s
         blob_path = options[:blob_path] || PrivateFiles.tmp_dir("blobs")
 
@@ -55,11 +61,11 @@ module Profiler
             INSERT OR REPLACE INTO profiler_profiles (
               token, profile_type, gem_version, path, method, status, duration, memory,
               started_at, finished_at, parent_token, is_ajax,
-              tabs, params, headers, response_headers, collectors_meta
+              tabs, params, headers, response_headers, collectors_meta, summary
             ) VALUES (
               :token, :profile_type, :gem_version, :path, :method, :status, :duration, :memory,
               :started_at, :finished_at, :parent_token, :is_ajax,
-              :tabs, :params, :headers, :response_headers, :collectors_meta
+              :tabs, :params, :headers, :response_headers, :collectors_meta, :summary
             )
           SQL
           token:            token,
@@ -78,8 +84,10 @@ module Profiler
           params:           JSON.generate(data[:params] || {}),
           headers:          JSON.generate(data[:headers] || {}),
           response_headers: JSON.generate(data[:response_headers] || {}),
-          collectors_meta:  JSON.generate(collectors_meta)
+          collectors_meta:  JSON.generate(collectors_meta),
+          summary:          JSON.generate(Summary.build(data))
         )
+        evict_oldest
 
         token
       end
@@ -98,12 +106,18 @@ module Profiler
         nil
       end
 
-      def list(limit: 50, offset: 0)
+      # Newest first. summary: true reads the summary column only, for the rows that have it.
+      def list(limit: 50, offset: 0, type: nil, summary: false)
+        where = type ? "WHERE profile_type = :type" : ""
+        # The summaries need neither the params, headers and tabs nor the collector data.
+        columns = summary ? "token, summary" : "*"
         rows = @db.execute(
-          "SELECT * FROM profiler_profiles ORDER BY started_at DESC LIMIT :limit OFFSET :offset",
-          limit: limit, offset: offset
+          "SELECT #{columns} FROM profiler_profiles #{where} ORDER BY started_at DESC, rowid DESC LIMIT :limit OFFSET :offset",
+          { limit: limit, offset: offset }.merge(type ? { type: type.to_s } : {})
         )
-        rows.map { |row| row_to_profile(row, load_blobs: false) }.compact
+        return rows.filter_map { |row| row_to_profile(row, load_blobs: false) } unless summary
+
+        rows.filter_map { |row| row_to_summary(row) }
       end
 
       def find_by_parent(parent_token)
@@ -147,6 +161,40 @@ module Profiler
 
       private
 
+      # In the order the profiles were written (rowid: INSERT OR REPLACE gives a saved again
+      # profile a new one), not started: a job saved when it ends is a new profile, and the one
+      # just written is never evicted. One query on the rowid tells whether the table holds more
+      # than max_profiles.
+      def evict_oldest
+        return unless @max_profiles
+        return unless @db.get_first_value(
+          "SELECT 1 FROM profiler_profiles ORDER BY rowid DESC LIMIT 1 OFFSET :max", max: @max_profiles
+        )
+
+        keep = [(@max_profiles * LOW_WATER).floor, 1].max
+        tokens = @db.execute(
+          "SELECT token FROM profiler_profiles ORDER BY rowid DESC LIMIT -1 OFFSET :keep", keep: keep
+        ).map { |r| r["token"] }
+        tokens.each_slice(500) do |slice|
+          @db.execute("DELETE FROM profiler_profiles WHERE token IN (#{(["?"] * slice.size).join(",")})", slice)
+        end
+        tokens.each { |token| @blob_store.delete(token) }
+      end
+
+      # A row written before the summary column falls back to the whole row, summarized.
+      def row_to_summary(row)
+        if row["summary"].nil? || row["summary"].empty?
+          full = @db.get_first_row("SELECT * FROM profiler_profiles WHERE token = :token", token: row["token"])
+          profile = full && row_to_profile(full, load_blobs: false)
+          return profile && Summary.to_profile(Summary.build(profile))
+        end
+
+        Summary.to_profile(JSON.parse(row["summary"]))
+      rescue JSON::ParserError => e
+        warn "SqliteStore: failed to read the summary of #{row["token"]}: #{e.message}"
+        nil
+      end
+
       def save_http_response_bodies(token, requests)
         bodies = requests.map do |req|
           { "response_body" => req["response_body"], "response_body_encoding" => req["response_body_encoding"] }
@@ -213,8 +261,8 @@ module Profiler
             ON profiler_profiles(profile_type);
         SQL
 
-        begin
-          @db.execute("ALTER TABLE profiler_profiles ADD COLUMN gem_version TEXT")
+        %w[gem_version summary].each do |column|
+          @db.execute("ALTER TABLE profiler_profiles ADD COLUMN #{column} TEXT")
         rescue SQLite3::Exception
           # column already exists
         end

data/lib/profiler/storage/summary.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../models/profile"
+
+module Profiler
+  module Storage
+    # What the profile lists show of a profile, for the stores to keep apart from the profile
+    # itself: the top-level fields without the bodies, params, headers and tabs, and for each
+    # collector its scalar values only (database.total_queries, job.queue, test.test_name...),
+    # nested lists and hashes left out, strings cut at MAX_SCALAR_LENGTH (a console return value,
+    # an exception message). Built from Profile#to_h, after the collectors and the
+    # redaction have run: a summary is a subset of the stored profile (a long string cut to its
+    # start) and holds no value the profile does not.
+    module Summary
+      MAX_SCALAR_LENGTH = 500
+
+      DROPPED = %i[params headers response_headers request_body request_body_encoding
+                   response_body response_body_encoding tabs].freeze
+
+      module_function
+
+      # From a Profile, or the Hash its #to_h returns.
+      def build(profile)
+        data = profile.is_a?(Hash) ? profile : profile.to_h
+        summary = data.transform_keys(&:to_sym).except(*DROPPED)
+        summary[:collectors_data] = (summary[:collectors_data] || {}).to_h do |name, values|
+          [name.to_s, values.is_a?(Hash) ? scalars(values) : {}]
+        end
+        summary
+      end
+
+      # The Profile a list shows, from a summary with string or symbol keys.
+      def to_profile(summary)
+        Models::Profile.from_hash(summary.transform_keys(&:to_sym))
+      end
+
+      def scalars(values)
+        values.each_with_object({}) do |(key, value), kept|
+          next unless scalar?(value)
+
+          kept[key.to_s] = value.is_a?(String) && value.length > MAX_SCALAR_LENGTH ? value[0, MAX_SCALAR_LENGTH] : value
+        end
+      end
+
+      def scalar?(value)
+        value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+      end
+    end
+  end
+end