coverband 6.2.2 → 7.0.0.rc.2

data/changes.md

@@ -1,3 +1,63 @@
+### 7.0.0
+
+**Breaking changes**
+
+* **Upgrading from 6.x? Follow [Upgrading to 7.0](https://github.com/danmayer/coverband#upgrading-to-70) in the README**, which lists what to change for each item below. Removed APIs are removed outright rather than deprecated first.
+* **The `redis` gem is no longer a dependency of Coverband. If you use Redis (the default), add `gem "redis"` to your Gemfile when you upgrade.** Redis is still the default store and still needs no other configuration: whenever the `redis` gem is installed Coverband loads it and stores coverage there exactly as before. Apps that only got `redis` through Coverband will otherwise boot with a warning telling them to add it, and record nothing until they do. Apps that store coverage elsewhere (`ActiveSupportCacheStore` with Solid Cache, memcached, or files) no longer need Redis installed at all
+* **Coverage and tracker history do not survive this upgrade.** Stored documents now carry the metadata the new merge protocol needs, and keys are scoped by a generation token, so the storage format version changed for both `RedisStore` and the cache adapters. Old keys are ignored rather than migrated, and coverage accumulates fresh from the upgrade. Delete the old `coverband_3_2.*` keys once you are happy with the new data.
+* **Reporting to coverband.io (`WebServiceStore`) has been removed, as the hosted service is no longer maintained.** This also removes `ViewTrackerService`, loading `config/coverband_service.rb`, the `api_key`, `service_url`, `coverband_timeout`, `service_dev_mode`, `service_test_mode`, and `process_type` settings, and the `COVERBAND_API_KEY`, `COVERBAND_URL`, `COVERBAND_ENABLE_DEV_MODE`, `COVERBAND_ENABLE_TEST_MODE`, and `PROCESS_TYPE` environment variables. Setting `COVERBAND_API_KEY` no longer switches Coverband into service mode. Move settings into `config/coverband.rb` and configure Redis or an `ActiveSupportCacheStore`
+* Removed configuration settings that no longer had production consumers: `reporter` (no effect since 5.0), `s3_region`, `s3_bucket`, `s3_access_key_id`, `s3_secret_access_key`, `track_gems`, `gem_details`, and `simulate_oneshot_lines_coverage`, plus the coverband.io settings above. Assigning any of them logs a warning naming the setting and how to fix it, and is otherwise ignored, so an old `config/coverband.rb` still boots.
+* `Coverband::Utils::SourceFile` and `Coverband::Utils::Result` now accept only enriched file records from stored Coverband reports. Passing the legacy bare line-coverage Array is no longer supported.
+* **`Coverband::Adapters::MemcachedStore` has been removed.** Use `ActiveSupportCacheStore.new(cache, cache_namespace: "...")` with the same memcached cache; it also supports the trackers. `ActiveSupportCacheStore` no longer accepts `memcached_namespace`
+* **`background_reporting_sleep_seconds` now defaults to 600** for the new cache adapter (`HashRedisStore` still defaults to 300, everything else to 60), because each report rewrites a whole document.
+* `Adapters::Base#size` now returns bytes as an Integer or `nil`; `size_in_mib` owns the "N/A" presentation. A store returning the string `"N/A"` previously reported `0.00` MiB.
+* `Adapters::Base#get_coverage_report` now reports the receiver's coverage instead of routing through `Coverband.configuration.store`, which quietly returned another store's data when the receiver was not the configured one.
+* Removed `AbstractTracker#redis_store`; custom trackers use `#storage`. Trackers no longer reach through the store to raw Redis commands.
+* Removed the misspelled `Coverband::Utils::Results#runtime_relavent_lines`; use `#runtime_relevant_lines` instead.
+* Removed `Adapters::Base#raw_store` and the Redis adapters' raw-client escape hatch. Redis maintenance now uses the narrow `store.cleanup` capability (`clear_legacy!` and `clear_orphans!`); adapters that cannot enumerate keys return `nil`.
+* Work is retained when generation resolution fails, so a backend blip during a reporting cycle no longer discards that cycle's coverage. Previously only deltas that had reached the pending queue were protected, and the generation is resolved before the payload is enqueued. The retention caps apply to that held work too, so a sustained outage cannot grow the queue without limit
+* A cache store that is not resolvable yet (`ActiveSupportCacheStore.new { Rails.cache }` running before Rails assigns `Rails.cache`) is no longer a `NoMethodError` on a nil target. It holds the cycle's work, logs, and resolves on a later cycle. A resolver returning something that is not a cache store now names the problem instead of failing deep in the storage layer
+* Rake tasks that reach the store (`coverband:clear`, `clear_coverage`, `clear_tracker`, `clear_legacy`, `clear_orphans`, `coverage`, `coverage_json`, `coverage_html`) load the Rails environment first. With a lazily configured store they previously failed with an unavailable cache unless `rake environment` was named explicitly
+* Coverage data loss (eviction, dropped pending deltas) is now surfaced on the web report index. It was logged and shown on the tracker tabs, but the coverage index reported partial numbers as though they were complete
+* `Adapters::SessionCoverage#save_report` returns the protocol state from `Session#record` rather than `nil`, so a caller can tell a write that landed from one that was deferred or refused
+* Coverage now absorbs the two-cycle outage the design commits to. The cap bounds the queue, and the cycle that recovers takes a slot in it, so a cap of 2 only ever absorbed one; it is now 3
+* Data loss from dropping a delta that was already written and merely awaiting confirmation is reported as `unconfirmed_dropped` rather than `pending_dropped`, and the web report says the numbers may be undercounted instead of claiming earlier results are unavailable. Only the second kind is lost coverage
+* Trackers keep their own keys whenever a report is not stored (`:failed`, `:unavailable`, or an error), so an unreachable backend is no longer lossier for them than one that raises. `TrackerStorage::Base#retains_pending?` is removed; the decision comes from what `record` returns
+* A write refused or errored *after* the delta was enqueued now reports `:retained` rather than `:failed`, since the work is in the storage queue and a caller holding a second copy would replay it. This is the documented memcached >1MB path, where it double counted `QueryBurstTracker`
+* `QueryBurstTracker` reports on a quiet cycle when storage is holding work it could not write, instead of waiting for the next burst to flush it
+* A document that cannot be written is now reported while it is happening, rather than an hour later. Its retention caps never fire on a quiet tracker -- nothing new arrives for them to drop -- so only the absolute age cap eventually turned a permanently refused write (a tracker document past memcached's 1MB limit, for instance) into a loss event, and until then the tab read "0 used" exactly like an app that used none. The web report now says how many reports could not be stored and since when
+* Presence trackers (views, routes, translations) re-supply their known keys when storage reports work dropped at its retention caps, so a backend outage longer than the queue no longer leaves a used view reading as unused. Their merge is idempotent, so this cannot double count; `QueryBurstTracker` sums, so its loss stays irreducible and reported
+* `save_report` no longer mutates the report it is given. The merge used to sum stored counts back into the caller's line arrays, so a caller that reused its report object re-submitted counts that were already recorded.
+
+**Features**
+
+* Replaced the generation lifecycle mixin and its implicit instance-variable/hook contract with a state-owning coordinator and typed generation-change events (#656)
+* Added structured storage health through `Coverband.storage_health`, normal JSON reports, and the MCP `get_storage_health` tool, so monitoring can distinguish healthy, stalled, data-loss, and unsupported diagnostic states (#658)
+* Added `Coverband::Adapters::ActiveSupportCacheStore`, which stores coverage in any `ActiveSupport::Cache::Store` — Redis, Memcached, files, or Solid Cache for Postgres/MySQL/SQLite. The cache target can be passed lazily (`ActiveSupportCacheStore.new { Rails.cache }`) so it works from `config/coverband.rb`, where `Rails.cache` does not exist yet (#533)
+* Trackers (views, routes, translations, query bursts) now work on non-Redis stores. They previously reached through the store to raw Redis commands, so file and memcached users got trackers that silently collected nothing and empty web UI tabs
+* Fixed the read-modify-write conflict Coverband has always had on `RedisStore`: concurrent reports could silently drop one process's contribution. Reports are now applied under a per-writer sequence, so a conflicting write is detected and repaired on the next cycle without double counting. `QueryBurstTracker` had the same conflict on its cumulative counters and is fixed the same way
+* Resets are now strong: `clear!` and `reset_recordings` retire a whole generation key, so a straggling write from before the reset cannot undo it
+* Coverband now detects when a backend has dropped its data (cache eviction, `Rails.cache.clear`) and reports it in the web UI rather than silently showing partial numbers
+* Trackers are skipped with an explanatory log line when the configured store cannot support them, instead of collecting nothing
+* Query bursts no longer count Coverband's own storage queries against the surrounding request, which would otherwise inflate query counts on a database backed cache
+* Added `persistent_coverage?`, `supports_trackers?`, and `supports_paged_reports?` capability predicates on adapters, plus `file_count` and `cached_file_count` defaults so non-Redis stores no longer raise from the web UI's datatables path
+* `redis_ttl` applies to stored coverage documents again; generation pointers deliberately never expire, since a pointer that outlived its document would leave live coverage unreachable
+* Storage reads degrade to empty and log when the backend is unavailable (an unreachable cache, or a Solid Cache table that has not been created yet) rather than raising into the request rendering the report; write failures still reach the reporting paths that log them
+* Added `rake test:solid_cache`, an ENV gated SQLite backed Solid Cache suite covering atomic pointer creation, batched pointer reads, ActiveRecord being unavailable, a missing Solid Cache schema, and Coverband's own SQL not being attributed to the request that triggered the report
+* Added `rake coverband:clear_orphans` to reclaim generation keys no longer referenced by a pointer, and scoped `coverband:clear_legacy` to Coverband's own namespaces and tracker names so it cannot delete unrelated application keys
+* CI now runs a memcached service, so the memcached backed adapter is actually exercised
+* Coverage adapters share one implementation of the merge protocol, and the generation lifecycle is shared between the session and the Redis hash repository, rather than each reimplementing the same bookkeeping
+* The web report has a dark theme. It follows the operating system through `prefers-color-scheme`, so there is nothing to configure and no toggle; every color in `public/application.css` now resolves through a custom property on `:root`, which makes the report restylable from one place. Coverage row colors are picked for contrast on the dark surface rather than darkened mechanically, so covered / missed / never / skipped stay as easy to tell apart; thanks @naofumi-fujii (#665, #666, #667)
+* Added `Coverband::Collectors::TrackerRegistry` so applications and gems can register their own trackers, along with `Coverband::Configuration.add_tracker_flag` for their enablement flags and `Coverband.configuration.tracker_for` / `Coverband.track_key` support for trackers without a dedicated accessor; bundled trackers now self-register and are initialized generically at Rails boot (#651)
+
+**Bug fixes**
+
+* Coverband's development dependencies no longer globally constrain JSON to 2.x. Legacy Rails test bundles retain their required JSON 2 constraint, while the latest-Rails suite explicitly validates Coverband against JSON 3. This constraint was development-only and never affected applications installing Coverband.
+* The web report's `/report_json` route and `JSONReport.new(store, as_report: true)` no longer raise `NoMethodError` outside Rails, where ActiveSupport's `as_json` is not loaded; thanks @dajiaohuang (#669)
+* The web report's password check accepts passwords containing `:` (it split the credentials on every colon) and compares in constant time, as does the MCP endpoint's bearer token check. This also drops the runtime dependency on the `base64` gem
+* `Coverband::Utils::Results#respond_to?(name, true)` no longer raises `ArgumentError`
+* The runtime % no longer reads 100% for files with runtime relevant lines that were never hit, and no longer divides by every line of a file that was never eager loaded. It only counts runtime hits on lines that eager loading did not cover, and takes line relevance from real coverage data rather than the never loaded placeholder, which marked blank and comment lines as relevant. Runtime relevant lines on the file page use the same calculation, and the runtime % there is colored by its own value rather than by % covered (#668)
+
 ### 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)

data/coverband.gemspec

@@ -48,21 +48,23 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "resque"
   spec.add_development_dependency "standard", ">= 1.35.1"
-  # breaking changes in various rubocop versions
-  spec.add_development_dependency "rubocop"
-
-  spec.add_development_dependency "coveralls"
   # minitest-profile is not compatible with Rails 7.1.0 setup... dropping it for now
   # spec.add_development_dependency "minitest-profile"
   spec.add_development_dependency "webmock"
-  spec.add_development_dependency "dalli" # Default memcached adapter
-  spec.add_development_dependency "mcp" # For MCP server support testing
+  spec.add_development_dependency "dalli" # memcached client for the cache adapter tests
+  # the cache adapter duck types the ActiveSupport::Cache::Store interface and
+  # never requires it, but the tests need real cache stores to run against
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "mcp", ">= 0.23" # For MCP server support testing
+
+  # Redis is optional since 7.0: it stays the default store whenever the redis gem
+  # is installed, and the ActiveSupport cache adapter covers everything else.
+  spec.add_development_dependency "redis", ">= 3.0"
 
-  # TODO: Remove when other production adapters exist
-  # because the default configuration of redis store, we really do require
-  # redis now. I was reluctant to add this, but until we offer another production
-  # quality adapter, I think this is more honest about requirements and reduces confusion
-  # without this there was a race condition on calling coverband configure before redis was loaded
-  spec.add_runtime_dependency "redis", ">= 3.0"
-  spec.add_runtime_dependency "base64"
+  spec.post_install_message = <<~MSG
+    Coverband 7.0 no longer depends on the redis gem. Redis is still the default
+    store, so if you use it add `gem "redis"` to your Gemfile. To store coverage
+    elsewhere (Solid Cache, memcached, files) see config.store in the README.
+    Coverage stored by Coverband 6.x is not carried over; see changes.md.
+  MSG
 end

data/lib/coverband/adapters/active_support_cache_store.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../storage/target"
+require_relative "../storage/session"
+require_relative "tracker_storage/factory"
+require_relative "session_coverage"
+
+module Coverband
+  module Adapters
+    ###
+    # Stores coverage in any ActiveSupport::Cache::Store: Redis, Memcached,
+    # files, and through Solid Cache, Postgres, MySQL, and SQLite -- one adapter
+    # instead of one per backend. See docs/active_support_cache_adapter_plan.md.
+    #
+    # The cache target may be given lazily, because Rails.cache does not exist
+    # while config/coverband.rb is loading:
+    #
+    #   config.store = Coverband::Adapters::ActiveSupportCacheStore.new { Rails.cache }
+    ###
+    class ActiveSupportCacheStore < Base
+      include SessionCoverage
+
+      # bumped from coverband_3_2: documents carry their metadata and keys are
+      # generation scoped, so old keys are ignored rather than migrated
+      STORAGE_FORMAT_VERSION = "coverband_cache_4_0"
+
+      attr_reader :cache_namespace
+
+      def initialize(cache = nil, opts = {}, &block)
+        super()
+        @target = Storage::Target.new(cache, &block)
+        @cache_namespace = opts[:cache_namespace] || opts[:redis_namespace] || Coverband.configuration.redis_namespace
+        @format_version = self.class::STORAGE_FORMAT_VERSION
+        @ttl = opts[:ttl]
+      end
+
+      def tracker_storage
+        @tracker_storage ||= TrackerStorage::Factory.cache(target: @target, namespace: @cache_namespace,
+          format_version: @format_version)
+      end
+
+      private
+
+      def storage_target
+        @target
+      end
+
+      def coverage_key_base(local_type)
+        [@format_version, @cache_namespace, "coverage", local_type].compact.join(".")
+      end
+    end
+  end
+end

data/lib/coverband/adapters/base.rb

@@ -35,30 +35,63 @@ module Coverband
         raise ABSTRACT_KEY
       end
 
+      # adapters return bytes or nil; presentation lives here, so a store
+      # returning the string "N/A" can't be truthy and reported as 0.00 MiB
       def size_in_mib
-        if size
-          format("%<size>.2f", size: (size.to_f / 2**20))
-        else
-          "N/A"
-        end
+        bytes = size
+        return "N/A" unless bytes.is_a?(Numeric)
+
+        format("%<size>.2f", size: (bytes.to_f / 2**20))
+      end
+
+      # tracker storage, or nil when this store can't support it; trackers are
+      # then skipped rather than left silently collecting nothing
+      def tracker_storage
+        nil
+      end
+
+      def supports_trackers?
+        !tracker_storage.nil?
+      end
+
+      # paginated / single file report loading, HashRedisStore only
+      def supports_paged_reports?
+        false
+      end
+
+      # eligible for the core coverage contract: round trips and can be counted
+      def persistent_coverage?
+        false
+      end
+
+      def file_count
+        coverage(Coverband::RUNTIME_TYPE).keys.length
+      end
+
+      def cached_file_count
+        @cached_file_count ||= file_count
       end
 
       def save_report(_report)
         raise "abstract"
       end
 
+      # this adapter's coverage: it used to route through configuration.store,
+      # quietly reporting someone else's data when the receiver was not it
       def get_coverage_report(options = {})
         coverage_cache = {}
-        data = Coverband.configuration.store.split_coverage(Coverband::TYPES, coverage_cache, options)
-        data.merge(Coverband::MERGED_TYPE => Coverband.configuration.store.merged_coverage(Coverband::TYPES, coverage_cache))
+        data = split_coverage(Coverband::TYPES, coverage_cache, options)
+        data.merge(Coverband::MERGED_TYPE => merged_coverage(Coverband::TYPES, coverage_cache))
       end
 
       def covered_files
         coverage.keys || []
       end
 
-      def raw_store
-        raise ABSTRACT_KEY
+      # Optional maintenance capability. Redis-backed adapters return an object
+      # that can enumerate and safely clean Coverband-owned keys.
+      def cleanup
+        nil
       end
 
       protected
@@ -79,7 +112,6 @@ module Coverband
         Coverband::Utils::FileHasher.hash_file(file)
       end
 
-      # TODO: modify to extend report inline?
       def expand_report(report)
         expanded = {}
         report_time = Time.now.to_i

data/lib/coverband/adapters/file_store.rb

@@ -69,8 +69,8 @@ module Coverband
         File.write(path, JSON.dump(data))
       end
 
-      def raw_store
-        raise NotImplementedError, "FileStore doesn't support raw_store"
+      def persistent_coverage?
+        true
       end
 
       private

data/lib/coverband/adapters/hash_redis_store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require_relative "tracker_storage/factory"
 
 module Coverband
   module Adapters
@@ -34,7 +35,7 @@ module Coverband
 
       def supported?
         Gem::Version.new(@redis.info["redis_version"]) >= Gem::Version.new("2.6.0")
-      rescue Redis::CannotConnectError => e
+      rescue *Coverband.redis_connection_errors => e
         Coverband.configuration.logger.info "Redis is not available (#{e}), Coverband not configured"
         Coverband.configuration.logger.info "If this is a setup task like assets:precompile feel free to ignore"
       end
@@ -184,8 +185,26 @@ module Coverband
         @cached_file_count ||= file_count(Coverband::RUNTIME_TYPE)
       end
 
-      def raw_store
-        @redis
+      def cleanup
+        RedisCleanup.new(@redis, namespace: @redis_namespace)
+      end
+
+      def persistent_coverage?
+        true
+      end
+
+      ###
+      # Coverage storage here is unchanged: LUA scripts and per file keys avoid
+      # the merge conflict entirely. Tracker storage is shared across adapters,
+      # so this store picks it up like any other.
+      ###
+      def tracker_storage
+        @tracker_storage ||= TrackerStorage::Factory.redis(redis: @redis, namespace: @redis_namespace,
+          format_version: REDIS_STORAGE_FORMAT_VERSION)
+      end
+
+      def supports_paged_reports?
+        true
       end
 
       def size

data/lib/coverband/adapters/null_store.rb

@@ -29,10 +29,6 @@ module Coverband
       def save_report(report)
         # NOOP
       end
-
-      def raw_store
-        raise NotImplementedError, "NullStore doesn't support raw_store"
-      end
     end
   end
 end

data/lib/coverband/adapters/redis_cleanup.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Adapters
+    ###
+    # The narrow maintenance interface shared by Redis-backed adapters. Key
+    # discovery and deletion stay here so callers never need the raw client or
+    # knowledge of Coverband's Redis formats.
+    ###
+    class RedisCleanup
+      GRACE_SECONDS = 3600
+      TRACKERS = %w[ViewTracker RouteTracker TranslationTracker QueryBurstTracker].freeze
+
+      def initialize(redis, namespace: nil)
+        @redis = redis
+        @namespace = namespace
+      end
+
+      def clear_legacy!
+        patterns = legacy_formats.map { |format| "#{format}*" }
+        [@namespace, nil].uniq.each do |namespace|
+          TRACKERS.each do |tracker|
+            prefix = namespace ? "#{namespace}_#{tracker}" : tracker
+            patterns << "#{prefix}_tracker"
+            patterns << "#{prefix}_tracker_time"
+          end
+        end
+
+        delete_matching(patterns)
+      end
+
+      def clear_orphans!
+        orphan_formats.sum { |format| remove_orphans(format) }
+      end
+
+      private
+
+      ###
+      # A generation is garbage only while its pointer names something else.
+      # Rechecking immediately before deletion protects a generation made live
+      # by a concurrent reset. Young or uncertain generations are retained.
+      ###
+      def remove_orphans(format)
+        removed = 0
+
+        @redis.scan_each(match: "#{format}*.g*").to_a.uniq.each do |key|
+          base = key[/\A(.*)\.g[^.]*\z/, 1]
+          token = key[/\.g([^.]*)\z/, 1]
+          next unless base && token
+
+          pointer = read_pointer("#{base}.pointer")
+          next if pointer && pointer["token"] == token
+          next if recently_written?(key)
+
+          removed += @redis.del(key)
+        end
+
+        removed
+      end
+
+      def read_pointer(key)
+        raw = @redis.get(key)
+        raw ? JSON.parse(raw) : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      def recently_written?(key)
+        idle = @redis.object("idletime", key)
+        idle ? idle < GRACE_SECONDS : true
+      rescue
+        # If Redis cannot establish the age, retaining the key is safest.
+        true
+      end
+
+      def legacy_formats
+        %w[coverband_3_2 coverband_hash_3_2 coverband_hash_4_0] - current_formats
+      end
+
+      def current_formats
+        [
+          RedisStore::REDIS_STORAGE_FORMAT_VERSION,
+          HashRedisStore::REDIS_STORAGE_FORMAT_VERSION,
+          ActiveSupportCacheStore::STORAGE_FORMAT_VERSION
+        ].uniq
+      end
+
+      def orphan_formats
+        [
+          RedisStore::REDIS_STORAGE_FORMAT_VERSION,
+          HashRedisStore::REDIS_STORAGE_FORMAT_VERSION
+        ].uniq
+      end
+
+      def delete_matching(patterns)
+        keys = patterns.flat_map { |pattern| @redis.scan_each(match: pattern).to_a }.uniq
+        keys.any? ? @redis.del(*keys) : 0
+      end
+    end
+  end
+end

data/lib/coverband/adapters/redis_store.rb

@@ -1,17 +1,28 @@
 # frozen_string_literal: true
 
+require_relative "../storage/redis_target"
+require_relative "../storage/session"
+require_relative "tracker_storage/factory"
+require_relative "session_coverage"
+
 module Coverband
   module Adapters
     ###
     # RedisStore store a merged coverage file to redis
     ###
     class RedisStore < Base
+      include SessionCoverage
+
       ###
       # This key isn't related to the coverband version, but to the internal format
       # used to store data to redis. It is changed only when breaking changes to our
       # redis format are required.
+      #
+      # Bumped from coverband_3_2 for 7.0: coverage documents now carry the
+      # metadata the merge protocol needs, and keys are generation scoped. There
+      # is no migration; old keys are ignored.
       ###
-      REDIS_STORAGE_FORMAT_VERSION = "coverband_3_2"
+      REDIS_STORAGE_FORMAT_VERSION = "coverband_5_0"
 
       attr_reader :redis_namespace
 
@@ -21,85 +32,41 @@ module Coverband
         @ttl = opts[:ttl]
         @redis_namespace = opts[:redis_namespace]
         @format_version = REDIS_STORAGE_FORMAT_VERSION
-        @keys = {}
-        Coverband::TYPES.each do |type|
-          @keys[type] = [@format_version, @redis_namespace, type].compact.join(".")
-        end
-      end
-
-      def clear!
-        Coverband::TYPES.each do |type|
-          @redis.del(type_base_key(type))
-        end
-      end
-
-      def clear_file!(filename)
-        Coverband::TYPES.each do |type|
-          data = coverage(type)
-          data.delete(filename)
-          save_coverage(data, type)
-        end
-      end
-
-      def size
-        @redis.get(base_key) ? @redis.get(base_key).bytesize : "N/A"
-      end
-
-      def type=(type)
-        super
-        reset_base_key
       end
 
-      def coverage(local_type = nil, opts = {})
-        local_type ||= opts.key?(:override_type) ? opts[:override_type] : type
-        data = redis.get type_base_key(local_type)
-        data = data ? JSON.parse(data) : {}
-        data.delete_if { |file_path, file_data| file_hash(file_path) != file_data["file_hash"] } unless opts[:skip_hash_check]
-        data
+      def tracker_storage
+        sync_target
+        @tracker_storage ||= TrackerStorage::Factory.redis(redis: @redis, namespace: @redis_namespace,
+          format_version: @format_version)
       end
 
-      # Note: This could lead to slight race on redis
-      # where multiple processes pull the old coverage and add to it then push
-      # the Coverband 2 had the same issue,
-      # and the tradeoff has always been acceptable
-      def save_report(report)
-        data = merge_reports(report, coverage(nil, skip_hash_check: true))
-        save_coverage(data)
-      end
-
-      def raw_store
-        @redis
-      end
-
-      def file_count
-        data = redis.get type_base_key(Coverband::RUNTIME_TYPE)
-        JSON.parse(data).keys.length
-      end
-
-      def cached_file_count
-        @cached_file_count ||= file_count
+      def cleanup
+        RedisCleanup.new(@redis, namespace: @redis_namespace)
       end
 
       private
 
       attr_reader :redis
 
-      def reset_base_key
-        @base_key = nil
-      end
+      ###
+      # The client can be swapped after construction, and a different client is
+      # a different database: cached generation tokens and unconfirmed deltas
+      # from the old one would be meaningless against the new one.
+      ###
+      def sync_target
+        return @target if @target && @target.redis.equal?(@redis)
 
-      def base_key
-        @base_key ||= [@format_version, @redis_namespace, type].compact.join(".")
+        sessions.clear
+        @tracker_storage = nil
+        @target = Storage::RedisTarget.new(@redis, ttl: @ttl)
       end
 
-      def type_base_key(local_type)
-        @keys[local_type]
+      def storage_target
+        sync_target
       end
 
-      def save_coverage(data, local_type = nil)
-        local_type ||= type
-        redis.set type_base_key(local_type), data.to_json
-        redis.expire(type_base_key(local_type), @ttl) if @ttl
+      def coverage_key_base(local_type)
+        [@format_version, @redis_namespace, "coverage", local_type].compact.join(".")
       end
     end
   end