coverband 6.2.0 → 6.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12802541de3827dd777fba9962270fd2f0a6c7b3debb2ef96c4bcca32f02b48d
-  data.tar.gz: 36fa21009ed2ada842ff90ca4a18195c8bfcddc81ad0951c11f613ede11f6606
+  metadata.gz: 20188ba8fca24027b2a7bd367ac88586b7dace04a6eadfd9714bdf509849683e
+  data.tar.gz: c2db00de6ffaa32256d083c7d51290a5936f5e2ee46c774eed901f91fa0ba545
 SHA512:
-  metadata.gz: 03c7e496735cfe705b926b30140b3d704993b0599e470d290fb9ae672a7b204bf5cfa98adfc73d54eb70df1c71e8cbb9d91a5f85862b86d5c2a1ba1d0d3aa704
-  data.tar.gz: 6610a4ec327a69de3bd6878cb256a8f9d605fcf2a4104e6699b6b68acbec3ac9aaaeb957569eaf9ac1e949c58c5a6adbcd75055be464da56a11dde5c873dc4b6
+  metadata.gz: 22b5b1281136a3ed3172383d84526f1659568e6b204cc38b636d929c76b8ec84c9b70d20e61a54484cf97d8604e268de9da87cc596bbff2cbb81752c1078ca8b
+  data.tar.gz: aa55b358d2a3a196fd5de29f850ad41a877274649ccf377395a114c6e940bc926424fccbe6a3e7642225eaa81432f73094443b5874c8e79ac75cccb39a6c3422

data/.github/workflows/main.yml

@@ -39,7 +39,7 @@ jobs:
           --health-timeout 5s
           --health-retries 5
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
@@ -49,9 +49,17 @@ jobs:
   starndardrb:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 3.1
           bundler-cache: true # runs 'bundle install' and caches installed gems automatically
       - run: bundle exec standardrb --format github
+  javascript:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - run: node --test test/javascript/*.test.mjs

data/.gitignore

@@ -26,4 +26,5 @@ log/
 test/unique_files
 test/rails7_dummy/tmp
 CLAUDE.md
-.claude/
+.claude/
+scratch/

data/README.md

@@ -45,6 +45,28 @@ Coverband stores coverage data in Redis. The Redis endpoint is looked for in thi
 
 The redis store can also be explicitly defined within the `config/coverband.rb`. See [advanced config](#advanced-config).
 
+### Redis with TLS
+
+For Redis servers that require TLS (such as AWS serverless ElastiCache), use the `rediss://` URL scheme instead of `redis://`. The Redis gem automatically enables TLS when it detects this scheme:
+
+```bash
+# Example with AWS serverless ElastiCache
+REDIS_URL=rediss://my-elasticache.abcdef.cache.amazonaws.com:6379
+```
+
+Or in `config/coverband.rb`:
+
+```ruby
+config.store = Coverband::Adapters::RedisStore.new(
+  Redis.new(url: "rediss://my-elasticache-endpoint:6379")
+)
+```
+
+The `rediss://` scheme works with:
+- AWS ElastiCache (serverless or provisioned with required TLS)
+- Any self-hosted Redis with TLS enabled
+- Other managed Redis services that require TLS
+
 ## Gem Installation
 
 Add this line to your application's `Gemfile`, remember to `bundle install` after updating:
@@ -271,8 +293,71 @@ This feature is enabled by default. To stop this feature, disable the feature in
 
 `config.track_views = false`
 
+#### ViewComponent Support
+
+Coverband can also track [ViewComponent](https://viewcomponent.org/) renders. This requires:
+
+- ViewComponent **>= 4.6.0**
+- Instrumentation enabled in your app config:
+
+```ruby
+# config/application.rb (or environment-specific config)
+config.view_component.instrumentation_enabled = true
+```
+
+When enabled, Coverband subscribes to the `render.view_component` notification and tracks which component templates are rendered, just like standard Rails views.
+
 ![image](https://raw.github.com/danmayer/coverband/main/docs/coverband_view_tracker.png)
 
+### Query Burst Tracking
+
+Coverband includes an optional Query Burst Tracker to monitor SQL activity per request and per background job in production. It helps identify potential N+1 query issues and bursty database behavior.
+
+Enable it in your Coverband configuration:
+
+```ruby
+Coverband.configure do |config|
+  config.track_query_bursts = true
+
+  # Thresholds used to flag heavy requests/jobs
+  config.query_burst_query_count_threshold = 30
+  config.query_burst_sql_time_threshold_ms = 100.0
+end
+```
+
+When enabled, Coverband records stats by execution context (for example controller/action and ActiveJob class) and exposes them in the Query Burst Tracker tab in the web UI.
+
+#### Threshold Settings
+
+- `query_burst_query_count_threshold`:
+  - Max SQL query count allowed for a single tracked execution (one request or one job run).
+  - If query count is greater than or equal to this value, it is counted as a threshold hit.
+- `query_burst_sql_time_threshold_ms`:
+  - Max total SQL time (in milliseconds) allowed for a single tracked execution.
+  - If SQL time is greater than or equal to this value, it is counted as a threshold hit.
+
+Threshold logic is OR-based: Coverband records a threshold hit if either threshold is exceeded.
+
+#### What You See in the UI
+
+For each tracked key, the Query Burst Tracker reports:
+
+- Requests: Number of tracked executions
+- Total SQL Calls: Sum of all SQL calls across executions
+- Total SQL ms: Sum of SQL time across executions
+- Max SQL Calls: Highest query count seen in one execution
+- Max SQL ms: Highest SQL time seen in one execution
+- Threshold Hits: Number of executions that exceeded either threshold
+
+#### How To Tune Thresholds
+
+- Start with defaults (`30` queries, `100.0` ms SQL time).
+- Lower thresholds to detect smaller regressions sooner.
+- Raise thresholds if you see too much noise from expected heavy endpoints/jobs.
+- Tune by endpoint/job behavior: latency-sensitive paths often need stricter limits than batch work.
+
+Tip: use this tracker in production-like traffic, where query patterns are most realistic.
+
 ### Hiding settings
 
 Coverband provides a view of all of its current settings. Sometimes you might want to hide this view,
@@ -281,6 +366,16 @@ You can disable the settings view like so:
 
 `config.hide_settings = true`
 
+### Dead-code review session
+
+The web report includes a client-side "dead-code session" toolbar to help drive code-removal work:
+
+- Hide files or whole folders from the report via the ✕ icon that appears when hovering path segments, or hide everything with runtime % > 0 with one toggle.
+- Mark files or folders for deletion via the 🗑 icon (with an optional comment). Marked items disappear from the view and are listed in the "Marked for deletion" modal.
+- Export the marked list as a CSV (`path,comment,marked_at`) to feed a code-removal PR process.
+
+Session state lives in your browser's localStorage: "Reset session" clears the hidden set; "Start over" (in the modal) clears the marked list.
+
 ### Fixing Coverage Only Shows Loading Hits
 
 If all your coverage is being counted as loading or eager_loading coverage, and nothing is showing as runtime Coverage the initialization hook failed for some reason. The most likely reason for this issue is manually calling `eager_load!` on some Plugin/Gem. If you or a plugin is altering the Rails initialization process, you can manually flip Coverband to runtime coverage by calling these two lines, in an `after_initialize` block, in `application.rb`.
@@ -314,6 +409,8 @@ Add a wiggle (in seconds) to the background thread to avoid all your servers rep
 
 `config.reporting_wiggle = 30`
 
+The default 30-second wiggle is suitable for most deployments. For larger fleets you may want to increase the wiggle proportionally (e.g. 1 second per server). The tradeoff is a small delay in coverage reporting freshness. The `reporting_wiggle` and `background_reporting_sleep_seconds` options work together — consider configuring both when tuning background reporting for your environment.
+
 Another way to avoid cache stampede is to omit some reporting on starting servers. Coverband stores the results of eager_loading to Redis at server startup. The eager_loading results are the same for all servers, so there is no need to save all results. By configuring the eager_loading results of some servers to be stored in Redis, we can reduce the load on Redis during deployment.
 
 ```ruby
@@ -325,11 +422,21 @@ config.send_deferred_eager_loading_data = rand(100) < 5
 config.send_deferred_eager_loading_data = ENV.fetch('ENABLE_EAGER_LOADING_COVERAGE', false)
 ```
 
+Note: `defer_eager_loading_data = true` is required in order to use `send_deferred_eager_loading_data`. With both set, eager_loading data is deferred at startup and only sent by the subset of servers where `send_deferred_eager_loading_data` evaluates to `true`.
+
+### Oneshot Mode
+
+Enabling [oneshot mode](https://docs.ruby-lang.org/en/master/Coverage.html#module-coverage-oneshot-lines-coverage) reduces the Ruby CPU overhead. The tradeoff is that you no longer get frequency data — you will only know whether a line was executed at least once, not how many times.
+
+```ruby
+config.use_oneshot_lines_coverage = true
+```
+
 ### Redis Hash Store
 
 Coverband on very high volume sites with many server processes reporting can have a race condition which can cause hit counts to be inaccurate. To resolve the race condition and reduce Ruby memory overhead we have introduced a new Redis storage option. This moves the some of the work from the Ruby processes to Redis. It is worth noting because of this, it has larger demands on the Redis server. So adjust your Redis instance accordingly. To help reduce the extra redis load you can also change the background reporting frequency.
 
-- Use a dedicated Coverband redis instance: `config.store = Coverband::Adapters::HashRedisStore.new(Redis.new(url: redis_url))`
+- To use Redis Hash Store: `config.store = Coverband::Adapters::HashRedisStore.new(Redis.new(url: redis_url))`
 - Adjust from default 30s reporting `config.background_reporting_sleep_seconds = 120`
 
 See more discussion [here](https://github.com/danmayer/coverband/issues/384).
@@ -402,10 +509,20 @@ gem 'coverband', require: ['alternative_coverband_patch']
 
 This conflict happens when a ruby method is patched twice, once using module prepend, and once using method aliasing. See this ruby issue for details. The fix is to apply all patches the same way. By default, Coverband will apply its patch using prepend, but you can change that to method aliasing by adding require: ['alternative_coverband_patch'] to the gem line as shown above.
 
-### Redis Sizing Info
+### Redis Sizing & Configuration Info
 
 A few folks have asked about what size of Redis is needed to run Coverband. I have some of our largest services with hundreds of servers on cache.m3.medium with plenty of room to spare. I run most apps on the smallest AWS Redis instances available and bump up only if needed or if I am forced to be on a shared Redis instance, which I try to avoid. On Heroku, I have used it with most of the 3rd party and also been fine on the smallest Redis instances, if you have hundreds of dynos you would likely need to scale up. Also note there is a tradeoff one can make, `Coverband::Adapters::HashRedisStore` will use LUA on Redis and increase the Redis load, while being nicer to your app servers and avoid potential lost data during race conditions. While the `Coverband::Adapters::RedisStore` uses in app memory and merging and has lower load on Redis.
 
+For a dedicated Coverband Redis instance, `allkeys-lfu` is a good choice for `maxmemory-policy` as it evicts the least-frequently-used keys first, meaning rarely-hit files are evicted before frequently-reported ones. On a shared Redis instance, be cautious with eviction policies that could interfere with other data. See [issue #595](https://github.com/danmayer/coverband/issues/595) for more discussion.
+
+### Ruby Overhead Reduction Checklist
+
+If Coverband is adding meaningful latency to your application, work through this checklist:
+
+* Enable oneshot mode (`config.use_oneshot_lines_coverage = true`) — reduces CPU overhead by only tracking whether a line ran, not how many times
+* Enable Redis Hash Store — moves merging work from Ruby processes to Redis, reducing per-process memory overhead
+* Only enable Coverband on a subset of server instances — requests routed to those servers will be slightly slower, but coverage data will still be gathered. This is most effective with a Least Outstanding Requests load balancing algorithm. Avoid enabling on all servers but only reporting on a subset of requests — loading the coverage module itself has a performance impact regardless of reporting.
+
 # Newer Features
 
 ### MCP Server for AI Assistants

data/Rakefile

@@ -8,7 +8,7 @@ RuboCop::RakeTask.new
 
 task default: %i[test]
 
-task "test:all": %i[test forked_tests benchmarks:memory benchmarks]
+task "test:all": %i[test test:javascript forked_tests benchmarks:memory benchmarks]
 
 task :test
 require "rake/testtask"
@@ -21,6 +21,14 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
+desc "run the web report's javascript unit tests (node --test)"
+task :"test:javascript" do
+  # Pass expanded file paths rather than the bare directory: node's
+  # directory-argument handling for --test is inconsistent across versions
+  # (Node 22 fails to find test/javascript/ as a directory in some CI images).
+  sh "node --test #{FileList["test/javascript/*.test.mjs"].join(" ")}"
+end
+
 Rake::TestTask.new(:forked_tests) do |test|
   if RUBY_PLATFORM == "java"
     puts "forked tests not supported on JRuby"

data/changes.md

@@ -1,3 +1,19 @@
+### 6.2.2
+
+* Feature: Added a dead-code review session to the web report — hide files/folders by hovering any path segment, mark files for deletion with an optional comment, and export marked entries to CSV to drive an out-of-band code-removal process; session state lives in browser localStorage; thanks @obie (#647, #649)
+* Feature: Added `Coverband::Collectors::QueryBurstTracker` to detect N+1/burst SQL patterns per request or job, with configurable query-count and SQL-time thresholds and a new Query Burst Tracker tab in the web UI (#644)
+* Fix: Scoped the `ruby-head` memory-leak benchmark check to only fail on Coverband's own retained objects, fixing CI false positives caused by stdlib/gem string-deduplication artifacts on newer Ruby (#648)
+
+### 6.2.1
+
+* Fix: Search now includes full filenames hidden by truncation in the web UI; users can search for complete file paths even when displaying truncated versions (#569)
+* Feature: Added support for TLS Redis connections via `rediss://` URL scheme for use with serverless ElastiCache and other TLS-required Redis services (#580)
+* Fix: MCP HTTP handler now properly uses `StreamableHTTPTransport` for full HTTP protocol support including GET, DELETE, and OPTIONS methods (#604)
+* Fix: Suppressed Rails logger stdout pollution in stdio MCP mode to ensure clean JSON-RPC stream for Claude Desktop and other AI clients (#625)
+* Fix: Tracker persistence now gracefully handles non-Redis stores (FileStore, NullStore) without raising errors at process exit (#637)
+* Fix: Resolved Rack 1.6 compatibility issue in web reporter by detecting `Rack::Files` vs `Rack::File` class (#639)
+* Docs: Added TLS Redis setup documentation to README for serverless ElastiCache configurations
+
 ### 6.2.0
 
 * Fix: Correct `Rack::Static` URL handling in the web reporter by using an empty string URL prefix; thanks @alpaca-tc (#635)

data/lib/coverband/collectors/abstract_tracker.rb

@@ -53,6 +53,8 @@ module Coverband
       end
 
       def used_keys
+        return {} unless redis_store
+
         redis_store.hgetall(tracker_key)
       end
 
@@ -74,6 +76,8 @@ module Coverband
       end
 
       def tracking_since
+        return "N/A" unless redis_store
+
         if (tracking_time = redis_store.get(tracker_time_key))
           Time.at(tracking_time.to_i).iso8601
         else
@@ -82,18 +86,24 @@ module Coverband
       end
 
       def reset_recordings
+        return unless redis_store
+
         redis_store.del(tracker_key)
         redis_store.del(tracker_time_key)
       end
 
       def clear_key!(key)
         return unless key
+        return unless redis_store
+
         puts "#{tracker_key} key #{key}"
         redis_store.hdel(tracker_key, key)
         @logged_keys.delete(key)
       end
 
       def save_report
+        return unless redis_store
+
         redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || tracker_time_key_exists?
         @one_time_timestamp = true
         reported_time = Time.now.to_i
@@ -138,10 +148,16 @@ module Coverband
       end
 
       def redis_store
-        store.raw_store
+        @redis_store ||= begin
+          store.raw_store
+        rescue NotImplementedError
+          nil
+        end
       end
 
       def tracker_time_key_exists?
+        return false unless redis_store
+
         if defined?(redis_store.exists?)
           redis_store.exists?(tracker_time_key)
         else

data/lib/coverband/collectors/delta.rb

@@ -59,10 +59,12 @@ module Coverband
 
           # This handles Coverage branch support, setup by default in
           # simplecov 0.18.x
-          arr_line_counts = line_counts.is_a?(Hash) ? line_counts[:lines] : line_counts
+          arr_line_counts = extract_line_counts(file, line_counts)
+          next unless arr_line_counts
+
           new_results[file] = if @@previous_coverage && @@previous_coverage[file]
-            prev_line_counts = @@previous_coverage[file].is_a?(Hash) ? @@previous_coverage[file][:lines] : @@previous_coverage[file]
-            array_diff(arr_line_counts, prev_line_counts)
+            prev_line_counts = extract_line_counts(file, @@previous_coverage[file])
+            prev_line_counts ? array_diff(arr_line_counts, prev_line_counts) : arr_line_counts
           else
             arr_line_counts
           end
@@ -87,13 +89,25 @@ module Coverband
           next unless file.start_with?(@@project_directory) &&
             @@ignore_patterns.none? { |pattern| file.match(pattern) }
 
-          @@stubs[file] ||= ::Coverage.line_stub(file)
-          transformed_line_counts = coverage[:oneshot_lines].each_with_object(@@stubs[file].dup) { |line_number, line_counts|
-            line_counts[line_number - 1] = 1
-          }
+          transformed_line_counts = oneshot_lines_to_line_counts(file, coverage[:oneshot_lines])
           new_results[file] = transformed_line_counts
         end
       end
+
+      def extract_line_counts(file, coverage_data)
+        return coverage_data unless coverage_data.is_a?(Hash)
+
+        coverage_data[:lines] || oneshot_lines_to_line_counts(file, coverage_data[:oneshot_lines])
+      end
+
+      def oneshot_lines_to_line_counts(file, oneshot_lines)
+        return nil unless oneshot_lines
+
+        @@stubs[file] ||= ::Coverage.line_stub(file)
+        oneshot_lines.each_with_object(@@stubs[file].dup) do |line_number, line_counts|
+          line_counts[line_number - 1] = 1
+        end
+      end
     end
   end
 end

data/lib/coverband/collectors/query_burst_tracker.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+require "singleton"
+
+module Coverband
+  module Collectors
+    # Lightweight SQL burst tracker for production runtime behavior.
+    # Aggregates per controller action / job class and persists compact stats.
+    class QueryBurstTracker < AbstractTracker
+      REPORT_ROUTE = "query_bursts_tracker"
+      TITLE = "Query Bursts"
+      CONTEXT_STACK_KEY = :coverband_query_burst_context_stack
+      IGNORED_SQL_NAMES = %w[SCHEMA CACHE TRANSACTION].freeze
+
+      def initialize(options = {})
+        super
+        @pending_stats = {}
+      end
+
+      def railtie!
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |_name, _start, _finish, _id, payload|
+          start_context(:controller, controller_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |_name, _start, _finish, _id, payload|
+          finish_context(:controller, controller_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("perform_start.active_job") do |_name, _start, _finish, _id, payload|
+          start_context(:job, job_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |_name, _start, _finish, _id, payload|
+          finish_context(:job, job_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, start, finish, _id, payload|
+          next if ignore_sql_event?(payload)
+
+          record_sql_event(duration_ms(start, finish))
+        end
+      end
+
+      def track_key(payload)
+        key = payload[:key] || payload["key"]
+        return unless key
+
+        queries = (payload[:queries] || payload["queries"] || 0).to_i
+        sql_time_ms = (payload[:sql_time_ms] || payload["sql_time_ms"] || 0.0).to_f
+        record_observation(key, queries, sql_time_ms)
+      end
+
+      def used_keys
+        return {} unless redis_store
+
+        stats_hash = redis_store.hgetall(tracker_key)
+        stats_hash.each_with_object({}) do |(key, stats_json), used|
+          stats = parse_stats(stats_json)
+          used[key] = stats["last_seen"].to_i
+        end
+      end
+
+      def used_key_stats
+        return {} unless redis_store
+
+        stats_hash = redis_store.hgetall(tracker_key)
+        stats_hash
+          .transform_values { |stats_json| parse_stats(stats_json) }
+          .sort_by { |key, stats| [-stats["threshold_hits"].to_i, -stats["total_sql_time_ms"].to_f, key] }
+          .to_h
+      end
+
+      def unused_keys(_used_keys = nil)
+        []
+      end
+
+      def all_keys
+        []
+      end
+
+      def as_json
+        {
+          tracking_since: tracking_since,
+          thresholds: {
+            query_count: query_count_threshold,
+            sql_time_ms: sql_time_threshold_ms
+          },
+          used_keys: used_key_stats
+        }.to_json
+      end
+
+      def save_report
+        return unless redis_store
+        return if @pending_stats.empty?
+
+        redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || tracker_time_key_exists?
+        @one_time_timestamp = true
+
+        existing_stats = redis_store.hgetall(tracker_key)
+        merged = @pending_stats.each_with_object({}) do |(key, pending), h|
+          existing = parse_stats(existing_stats[key])
+          h[key] = merge_stats(existing, pending).to_json
+        end
+
+        redis_store.hset(tracker_key, merged) if merged.any?
+        @pending_stats.clear
+      rescue => e
+        logger&.error "Coverband: #{self.class.name} failed to store, error #{e.class.name} info #{e.message}"
+      end
+
+      private
+
+      def start_context(type, key)
+        return unless key
+
+        context_stack << {
+          type: type,
+          key: key,
+          queries: 0,
+          sql_time_ms: 0.0
+        }
+      end
+
+      def finish_context(type, key)
+        context = pop_context(type, key)
+        return unless context
+
+        record_observation(context[:key], context[:queries], context[:sql_time_ms])
+      end
+
+      def pop_context(type, key)
+        index = context_stack.rindex { |context| context[:type] == type && context[:key] == key }
+        return unless index
+
+        context_stack.delete_at(index)
+      end
+
+      def record_sql_event(ms)
+        return if context_stack.empty?
+
+        context = context_stack.last
+        context[:queries] += 1
+        context[:sql_time_ms] += ms
+      end
+
+      def record_observation(key, query_count, sql_time_ms)
+        key = key.to_s
+        stats = @pending_stats[key] || default_stats
+
+        stats["requests"] += 1
+        stats["total_queries"] += query_count
+        stats["total_sql_time_ms"] += sql_time_ms
+        stats["max_queries"] = [stats["max_queries"], query_count].max
+        stats["max_sql_time_ms"] = [stats["max_sql_time_ms"], sql_time_ms].max
+
+        now = Time.now.to_i
+        stats["last_seen"] = now
+        stats["last_event"] = {
+          "queries" => query_count,
+          "sql_time_ms" => sql_time_ms.round(3),
+          "at" => now
+        }
+        stats["threshold_hits"] += 1 if threshold_hit?(query_count, sql_time_ms)
+
+        @pending_stats[key] = stats
+        @logged_keys << key
+      end
+
+      def threshold_hit?(query_count, sql_time_ms)
+        query_count >= query_count_threshold || sql_time_ms >= sql_time_threshold_ms
+      end
+
+      def default_stats
+        {
+          "requests" => 0,
+          "total_queries" => 0,
+          "total_sql_time_ms" => 0.0,
+          "max_queries" => 0,
+          "max_sql_time_ms" => 0.0,
+          "threshold_hits" => 0,
+          "last_seen" => nil,
+          "last_event" => nil
+        }
+      end
+
+      def merge_stats(existing, pending)
+        {
+          "requests" => existing["requests"].to_i + pending["requests"].to_i,
+          "total_queries" => existing["total_queries"].to_i + pending["total_queries"].to_i,
+          "total_sql_time_ms" => existing["total_sql_time_ms"].to_f + pending["total_sql_time_ms"].to_f,
+          "max_queries" => [existing["max_queries"].to_i, pending["max_queries"].to_i].max,
+          "max_sql_time_ms" => [existing["max_sql_time_ms"].to_f, pending["max_sql_time_ms"].to_f].max,
+          "threshold_hits" => existing["threshold_hits"].to_i + pending["threshold_hits"].to_i,
+          "last_seen" => [existing["last_seen"].to_i, pending["last_seen"].to_i].max,
+          "last_event" => latest_event(existing["last_event"], pending["last_event"])
+        }
+      end
+
+      def latest_event(existing_event, pending_event)
+        return pending_event unless existing_event
+        return existing_event unless pending_event
+
+        if existing_event["at"].to_i >= pending_event["at"].to_i
+          existing_event
+        else
+          pending_event
+        end
+      end
+
+      def parse_stats(stats_json)
+        return default_stats unless stats_json
+
+        parsed = JSON.parse(stats_json)
+        default_stats.merge(parsed)
+      rescue JSON::ParserError
+        default_stats
+      end
+
+      def context_stack
+        Thread.current[CONTEXT_STACK_KEY] ||= []
+      end
+
+      def ignore_sql_event?(payload)
+        return true if payload[:cached]
+
+        name = payload[:name].to_s
+        IGNORED_SQL_NAMES.include?(name)
+      end
+
+      def duration_ms(start, finish)
+        (finish - start) * 1000.0
+      end
+
+      def controller_key(payload)
+        controller = payload[:controller] || payload.dig(:params, "controller")
+        action = payload[:action]
+        return unless controller && action
+
+        "controller:#{controller}##{action}"
+      end
+
+      def job_key(payload)
+        job = payload[:job]
+        return unless job
+
+        queue_name = if job.respond_to?(:queue_name)
+          job.queue_name
+        end
+        queue_suffix = queue_name ? " queue:#{queue_name}" : ""
+        "job:#{job.class.name}#{queue_suffix}"
+      end
+
+      def query_count_threshold
+        Coverband.configuration.query_burst_query_count_threshold.to_i
+      end
+
+      def sql_time_threshold_ms
+        Coverband.configuration.query_burst_sql_time_threshold_ms.to_f
+      end
+
+      def concrete_target
+        []
+      end
+    end
+  end
+end

data/lib/coverband/collectors/view_tracker.rb

@@ -33,6 +33,13 @@ module Coverband
         ActiveSupport::Notifications.subscribe(/render_(template|partial|collection).action_view/) do |name, start, finish, id, payload|
           Coverband.configuration.view_tracker.track_key(payload) unless name.include?("!")
         end
+
+        # ViewComponent >= 4.6.0 emits render.view_component with a view_identifier key
+        # containing the template path. Requires config.view_component.instrumentation_enabled = true
+        # in the host app.
+        ActiveSupport::Notifications.subscribe("render.view_component") do |name, start, finish, id, payload|
+          Coverband.configuration.view_tracker.track_key(identifier: payload[:view_identifier]) unless name.include?("!")
+        end
       end
 
       ###
@@ -61,6 +68,8 @@ module Coverband
       end
 
       def used_keys
+        return {} unless redis_store
+
         views = redis_store.hgetall(tracker_key)
         normalized_views = {}
         views.each_pair do |view, time|
@@ -93,6 +102,7 @@ module Coverband
 
       def clear_key!(filename)
         return unless filename
+        return unless redis_store
 
         filename = "#{@project_directory}/#{filename}"
         redis_store.hdel(tracker_key, filename)
@@ -126,7 +136,7 @@ module Coverband
 
       def concrete_target
         if defined?(Rails.application)
-          Dir.glob("#{@project_directory}/{,packs,engines/*}/app/{views,components}/**/*.html.{erb,haml,slim}")
+          Dir.glob("#{@project_directory}/{,packs/*,engines/*}/app/{views,components}/**/*.html.{erb,haml,slim}")
         else
           []
         end