rails-profiler 0.31.3 → 0.31.5

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
 
@@ -37,54 +64,51 @@ module Profiler
 
         Models::Profile.from_json(json_data)
       rescue => e
-        warn "Failed to load profile #{token}: #{e.message}"
+        Profiler.log_error("RedisStore: could not load profile #{token}", e)
         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
+          Profiler.log_error("RedisStore: could not index profile #{token}", e)
+          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
@@ -94,16 +102,22 @@ module Profiler
 
         row_to_profile(row)
       rescue => e
-        warn "SqliteStore: failed to load profile #{token}: #{e.message}"
+        Profiler.log_error("SqliteStore: could not load profile #{token}", e)
         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
+        Profiler.log_error("SqliteStore: could not read the summary of #{row["token"]}", e)
+        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
@@ -260,7 +308,7 @@ module Profiler
           collectors_data:        collectors_data
         )
       rescue => e
-        warn "SqliteStore: failed to deserialize profile #{row["token"]}: #{e.message}"
+        Profiler.log_error("SqliteStore: could not deserialize profile #{row["token"]}", e)
         nil
       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

data/lib/profiler/storage/unavailable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Storage
+    # Stands in for a store that could not be created (an index or lock replaced by a symbolic
+    # link, a directory that cannot be written, a database that cannot be opened): the cause is
+    # said once per process, without a backtrace, rather than with one on every request. Saves are
+    # dropped; reads, which a person asked for from the dashboard or an MCP tool, raise the cause.
+    # Profiler.storage tries to create the store again on its next call, so fixing the cause is
+    # enough.
+    class Unavailable
+      # What the reads raise: the cause in one line, without a path (the profiler's routes answer
+      # it as a 503, the MCP tools as an error).
+      class Error < Profiler::Error; end
+
+      @said = {}
+      @mutex = Mutex.new
+
+      class << self
+        def for(error)
+          key = [Process.pid, error.class.name, error.message]
+          first = @mutex.synchronize { @said[key] ? false : (@said[key] = true) }
+          if first
+            Profiler.log_warn("storage unavailable, profiles are not saved until it is fixed", error)
+          end
+          new(error)
+        end
+
+        def reset!
+          @mutex.synchronize { @said = {} }
+        end
+      end
+
+      def initialize(error)
+        @error = Error.new("The profiler storage is unavailable: #{self.class.short_cause(error)}")
+      end
+
+      # First line of the message, absolute paths replaced, credentials masked, at most 300
+      # characters.
+      def self.short_cause(error)
+        line = error.message.to_s.lines.first.to_s.strip
+        line = line.gsub(%r{(?<=\A|[\s'"(=])(?:[A-Za-z]:)?[/\\][^\s'"]*[^\s'":,.;)]}, "[path]")
+        line = Redaction.hide_credentials(line) if defined?(Redaction)
+        line = line[0, 300]
+        line.empty? ? error.class.name : line
+      end
+
+      def save(token, _profile)
+        token
+      end
+
+      %i[load list cleanup exists? find_by_parent delete clear].each do |name|
+        define_method(name) { |*, **| raise @error }
+      end
+    end
+  end
+end

data/lib/profiler/test_helpers/reporter.rb

@@ -8,7 +8,7 @@ module Profiler
       def self.print
         return unless Profiler.enabled?
 
-        profiles = Profiler.storage.list(limit: 1000).select { |p| p.profile_type == "test" }
+        profiles = Profiler.storage.list(limit: 1000, type: "test").select { |p| p.profile_type == "test" }
         return if profiles.empty?
 
         passed  = profiles.count { |p| test_status(p) == "passed" }
@@ -75,7 +75,7 @@ module Profiler
 
         $stdout.puts lines.join("\n")
       rescue => e
-        warn "Profiler Reporter: failed to generate report: #{e.message}"
+        Profiler.log_error("Reporter: could not generate the report", e)
       end
 
       def self.has_n1?(profile)

data/lib/profiler/test_profiler.rb

@@ -114,7 +114,7 @@ module Profiler
             collector.collect if collector.respond_to?(:collect)
             profile.add_collector_metadata(collector)
           rescue => e
-            warn "Profiler TestProfiler: Collector #{collector.class} failed: #{e.message}"
+            Profiler.log_error("TestProfiler: collector #{collector.class} failed", e)
           end
         end
 

data/lib/profiler/test_runner/runner.rb

@@ -51,7 +51,7 @@ module Profiler
         root = project_root
         allowed = if Profiler.configuration.test_runner_allow_undiscovered_files
                     warn_once(:undiscovered,
-                              "[Profiler] config.test_runner_allow_undiscovered_files is enabled: the test runner " \
+                              "config.test_runner_allow_undiscovered_files is enabled: the test runner " \
                               "runs any file under the Rails root, not only the discovered tests.")
                     nil
                   else
@@ -101,11 +101,7 @@ module Profiler
           @warned[key] = true
         end
 
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.warn(message)
-        else
-          warn(message)
-        end
+        Profiler.log_warn(message)
       end
 
       def self.reset_warnings!
@@ -227,7 +223,7 @@ module Profiler
 
         unless left_out.empty?
           warn_once([:env, left_out.sort],
-                    "[Profiler] Environment overrides not passed to the test runner, because they make it " \
+                    "Environment overrides not passed to the test runner, because they make it " \
                     "load other code: #{left_out.sort.join(", ")}.")
         end
 

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.31.3"
+  VERSION = "0.31.5"
 end