coverband 6.0.1 → 6.0.3.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 036f9cdceb426dd675d4e6d78af901a6618dee5062fc5572b47ce90518ffbb1f
-  data.tar.gz: d1d1d8f6c1cf4123d34ae630cd92767d673e1e04e4ef0f18660327c481b309f0
+  metadata.gz: f25f2799e62201b31472588ed6ee3d00697b6ab8eba5beb04c3a76cb7e52d962
+  data.tar.gz: 599a0d1a4ef26b9b353d4ae341db2287f15b5119b9d9d3ed3d2b0e796c6e1fae
 SHA512:
-  metadata.gz: a10c5a56f2ef1cb15e42f5f52f4636432fa0bb779276e44dd719b06474d51da7529b03334d8d0a383fe25b38af932bc0d32c67e3c527aaa568bd9ab35466eb9e
-  data.tar.gz: 9be31a11af5c7d490e2f965a8e91f1fc916668efa3ec384afc88f78225a880056d3b3ae5dc4e1193be87e63a0d2cb07f35c72c4268018cf01e357c7d9835d3ae
+  metadata.gz: b58f4486c028a9ed4f2e3444ed164a43b620b4cc213f91e9b7aef93c2ef1c394840aade62466b216f29ade57851314989e0ed3f3bca2a7f692deddd106efe7a3
+  data.tar.gz: 6569ffaeb15feb24b4eb40d5e0403bcf4fcc6fc381a7fd30e64a9e6a7fee06498e05ffe2832c7a99545c51a8b25a12cf6264daf672ef82485ccf10e03a3895a3

data/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

data/.github/workflows/main.yml

@@ -20,13 +20,12 @@ jobs:
         # truffleruby-head,
         # removing jruby again to flaky
         gemfile: [ Gemfile.rails6.0, Gemfile.rails6.1, Gemfile.rails7.0, Gemfile.rails7.1 ]
-        # ruby: [2.3, 2.4, 2.5, 2.6, 2.7, "3.0", "3.1", jruby]
         # need to add support for multiple gemfiles
-        ruby: ["2.7", "3.0", "3.1", "3.2"]
+        ruby: ["2.7", "3.0", "3.1", "3.2", "3.3"]
         redis-version: [4, 5, 6, 7]
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: supercharge/redis-github-action@1.2.0
         with:
           redis-version: ${{ matrix.redis-version }}

data/.standard.yml

@@ -1,4 +1,4 @@
-ruby_version: 2.3
+ruby_version: 2.7
 fix: false # default: false
 parallel: true # default: false
 format: progress # default: Standard::Formatter

data/Gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in coverband.gemspec
 gemspec
-gem "rails", "~>6"
+gem "rails", "~>7"
 gem "haml"
 gem "slim"
 gem "webrick"

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2010-2018 Dan Mayer
+Copyright (c) 2010 Dan Mayer
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -79,7 +79,7 @@ run ActionController::Dispatcher.new
 
 ![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_web_ui.png)
 
-> The web index is available on the [Coverband Demo site](https://coverband-demo.herokuapp.com/coverage?#_Coverage).
+> You can check it out locally by running the [Coverband Demo App](https://github.com/danmayer/coverband_rails_example).
 
 - View overall coverage information
 
@@ -179,11 +179,6 @@ Coverband.configure do |config|
   # default false. button at the top of the web interface which clears all data
   config.web_enable_clear = true
 
-  # default false. Experimental support for tracking view layer tracking.
-  # Does not track line-level usage, only indicates if an entire file
-  # is used or not.
-  config.track_views = true
-
   # default false. Experimental support for routes usage tracking.
   config.track_routes = true
 end
@@ -221,9 +216,9 @@ config.ignore +=  ['config/application.rb',
 
 Coverband allows an optional feature to track all view files that are used by an application.
 
-To opt-in to this feature... enable the feature in your Coverband config.
+This feature is enabled by default. To stop this feature, disable the feature in your Coverband config.
 
-`config.track_views = true`
+`config.track_views = false`
 
 ![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_view_tracker.png)
 
@@ -252,12 +247,25 @@ end
 
 ### Avoiding Cache Stampede
 
-If you have many servers and they all hit Redis at the same time you can see spikes in your Redis CPU, and memory. This is due to a concept called [cache stampede](https://en.wikipedia.org/wiki/Cache_stampede). It is better to spread out the reporting across your servers. A simple way to do this is to add a random wiggle on your background reporting. This configuration option allows a wiggle. The right amount of wiggle depends on the number of servers you have and how willing you are to have delays in your coverage reporting. I would recommend at least 1 second per server. Note, the default wiggle is set to 30 seconds.
+If you have many servers and they all hit Redis at the same time you can see spikes in your Redis CPU, and memory. This is due to a concept called [cache stampede](https://en.wikipedia.org/wiki/Cache_stampede).
+
+It is better to spread out the reporting across your servers. A simple way to do this is to add a random wiggle on your background reporting. This configuration option allows a wiggle. The right amount of wiggle depends on the number of servers you have and how willing you are to have delays in your coverage reporting. I would recommend at least 1 second per server. Note, the default wiggle is set to 30 seconds.
 
 Add a wiggle (in seconds) to the background thread to avoid all your servers reporting at the same time:
 
 `config.reporting_wiggle = 30`
 
+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
+# To omit reporting on starting servers, need to defer saving eager_loading data
+config.defer_eager_loading_data = true
+# Store eager_loading data on 5% of servers
+config.send_deferred_eager_loading_data = rand(100) < 5
+# Store eager_loading data on servers with the environment variable
+config.send_deferred_eager_loading_data = ENV.fetch('ENABLE_EAGER_LOADING_COVERAGE', false)
+```
+
 ### 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.
@@ -267,6 +275,11 @@ Coverband on very high volume sites with many server processes reporting can hav
 
 See more discussion [here](https://github.com/danmayer/coverband/issues/384).
 
+Please note that with the Redis Hash Store, everytime you load the full report, Coverband will execute `HGETALL` queries in your Redis server twice for every file in the project (once for runtime coverage and once for eager loading coverage). This shouldn't have a big impact in small to medium projects, but can be quite a hassle if your project has a few thousand files.
+To help reduce the extra redis load when getting the coverage report, you can enable `get_coverage_cache` (but note that when doing that, you will always get a previous version of the report, while a cache is re-populated with a newer version).
+
+- Use Hash Redis Store with _get coverage cache_: `config.store = Coverband::Adapters::HashRedisStore.new(redis, get_coverage_cache: true)`
+
 ### Clear Coverage
 
 Now that Coverband uses MD5 hashes there should be no reason to manually clear coverage unless one is testing, changing versions, or possibly debugging Coverband itself.
@@ -425,6 +438,7 @@ If you submit a change please make sure the tests and benchmarks are passing.
 - **Coverband, [Elastic APM](https://github.com/elastic/apm-agent-ruby) and resque**
   - In an environment that uses the Elastic APM ruby agent, resque jobs will fail with `Transactions may not be nested. Already inside #<ElasticAPM::Transaction>` if the `elastic-apm` gem is loaded _before_ the `coverband` gem
   - Put `coverage` ahead of `elastic-apm` in your Gemfile
+- **Bootsnap**, The methods used by [bootsnap do not support having coverage enabled](https://github.com/Shopify/bootsnap/blob/main/lib/bootsnap/compile_cache/iseq.rb#L87), so you can either have Coverband or bootsnap, but not both.  
 
 ### Debugging Redis Store
 
@@ -449,4 +463,4 @@ The Coverband logo was created by [Dave Woodall](http://davewoodall.com). Thanks
 # License
 
 This is a MIT License project...
-See the file license.txt for copying permission.
+See the file [LICENSE](LICENSE) for copying permission.

data/Rakefile

@@ -8,7 +8,7 @@ RuboCop::RakeTask.new
 
 task default: %i[test]
 
-task 'test:all': %i[rubocop test forked_tests benchmarks:memory benchmarks]
+task "test:all": %i[rubocop test forked_tests benchmarks:memory benchmarks]
 
 task :test
 require "rake/testtask"

data/changes.md

@@ -1,3 +1,14 @@
+### Coverband 6.0.2
+
+* thanks makicamel for improved deferred eager loading
+* thanks Drowze for two performance improvements to reporting coverage
+
+
+### Coverband 6.0.1
+
+* [fix on reload routes](https://github.com/danmayer/coverband/commit/f7a81c9499c01a7c027e5f8bc127815bf29a5cb7)
+
+
 ### 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__
@@ -124,7 +135,7 @@ __NOTE: the current RCs include below, but this might turn into coverband 6.0__
 - added support to download coverage and view data in JSON format
 - documentation about working with environment variables
 - add cache wiggle to avoid Redis CPU spikes (cache stampede on Redis server)
-- make the nocov consistant on the data download and html view
+- make the nocov consistent on the data download and html view
 - small performance improvements
 
 ### Coverband 4.2.3

data/coverband.gemspec

@@ -18,10 +18,9 @@ Gem::Specification.new do |spec|
 
   spec.files = `git ls-files`.split("\n").reject { |f| f.start_with?("docs") }
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w[lib]
 
-  spec.required_ruby_version = ">= 2.3"
+  spec.required_ruby_version = ">= 2.7"
 
   spec.metadata = {
     "homepage_uri" => "https://github.com/danmayer/coverband",
@@ -40,11 +39,12 @@ Gem::Specification.new do |spec|
   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", "= 0.2.5"
+  spec.add_development_dependency "standard", "~> 1.34.0"
   spec.add_development_dependency "standardrb"
 
   spec.add_development_dependency "coveralls"

data/lib/coverband/adapters/base.rb

@@ -35,7 +35,7 @@ module Coverband
         raise ABSTRACT_KEY
       end
 
-      def coverage(_local_type = nil)
+      def coverage(_local_type = nil, opts = {})
         raise ABSTRACT_KEY
       end
 
@@ -51,9 +51,9 @@ module Coverband
         raise "abstract"
       end
 
-      def get_coverage_report
+      def get_coverage_report(options = {})
         coverage_cache = {}
-        data = Coverband.configuration.store.split_coverage(Coverband::TYPES, 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))
       end
 
@@ -67,12 +67,12 @@ module Coverband
 
       protected
 
-      def split_coverage(types, coverage_cache)
+      def split_coverage(types, coverage_cache, options = {})
         types.reduce({}) do |data, type|
           if type == Coverband::RUNTIME_TYPE && Coverband.configuration.simulate_oneshot_lines_coverage
             data.update(type => coverage_cache[type] ||= simulated_runtime_coverage)
           else
-            data.update(type => coverage_cache[type] ||= coverage(type))
+            data.update(type => coverage_cache[type] ||= coverage(type, options))
           end
         end
       end
@@ -100,7 +100,7 @@ module Coverband
       def expand_report(report)
         expanded = {}
         report_time = Time.now.to_i
-        updated_time = type == Coverband::EAGER_TYPE ? nil : report_time
+        updated_time = (type == Coverband::EAGER_TYPE) ? nil : report_time
         report.each_pair do |key, line_data|
           extended_data = {
             FIRST_UPDATED_KEY => report_time,
@@ -115,7 +115,7 @@ module Coverband
 
       def merge_reports(new_report, old_report, options = {})
         # transparently update from RUNTIME_TYPE = nil to RUNTIME_TYPE = :runtime
-        # transparent update for format coveband_3_2
+        # transparent update for format coverband_3_2
         old_report = coverage(nil, override_type: nil) if old_report.nil? && type == Coverband::RUNTIME_TYPE
         new_report = expand_report(new_report) unless options[:skip_expansion]
         keys = (new_report.keys + old_report.keys).uniq
@@ -145,11 +145,11 @@ module Coverband
       # TODO: This should only be 2 cases get our dup / not dups aligned
       def array_add(latest, original)
         if Coverband.configuration.use_oneshot_lines_coverage
-          latest.map!.with_index { |v, i| (v + original[i] >= 1 ? 1 : 0) if v && original[i] }
+          latest.map!.with_index { |v, i| ((v + original[i] >= 1) ? 1 : 0) if v && original[i] }
         elsif Coverband.configuration.simulate_oneshot_lines_coverage
-          latest.map.with_index { |v, i| (v + original[i] >= 1 ? 1 : 0) if v && original[i] }
+          latest.map.with_index { |v, i| ((v + original[i] >= 1) ? 1 : 0) if v && original[i] }
         else
-          latest.map.with_index { |v, i| v && original[i] ? v + original[i] : nil }
+          latest.map.with_index { |v, i| (v && original[i]) ? v + original[i] : nil }
         end
       end
     end

data/lib/coverband/adapters/file_store.rb

@@ -52,7 +52,7 @@ module Coverband
         raise NotImplementedError, "FileStore doesn't support migrations"
       end
 
-      def coverage(_local_type = nil)
+      def coverage(_local_type = nil, opts = {})
         if merge_mode
           data = {}
           Dir[path.sub(/\.\d+/, ".*")].each do |path|

data/lib/coverband/adapters/hash_redis_store.rb

@@ -5,6 +5,92 @@ require "securerandom"
 module Coverband
   module Adapters
     class HashRedisStore < Base
+      class GetCoverageNullCacheStore
+        def self.clear!(*_local_types)
+        end
+
+        def self.fetch(_local_type)
+          yield(0)
+        end
+      end
+
+      class GetCoverageRedisCacheStore
+        LOCK_LIMIT = 60 * 30 # 30 minutes
+
+        def initialize(redis, key_prefix)
+          @redis = redis
+          @key_prefix = [key_prefix, "get-coverage"].join(".")
+        end
+
+        def fetch(local_type)
+          cached_result = get(local_type)
+
+          # if no cache available, block the call and populate the cache
+          # if cache is available, return it and start re-populating it (with a lock)
+          if cached_result.nil?
+            value = yield(0)
+            result = set(local_type, JSON.generate(value))
+            value
+          else
+            if lock!(local_type)
+              Thread.new do
+                result = yield(deferred_time)
+                set(local_type, JSON.generate(result))
+              ensure
+                unlock!(local_type)
+              end
+            end
+            JSON.parse(cached_result)
+          end
+        end
+
+        def clear!(local_types = Coverband::TYPES)
+          Array(local_types).each do |local_type|
+            del(local_type)
+            unlock!(local_type)
+          end
+        end
+
+        protected
+
+        def split_coverage(types, coverage_cache, options = {})
+          if types.is_a?(Array)
+            coverage_for_types(types, options)
+          else
+            super
+          end
+        end
+
+        private
+
+        # sleep in between to avoid holding other redis commands..
+        # with a small random offset so runtime and eager types can be processed "at the same time"
+        def deferred_time
+          rand(2.0..3.0)
+        end
+
+        def del(local_type)
+          @redis.del("#{@key_prefix}.cache.#{local_type}")
+        end
+
+        def get(local_type)
+          @redis.get("#{@key_prefix}.cache.#{local_type}")
+        end
+
+        def set(local_type, value)
+          @redis.set("#{@key_prefix}.cache.#{local_type}", value)
+        end
+
+        # lock for at most 60 minutes
+        def lock!(local_type)
+          @redis.set("#{@key_prefix}.lock.#{local_type}", "1", nx: true, ex: LOCK_LIMIT)
+        end
+
+        def unlock!(local_type)
+          @redis.del("#{@key_prefix}.lock.#{local_type}")
+        end
+      end
+
       FILE_KEY = "file"
       FILE_LENGTH_KEY = "file_length"
       META_DATA_KEYS = [DATA_KEY, FIRST_UPDATED_KEY, LAST_UPDATED_KEY, FILE_HASH].freeze
@@ -17,7 +103,7 @@ module Coverband
 
       JSON_PAYLOAD_EXPIRATION = 5 * 60
 
-      attr_reader :redis_namespace
+      attr_reader :redis_namespace, :get_coverage_cache
 
       def initialize(redis, opts = {})
         super()
@@ -29,6 +115,13 @@ module Coverband
 
         @ttl = opts[:ttl]
         @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(".")
+          GetCoverageRedisCacheStore.new(redis, key_prefix)
+        else
+          GetCoverageNullCacheStore
+        end
       end
 
       def supported?
@@ -45,6 +138,8 @@ module Coverband
           file_keys = files_set
           @redis.del(*file_keys) if file_keys.any?
           @redis.del(files_key)
+          @redis.del(files_key(type))
+          @get_coverage_cache.clear!(type)
         end
         self.type = old_type
       end
@@ -54,13 +149,14 @@ module Coverband
         relative_path_file = @relative_file_converter.convert(file)
         Coverband::TYPES.each do |type|
           @redis.del(key(relative_path_file, type, file_hash: file_hash))
+          @get_coverage_cache.clear!(type)
         end
         @redis.srem(files_key, relative_path_file)
       end
 
       def save_report(report)
         report_time = Time.now.to_i
-        updated_time = type == Coverband::EAGER_TYPE ? nil : report_time
+        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)|
@@ -86,17 +182,71 @@ module Coverband
         @redis.sadd(files_key, keys) if keys.any?
       end
 
-      def coverage(local_type = nil)
-        files_set = files_set(local_type)
-        @redis.pipelined { |pipeline|
-          files_set.each do |key|
-            pipeline.hgetall(key)
+      # TODO: refactor this and the method below and consider removing all the cached results stuff
+      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] || {}
+          elsif opts[:filename]
+            files_set(local_type).select { |filepath| filepath == opts[:filename] } || {}
+          else
+            files_set(local_type)
           end
-        }.each_with_object({}) do |data_from_redis, hash|
+          # use 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|
+              key_batch.each do |key|
+                pipeline.hgetall(key)
+              end
+            end
+          end
+        end
+
+        cached_results.each_with_object({}) do |data_from_redis, hash|
           add_coverage_for_file(data_from_redis, hash)
         end
       end
 
+      # NOTE: when using paging we need to ensure we have the same set of files per page in runtime and eager
+      def coverage_for_types(types, opts = {})
+        page_size = opts[:page_size] || 250
+
+        local_type = Coverband::RUNTIME_TYPE
+        hash_data = {}
+
+        runtime_file_set = if opts[:page]
+          files_set(local_type).each_slice(page_size).to_a[opts[:page] - 1] || {}
+        elsif opts[:filename]
+          files_set(local_type).select { |filepath| filepath == opts[:filename] } || {}
+        else
+          files_set(local_type)
+        end
+        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|
+              pipeline.hgetall(key)
+            end
+          end
+        end
+
+        matched_file_set = files_set(Coverband::EAGER_TYPE)
+          .select { |filepath| runtime_file_set.include?(filepath) } || {}
+        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|
+              pipeline.hgetall(key)
+            end
+          end
+        end
+        hash_data
+      end
+
+      def file_count(local_type = nil)
+        files_set(local_type).count { |filename| !Coverband.configuration.ignore.any? { |i| filename.match(i) } }
+      end
+
       def raw_store
         @redis
       end
@@ -119,7 +269,7 @@ module Coverband
 
         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][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
 
@@ -127,7 +277,7 @@ module Coverband
         max = data_from_redis[FILE_LENGTH_KEY].to_i - 1
         Array.new(max + 1) do |index|
           line_coverage = data_from_redis[index.to_s]
-          line_coverage.nil? ? nil : line_coverage.to_i
+          line_coverage&.to_i
         end
       end
 

data/lib/coverband/adapters/null_store.rb

@@ -26,7 +26,7 @@ module Coverband
         raise NotImplementedError, "NullStore doesn't support migrations"
       end
 
-      def coverage(_local_type = nil)
+      def coverage(_local_type = nil, opts = {})
         {}
       end
 

data/lib/coverband/adapters/stdout_store.rb

@@ -25,7 +25,7 @@ module Coverband
         raise NotImplementedError, "StdoutStore doesn't support migrations"
       end
 
-      def coverage(_local_type = nil)
+      def coverage(_local_type = nil, opts = {})
         {}
       end
 

data/lib/coverband/adapters/web_service_store.rb

@@ -42,7 +42,7 @@ module Coverband
 
       ###
       # Fetch coverband coverage via the API
-      # This would allow one to expore from the service and move back to the open source
+      # This would allow one to explore from the service and move back to the open source
       # without having to reset coverage
       ###
       def coverage(local_type = nil, opts = {})
@@ -98,12 +98,10 @@ module Coverband
       def retry_failed_reports
         retries = []
         @failed_coverage_reports.any? do
-          begin
-            report_body = @failed_coverage_reports.pop
-            send_report_body(report_body)
-          rescue
-            retries << report_body
-          end
+          report_body = @failed_coverage_reports.pop
+          send_report_body(report_body)
+        rescue
+          retries << report_body
         end
         retries.each do |report_body|
           add_retry_message(report_body)

data/lib/coverband/collectors/coverage.rb

@@ -64,7 +64,7 @@ module Coverband
           else
             if @deferred_eager_loading_data && Coverband.configuration.defer_eager_loading_data?
               toggle_eager_loading do
-                @store.save_report(@deferred_eager_loading_data)
+                @store.save_report(@deferred_eager_loading_data) if Coverband.configuration.send_deferred_eager_loading_data?
                 @deferred_eager_loading_data = nil
               end
             end

data/lib/coverband/collectors/route_tracker.rb

@@ -65,7 +65,7 @@ module Coverband
 
         # NOTE: This event was instrumented in Aug 10th 2022, but didn't make the 7.0.4 release and should be in the next release
         # https://github.com/rails/rails/pull/43755
-        # Automatic tracking of redirects isn't avaible before Rails 7.1.0 (currently tested against the 7.1.0.alpha)
+        # Automatic tracking of redirects isn't available before Rails 7.1.0 (currently tested against the 7.1.0.alpha)
         # We could consider back porting or patching a solution that works on previous Rails versions
         ActiveSupport::Notifications.subscribe("redirect.action_dispatch") do |name, start, finish, id, payload|
           Coverband.configuration.route_tracker.track_key(payload)

data/lib/coverband/collectors/translation_tracker.rb

@@ -36,7 +36,7 @@ module Coverband
           app_translation_keys = []
           app_translation_files = ::I18n.load_path.select { |f| f.match(/config\/locales/) }
           app_translation_files.each do |file|
-            app_translation_keys += flatten_hash(YAML.load_file(file)).keys
+            app_translation_keys += flatten_hash(YAML.load_file(file, aliases: true)).keys
           end
           app_translation_keys.uniq
         else
@@ -48,7 +48,7 @@ module Coverband
         hash.each_with_object({}) do |(k, v), h|
           if v.is_a? Hash
             flatten_hash(v).map do |h_k, h_v|
-              h["#{k}.#{h_k}".to_sym] = h_v
+              h[:"#{k}.#{h_k}"] = h_v
             end
           else
             h[k] = v

data/lib/coverband/collectors/view_tracker.rb

@@ -81,7 +81,7 @@ module Coverband
       end
 
       def unused_keys(used_views = nil)
-        recently_used_views = (used_keys || used_keys).keys
+        recently_used_views = used_keys.keys
         unused_views = all_keys - recently_used_views
         # since layouts don't include format we count them used if they match with ANY formats
         unused_views.reject { |view| view.match(/\/layouts\//) && recently_used_views.any? { |used_view| view.include?(used_view) } }