coverband 6.0.3.rc.3 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7076b5973080adc6d9fc4ddeadf8baa92d19e04f0d8f2e1ef961ac3075737448
-  data.tar.gz: aca8e906625af383fbae32139836e8c93113d89e9b17ca323708aed3b5b46ee7
+  metadata.gz: 21e62f4add1bcd44cacd630e37e291a38ecfb924d8fa48698ecbe4ba69a99471
+  data.tar.gz: 4cc4dfd1289bdf13f77c78a7deb399c18075ec53a835abb45fa11011d0815bd4
 SHA512:
-  metadata.gz: 302bf319119b5c1c3911da3591db34170717a53b9d9af32aee1f04b87171115daa6f97502c1e2d2d06180c7ba9c24ca675e5b09c6f19473bffb98838c5765f6f
-  data.tar.gz: 0a65eb875a43605f1ef355b6bc268728763e8c6a64e1a5566388fbbd685714e8db6ef48e38849a4d1de5b5b34e984782512b9ffe9a37446b3549f82fa586701a
+  metadata.gz: 2bcf294b5d07fc508b1468b0e3a2d993d15b1dae067bd147ca1d55ebc444cf6f7157fbd6e5afee205a7fa9e3648bee9fdab66cec6573ff31605c417346c858a3
+  data.tar.gz: 282523aea85ea90943c6a8bbf595a3c135f7a95534ac2046ccfeb379cea252ad4889b3e31799de8917b3b989a9492f55fee032f302f8aa8a8c619e870941c79c

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -28,11 +28,5 @@ If applicable, add screenshots to help explain your problem.
  - Browser [e.g. chrome, safari]
  - Version [e.g. 22]
 
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
 **Additional context**
 Add any other context about the problem here.

data/.github/workflows/main.yml

@@ -26,7 +26,7 @@ jobs:
     runs-on: ${{ matrix.os }}-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: supercharge/redis-github-action@1.2.0
+      - uses: supercharge/redis-github-action@1.8.0
         with:
           redis-version: ${{ matrix.redis-version }}
       - uses: ruby/setup-ruby@v1

data/README.md

@@ -101,6 +101,22 @@ run ActionController::Dispatcher.new
 
   This triggers coverage collection on the current webserver process. Useful in development but confusing in production environments where many ruby processes are usually running.
 
+#### Interpreting results
+
+The columns in the web UI are as follows:
+
+- **% covered** - Percentage of total relevant lines covered
+- **% runtime** - Percentage of the runtime lines covered where runtime lines are lines that are hit after the application has been eagerly loaded
+- **Lines** - Total lines in the file including lines unreachable or uncover-able. An unreachable line would be an empty line with no code, comments, or `end` statements.
+- **Relevant lines** - Lines that are coverable, i.e. not empty
+- **Lines runtime** - Total lines minus uncoverable lines minus the lines that are only hit during eager loading of application
+- **Lines missed** - Relevant lines not covered
+- **Avg hits/line** - Total of coverage to the file divided by relevant lines.
+
+When viewing an individual file, a line of code such as a class or method definition may appear green because it is eager loaded by the application, but still not be hit at all in runtime by actual users.  
+
+![example of a file with lines not hit at runtime](https://user-images.githubusercontent.com/96786/63541229-aa98a580-c4eb-11e9-8eb8-c004fe1369db.png)
+
 ### Mounting as a Rack App
 
 Coverband comes with a mountable rack app for viewing reports. For Rails this can be done in `config/routes.rb` with:
@@ -191,7 +207,7 @@ Do you use figaro, mc-settings, dotenv or something else to inject environment v
 For example if you use dotenv, you need to do this, see https://github.com/bkeepers/dotenv#note-on-load-order
 
 ```
-gem 'dotenv-rails', require: 'dotenv/rails-now'
+gem 'dotenv-rails', require: 'dotenv/load'
 gem 'coverband'
 gem 'other-gem-that-requires-env-variables'
 ```
@@ -222,6 +238,14 @@ This feature is enabled by default. To stop this feature, disable the feature in
 
 ![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_view_tracker.png)
 
+### Hiding settings
+
+Coverband provides a view of all of its current settings. Sometimes you might want to hide this view,
+such as when sharing coverband data with a large number of developers of varying trust levels.
+You can disable the settings view like so:
+
+`config.hide_settings = false`
+
 ### 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`.

data/changes.md

@@ -1,3 +1,21 @@
+### Coverband 6.1.0
+
+This release has a number of smaller fixes and improvements. It includes a sizable refactoring around the UI which should simplify improvements going forward. This release is mostly targetting large projects with 6K+ ruby files, use the new `config.paged_reporting = true` option with the HashRedisStore to enable paged reporting for large projects. The HashRedisStore now also includes the last time a line in a file was executed.
+
+* Thanks to @FeLvi-zzz for the last time accessed support for the Hash Redis Store
+* Thanks to @alpaca-tc for the improvements on the route tracker
+* Thanks to @ydah for typo fixes, doc updates, adding ruby 3.3 to build matrix, improvements on CI, standardrb fixes
+* Thanks to @trivett, @khaled-badenjki, @IsabelleLePivain  for improved docs
+* Thanks to @prastamaha for the memcached adapter
+* Thanks to @ursm for a yaml fix
+* Thanks to @Drowze for a layered cache approach for perf improvements
+* Thanks to @vs37559 for a sinatra pandrino fix
+* This release addresses large projects and adds in paged reporting
+  * to ensure even on projects with 10K+ files it can load on heroku under the 30s timeout
+  * only supports HashRedis store
+  * faster UI for web UI in general which should be noticable on non paged reports
+  * reduce redis calls
+
 ### Coverband 6.0.2
 
 * thanks makicamel for improved deferred eager loading
@@ -11,16 +29,12 @@
 
 ### Coverband 6.0.0
 
-__NOTE: I ended up having 5.2.6 in various RCs for a long time, mostly because I had some breaking changes that were related to dropping support for old versions of Ruby and Rails__
-
 * The 6.0.0 release is all that was the 6 different RC releases of 5.2.6
 * Added Rails test matrix to github actions to test on all the supported versions
   - Rails: 6.0.x, 6.1.x, 7.0.x, 7.1.x
 
 ### Coverband 5.2.6
 
-__NOTE: the current RCs include below, but this might turn into coverband 6.0__
-
 - add support for translation keys
 - refactor non Coverage.so based trackers
 - adds CSP report support (thanks @jwg2s)

data/coverband.gemspec

@@ -34,18 +34,20 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "capybara"
   spec.add_development_dependency "m"
   spec.add_development_dependency "memory_profiler"
-  # breaking change in minitest and mocha
+  # breaking change in minitest and mocha...
+  # note: we are also adding 'spy' as mocha doesn't want us to spy on redis calls...
+  # ^^^ probably need a large test cleanup refactor
   spec.add_development_dependency "minitest", "= 5.18.1"
   spec.add_development_dependency "minitest-fork_executor"
   spec.add_development_dependency "minitest-stub-const"
   spec.add_development_dependency "mocha", "~> 1.7.0"
-  # spec.add_development_dependency "spy"
   spec.add_development_dependency "rack"
   spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "resque"
-  spec.add_development_dependency "standard", "~> 1.34.0"
-  spec.add_development_dependency "standardrb"
+  spec.add_development_dependency "standard", "= 1.34.0"
+  # breaking changes in various rubocop versions
+  spec.add_development_dependency "rubocop", "= 1.60.0"
 
   spec.add_development_dependency "coveralls"
   # minitest-profile is not compatible with Rails 7.1.0 setup... dropping it for now

data/lib/coverband/adapters/hash_redis_store.rb

@@ -89,7 +89,7 @@ module Coverband
       # used to store data to redis. It is changed only when breaking changes to our
       # redis format are required.
       ###
-      REDIS_STORAGE_FORMAT_VERSION = "coverband_hash_3_3"
+      REDIS_STORAGE_FORMAT_VERSION = "coverband_hash_4_0"
 
       JSON_PAYLOAD_EXPIRATION = 5 * 60
 
@@ -107,7 +107,7 @@ module Coverband
         @relative_file_converter = opts[:relative_file_converter] || Utils::RelativeFileConverter
 
         @get_coverage_cache = if opts[:get_coverage_cache]
-          key_prefix = [REDIS_STORAGE_FORMAT_VERSION, @redis_namespace, "v2"].compact.join(".")
+          key_prefix = [REDIS_STORAGE_FORMAT_VERSION, @redis_namespace].compact.join(".")
           GetCoverageRedisCacheStore.new(redis, key_prefix)
         else
           GetCoverageNullCacheStore
@@ -116,8 +116,8 @@ module Coverband
 
       def supported?
         Gem::Version.new(@redis.info["redis_version"]) >= Gem::Version.new("2.6.0")
-      rescue Redis::CannotConnectError => error
-        Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
+      rescue Redis::CannotConnectError => 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
 
@@ -149,7 +149,7 @@ module Coverband
         updated_time = (type == Coverband::EAGER_TYPE) ? nil : report_time
         keys = []
         report.each_slice(@save_report_batch_size) do |slice|
-          files_data = slice.map { |(file, data)|
+          files_data = slice.map do |(file, data)|
             relative_file = @relative_file_converter.convert(file)
             file_hash = file_hash(relative_file)
             key = key(relative_file, file_hash: file_hash)
@@ -162,29 +162,33 @@ module Coverband
               report_time: report_time,
               updated_time: updated_time
             )
-          }
+          end
           next unless files_data.any?
 
           arguments_key = [@redis_namespace, SecureRandom.uuid].compact.join(".")
           @redis.set(arguments_key, {ttl: @ttl, files_data: files_data}.to_json, ex: JSON_PAYLOAD_EXPIRATION)
-          @redis.evalsha(hash_incr_script, [arguments_key])
+          @redis.evalsha(hash_incr_script, [arguments_key], [report_time])
         end
         @redis.sadd(files_key, keys) if keys.any?
       end
 
-      # TODO: refactor this and the method below and consider removing all the cached results stuff
+      # NOTE: This method should be used for full coverage or filename coverage look ups
+      # When paging code should use coverage_for_types and pull eager and runtime together as matched pairs
       def coverage(local_type = nil, opts = {})
         page_size = opts[:page_size] || 250
         cached_results = @get_coverage_cache.fetch(local_type || type) do |sleep_time|
           files_set = if opts[:page]
-            files_set(local_type).each_slice(page_size).to_a[opts[:page] - 1] || {}
+            raise "call coverage_for_types with paging"
           elsif opts[:filename]
-            # TODO: this probably needs to be an exact match of the parsed cache key section
-            files_set(local_type).select{ |cache_key| cache_key.match(short_name(opts[:filename])) } || {}
+            type_key_prefix = key_prefix(local_type)
+            # NOTE: a better way to extract filename from key would be better
+            files_set(local_type).select do |cache_key|
+              cache_key.sub(type_key_prefix, "").match(short_name(opts[:filename]))
+            end || {}
           else
             files_set(local_type)
           end
-          # use batches with a sleep in between to avoid overloading redis
+          # below uses batches with a sleep in between to avoid overloading redis
           files_set.each_slice(page_size).flat_map do |key_batch|
             sleep sleep_time
             @redis.pipelined do |pipeline|
@@ -200,33 +204,25 @@ module Coverband
         end
       end
 
-      # TODO: fix this before shipping main line release
-      # def split_coverage(types, coverage_cache, options = {})
-      #   if types.is_a?(Array)
-      #     coverage_for_types(types, options)
-      #   else
-      #     super
-      #   end
-      # end
-
-      # NOTE: when using paging we need to ensure we have the same set of files per page in runtime and eager
-      # TODO: This merge of eager and runtime isn't working fix later...
-      def coverage_for_types(types, opts = {})
-        page_size = opts[:page_size] || 250
+      def split_coverage(types, coverage_cache, options = {})
+        if types.is_a?(Array) && !options[:filename] && options[:page]
+          data = coverage_for_types(types, options)
+          coverage_cache[Coverband::RUNTIME_TYPE] = data[Coverband::RUNTIME_TYPE]
+          coverage_cache[Coverband::EAGER_TYPE] = data[Coverband::EAGER_TYPE]
+          data
+        else
+          super
+        end
+      end
 
-        local_type = Coverband::RUNTIME_TYPE
+      def coverage_for_types(_types, opts = {})
+        page_size = opts[:page_size] || 250
         hash_data = {}
 
-        runtime_file_set = if opts[:page]
-          files_set(local_type).each_slice(page_size).to_a[opts[:page] - 1] || {}
-        elsif opts[:filename]
-          # TODO: this probably needs to be an exact match of the parsed cache key section
-          # match is a hack that will only kind of work
-          files_set(local_type).select{ |cache_key| cache_key.match(short_name(opts[:filename])) } || {}
-        else
-          files_set(local_type)
-        end
-        
+        runtime_file_set = files_set(Coverband::RUNTIME_TYPE)
+        @cached_file_count = runtime_file_set.length
+        runtime_file_set = runtime_file_set.each_slice(page_size).to_a[opts[:page] - 1] || []
+
         hash_data[Coverband::RUNTIME_TYPE] = runtime_file_set.each_slice(page_size).flat_map do |key_batch|
           @redis.pipelined do |pipeline|
             key_batch.each do |key|
@@ -235,12 +231,14 @@ module Coverband
           end
         end
 
-        # TODO: debug the set isn't just paths it has other key details including coverage type so below probalby fails
-        # match is a hack that will work a sometimes... fix this but it will prove out if this solves the perf issue
+        eager_key_pre = key_prefix(Coverband::EAGER_TYPE)
+        runtime_key_pre = key_prefix(Coverband::RUNTIME_TYPE)
         matched_file_set = files_set(Coverband::EAGER_TYPE)
-          .select { |eager_key, val| runtime_file_set.any?{ |runtime_key|
-          (eager_key.match(/\.\.(.*).rb/) && eager_key.match(/\.\.(.*).rb/)[0]==runtime_key.match(/\.\.(.*).rb/)[0]) }
-          } || {}
+          .select do |eager_key, _val|
+          runtime_file_set.any? do |runtime_key|
+            (eager_key.sub(eager_key_pre, "") == runtime_key.sub(runtime_key_pre, ""))
+          end
+        end || []
         hash_data[Coverband::EAGER_TYPE] = matched_file_set.each_slice(page_size).flat_map do |key_batch|
           @redis.pipelined do |pipeline|
             key_batch.each do |key|
@@ -259,13 +257,17 @@ module Coverband
 
       def short_name(filename)
         filename.sub(/^#{Coverband.configuration.root}/, ".")
-          .gsub(%r{^\.\/}, "")
+          .gsub(%r{^\./}, "")
       end
 
       def file_count(local_type = nil)
         files_set(local_type).count { |filename| !Coverband.configuration.ignore.any? { |i| filename.match(i) } }
       end
 
+      def cached_file_count
+        @cached_file_count ||= file_count(Coverband::RUNTIME_TYPE)
+      end
+
       def raw_store
         @redis
       end
@@ -287,9 +289,14 @@ module Coverband
         return unless file_hash(file) == data_from_redis[FILE_HASH]
 
         data = coverage_data_from_redis(data_from_redis)
-        hash[file] = data_from_redis.select { |meta_data_key, _value| META_DATA_KEYS.include?(meta_data_key) }.merge!("data" => data)
-        hash[file][LAST_UPDATED_KEY] = (hash[file][LAST_UPDATED_KEY].nil? || hash[file][LAST_UPDATED_KEY] == "") ? nil : hash[file][LAST_UPDATED_KEY].to_i
-        hash[file].merge!(LAST_UPDATED_KEY => hash[file][LAST_UPDATED_KEY], FIRST_UPDATED_KEY => hash[file][FIRST_UPDATED_KEY].to_i)
+        timedata = coverage_time_data_from_redis(data_from_redis)
+        hash[file] = data_from_redis.select do |meta_data_key, _value|
+          META_DATA_KEYS.include?(meta_data_key)
+        end.merge!("data" => data, "timedata" => timedata)
+        hash[file][LAST_UPDATED_KEY] =
+          (hash[file][LAST_UPDATED_KEY].nil? || hash[file][LAST_UPDATED_KEY] == "") ? nil : hash[file][LAST_UPDATED_KEY].to_i
+        hash[file].merge!(LAST_UPDATED_KEY => hash[file][LAST_UPDATED_KEY],
+          FIRST_UPDATED_KEY => hash[file][FIRST_UPDATED_KEY].to_i)
       end
 
       def coverage_data_from_redis(data_from_redis)
@@ -300,10 +307,18 @@ module Coverband
         end
       end
 
+      def coverage_time_data_from_redis(data_from_redis)
+        max = data_from_redis[FILE_LENGTH_KEY].to_i - 1
+        Array.new(max + 1) do |index|
+          unixtime = data_from_redis["#{index}_last_posted"]
+          unixtime.nil? ? nil : Time.at(unixtime.to_i)
+        end
+      end
+
       def script_input(key:, file:, file_hash:, data:, report_time:, updated_time:)
-        coverage_data = data.each_with_index.each_with_object({}) { |(coverage, index), hash|
+        coverage_data = data.each_with_index.each_with_object({}) do |(coverage, index), hash|
           hash[index] = coverage if coverage
-        }
+        end
         meta = {
           first_updated_at: report_time,
           file: file,

data/lib/coverband/adapters/memcached_store.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Adapters
+    class MemcachedStore < Base
+      STORAGE_FORMAT_VERSION = "coverband_3_2"
+
+      attr_reader :memcached_namespace
+
+      def initialize(memcached, opts = {})
+        super()
+        @memcached = memcached
+        @memcached_namespace = opts[:memcached_namespace]
+        @format_version = STORAGE_FORMAT_VERSION
+        @keys = {}
+        Coverband::TYPES.each do |type|
+          @keys[type] = [@format_version, @memcached_namespace, type].compact.join(".")
+        end
+      end
+
+      def clear!
+        Coverband::TYPES.each do |type|
+          @memcached.delete(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
+        @memcached.read(base_key) ? @memcached.read(base_key).bytesize : "N/A"
+      end
+
+      def migrate!
+        raise NotImplementedError, "MemcachedStore doesn't support migrations"
+      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 = memcached.read(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
+      end
+
+      def save_report(report)
+        data = report.dup
+        data = merge_reports(data, coverage(nil, skip_hash_check: true))
+        save_coverage(data)
+      end
+
+      def raw_store
+        raise NotImplementedError, "MemcachedStore doesn't support raw_store"
+      end
+
+      attr_reader :memcached
+
+      private
+
+      def reset_base_key
+        @base_key = nil
+      end
+
+      def base_key
+        @base_key ||= [@format_version, @memcached_namespace, type].compact.join(".")
+      end
+
+      def type_base_key(local_type)
+        @keys[local_type]
+      end
+
+      def save_coverage(data, local_type = nil)
+        local_type ||= type
+        key = type_base_key(local_type)
+        memcached.write(key, data.to_json)
+      end
+    end
+  end
+end

data/lib/coverband/collectors/route_tracker.rb

@@ -25,7 +25,10 @@ module Coverband
       # and ensure high performance
       ###
       def track_key(payload)
-        route = if payload[:request]
+        route = if payload.key?(:location)
+          # For redirect.action_dispatch
+          return unless Coverband.configuration.track_redirect_routes
+
           {
             controller: nil,
             action: nil,
@@ -33,6 +36,7 @@ module Coverband
             verb: payload[:request].method
           }
         else
+          # For start_processing.action_controller
           {
             controller: payload[:params]["controller"],
             action: payload[:action],
@@ -40,11 +44,10 @@ module Coverband
             verb: payload[:method]
           }
         end
-        if route
-          if newly_seen_key?(route)
-            @logged_keys << route
-            @keys_to_record << route if track_key?(route)
-          end
+
+        if newly_seen_key?(route)
+          @logged_keys << route
+          @keys_to_record << route if track_key?(route)
         end
       end
 

data/lib/coverband/configuration.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module Coverband
+  ###
+  # Configuration parsing and options for the coverband gem.
+  ###
   class Configuration
     attr_accessor :root_paths, :root,
       :verbose,
@@ -9,15 +12,15 @@ module Coverband
       :test_env, :web_enable_clear, :gem_details, :web_debug, :report_on_exit,
       :simulate_oneshot_lines_coverage,
       :view_tracker, :defer_eager_loading_data,
-      :track_routes, :route_tracker,
+      :track_routes, :track_redirect_routes, :route_tracker,
       :track_translations, :translations_tracker,
-      :trackers, :csp_policy
+      :trackers, :csp_policy, :hide_settings
 
     attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id,
       :s3_secret_access_key, :password, :api_key, :service_url, :coverband_timeout, :service_dev_mode,
       :service_test_mode, :process_type, :track_views, :redis_url,
       :background_reporting_sleep_seconds, :reporting_wiggle,
-      :send_deferred_eager_loading_data
+      :send_deferred_eager_loading_data, :paged_reporting
 
     attr_reader :track_gems, :ignore, :use_oneshot_lines_coverage
 
@@ -74,6 +77,7 @@ module Coverband
       @track_views = true
       @view_tracker = nil
       @track_routes = false
+      @track_redirect_routes = true
       @route_tracker = nil
       @track_translations = false
       @translations_tracker = nil
@@ -86,6 +90,7 @@ module Coverband
       @all_root_patterns = nil
       @password = nil
       @csp_policy = false
+      @hide_settings = false
 
       # coverband service settings
       @api_key = nil
@@ -131,8 +136,8 @@ module Coverband
         trackers << Coverband.configuration.view_tracker
       end
       trackers.each { |tracker| tracker.railtie! }
-    rescue Redis::CannotConnectError => error
-      Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
+    rescue Redis::CannotConnectError => 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
 
@@ -169,7 +174,10 @@ module Coverband
 
     def store
       @store ||= if service?
-        raise "invalid configuration: unclear default store coverband expects either api_key or redis_url" if ENV["COVERBAND_REDIS_URL"]
+        if ENV["COVERBAND_REDIS_URL"]
+          raise "invalid configuration: unclear default store coverband expects either api_key or redis_url"
+        end
+
         require "coverband/adapters/web_service_store"
         Coverband::Adapters::WebServiceStore.new(service_url)
       else
@@ -179,8 +187,14 @@ module Coverband
 
     def store=(store)
       raise "Pass in an instance of Coverband::Adapters" unless store.is_a?(Coverband::Adapters::Base)
-      raise "invalid configuration: only coverband service expects an API Key" if api_key && store.class.to_s != "Coverband::Adapters::WebServiceStore"
-      raise "invalid configuration: coverband service shouldn't have redis url set" if ENV["COVERBAND_REDIS_URL"] && store.instance_of?(::Coverband::Adapters::WebServiceStore)
+      if api_key && store.class.to_s != "Coverband::Adapters::WebServiceStore"
+        raise "invalid configuration: only coverband service expects an API Key"
+      end
+      if ENV["COVERBAND_REDIS_URL"] &&
+          defined?(::Coverband::Adapters::WebServiceStore) &&
+          store.instance_of?(::Coverband::Adapters::WebServiceStore)
+        raise "invalid configuration: coverband service shouldn't have redis url set"
+      end
 
       @store = store
     end
@@ -240,7 +254,10 @@ module Coverband
     end
 
     def use_oneshot_lines_coverage=(value)
-      raise(StandardError, "One shot line coverage is only available in ruby >= 2.6") unless one_shot_coverage_implemented_in_ruby_version? || !value
+      unless one_shot_coverage_implemented_in_ruby_version? || !value
+        raise(StandardError,
+          "One shot line coverage is only available in ruby >= 2.6")
+      end
 
       @use_oneshot_lines_coverage = value
     end
@@ -293,6 +310,10 @@ module Coverband
       @send_deferred_eager_loading_data
     end
 
+    def paged_reporting
+      !!@paged_reporting
+    end
+
     def service_disabled_dev_test_env?
       return false unless service?
 
@@ -317,7 +338,7 @@ module Coverband
     end
 
     def track_gems=(_value)
-      puts "gem tracking is deprecated, setting this will be ignored"
+      puts "gem tracking is deprecated, setting this will be ignored & eventually removed"
     end
 
     private

data/lib/coverband/reporters/json_report.rb

@@ -30,6 +30,18 @@ module Coverband
 
       private
 
+      def coverage_css_class(covered_percent)
+        if covered_percent.nil?
+          ""
+        elsif covered_percent > 90
+          "green"
+        elsif covered_percent > 80
+          "yellow"
+        else
+          "red"
+        end
+      end
+
       def report_as_json
         result = Coverband::Utils::Results.new(filtered_report_files)
         source_files = result.source_files
@@ -42,16 +54,16 @@ module Coverband
         if as_report
           row_data = []
           data[:files].each_pair do |key, data|
-            source_class = data[:never_loaded] ? 'strong red' : 'strong'
-            data_loader_url="#{base_path}load_file_details?filename=#{data[:filename]}"
-            # class=\"src_link cboxElement\
-            link = "<a href=\"##{data[:hash]}\" class=\"cboxElement\" title=\"#{key}\" data-loader-url=\"#{data_loader_url}\" onclick=\"src_link_click(this)\">#{key}</a>"
-            # Started GET "/config/coverage/load_file_details?filename=/home/danmayer/projects/coverband_rails_example/app/jobs/application_job.rb" for ::1 at 2024-03-05 16:02:33 -0700
-            # class="<%= coverage_css_class(source_file.covered_percent) %> strong"
+            source_class = data[:never_loaded] ? "strong red" : "strong"
+            data_loader_url = "#{base_path}load_file_details?filename=#{data[:filename]}"
+            link = "<a href=\"##{data[:hash]}\" class=\"src_link #{source_class} cboxElement\" title=\"#{key}\" data-loader-url=\"#{data_loader_url}\" onclick=\"src_link_click(this)\">#{key}</a>"
+            # Hack to ensure the sorting works on percentage columns, the span is hidden but colors the cell and the text is used for sorting
+            covered_percent = "#{data[:covered_percent]} <span class=\"#{coverage_css_class(data[:covered_percent])}\">&nbsp;</span>"
+            runtime_percentage = "#{data[:runtime_percentage]}<span class=\"#{coverage_css_class(data[:runtime_percentage])}\">&nbsp;</span>"
             row_data << [
               link,
-              data[:covered_percent].to_s,
-              data[:runtime_percentage].to_s,
+              covered_percent,
+              runtime_percentage,
               data[:lines_of_code].to_s,
               (data[:lines_covered] + data[:lines_missed]).to_s,
               data[:lines_covered].to_s,
@@ -60,7 +72,7 @@ module Coverband
               data[:covered_strength].to_s
             ]
           end
-          filesreported = store.file_count(:runtime)
+          filesreported = store.cached_file_count
           data["iTotalRecords"] = filesreported
           data["iTotalDisplayRecords"] = filesreported
           data["aaData"] = row_data