coverband 4.2.0 → 4.2.1

data/lib/coverband/adapters/redis_store.rb

@@ -13,23 +13,31 @@ module Coverband
       ###
       REDIS_STORAGE_FORMAT_VERSION = 'coverband_3_2'
 
+      attr_reader :redis_namespace
+
       def initialize(redis, opts = {})
         super()
         @redis           = redis
         @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
+        # temporarily clear the old namespace of coverband_3_2
+        @redis.del(type_base_key(nil))
       end
 
       def clear_file!(filename)
         Coverband::TYPES.each do |type|
-          data = get_report(type)
+          data = coverage(type)
           data.delete(filename)
           save_coverage(data, type)
         end
@@ -47,7 +55,7 @@ module Coverband
       def migrate!
         reset_base_key
         @format_version = 'coverband3_1'
-        previous_data = get_report
+        previous_data = coverage
         if previous_data.empty?
           puts 'no previous data to migrate found'
           exit 0
@@ -58,7 +66,7 @@ module Coverband
         clear!
         reset_base_key
         @format_version = REDIS_STORAGE_FORMAT_VERSION
-        save_coverage(merge_reports(get_report, relative_path_report, skip_expansion: true))
+        save_coverage(merge_reports(coverage, relative_path_report, skip_expansion: true))
       end
 
       def type=(type)
@@ -66,6 +74,12 @@ module Coverband
         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 ? JSON.parse(data) : {}
+      end
+
       private
 
       attr_reader :redis
@@ -79,7 +93,7 @@ module Coverband
       end
 
       def type_base_key(local_type)
-        [@format_version, @redis_namespace, local_type].compact.join('.')
+        @keys[local_type]
       end
 
       def save_coverage(data, local_type = nil)
@@ -87,12 +101,6 @@ module Coverband
         redis.set type_base_key(local_type), data.to_json
         redis.expire(type_base_key(local_type), @ttl) if @ttl
       end
-
-      def get_report(local_type = nil)
-        local_type ||= type
-        data = redis.get type_base_key(local_type)
-        data ? JSON.parse(data) : {}
-      end
     end
   end
 end

data/lib/coverband/at_exit.rb

@@ -16,19 +16,10 @@ module Coverband
         at_exit do
           ::Coverband::Background.stop
 
-          #####
-          # TODO: This is is brittle and not a great solution to avoid deploy time
-          # actions polluting the 'runtime' metrics
-          #
-          # * should we skip /bin/rails webpacker:compile ?
-          # * Perhaps detect heroku deployment ENV var opposed to tasks?
-          #####
-          default_heroku_tasks = ['assets:clean', 'assets:precompile']
-          if defined?(Rake) && Rake.respond_to?(:application) && (Rake&.application&.top_level_tasks || []).any? { |task| default_heroku_tasks.include?(task) }
+          if !Coverband.configuration.report_on_exit
             # skip reporting
           else
-            Coverband.report_coverage(true)
-            #Coverband.configuration.logger&.debug('Coverband: Reported coverage before exit')
+            Coverband.report_coverage
           end
         end
       end

data/lib/coverband/collectors/coverage.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'singleton'
 require_relative 'delta'
 
@@ -13,10 +14,13 @@ module Coverband
     class Coverage
       include Singleton
 
+      def self.ruby_version_greater_than_or_equal_to?(version)
+        Gem::Version.new(RUBY_VERSION) >= Gem::Version.new(version)
+      end
+
       def reset_instance
         @project_directory = File.expand_path(Coverband.configuration.root)
-        @ignore_patterns = Coverband.configuration.ignore + ['internal:prelude', 'schema.rb']
-        @reporting_frequency = Coverband.configuration.reporting_frequency
+        @ignore_patterns = Coverband.configuration.ignore
         @store = Coverband.configuration.store
         @verbose  = Coverband.configuration.verbose
         @logger   = Coverband.configuration.logger
@@ -27,36 +31,36 @@ module Coverband
       end
 
       def runtime!
-        @store.type = nil
+        @store.type = Coverband::RUNTIME_TYPE
       end
 
       def eager_loading!
         @store.type = Coverband::EAGER_TYPE
       end
 
-      def report_coverage(force_report = false)
-        return if !ready_to_report? && !force_report
-        raise 'no Coverband store set' unless @store
+      def eager_loading
+        old_coverage_type = @store.type
+        eager_loading!
+        yield
+      ensure
+        report_coverage
+        @store.type = old_coverage_type
+      end
 
-        original_previous_set = Delta.previous_results
-        files_with_line_usage = filtered_files(Delta.results)
+      def report_coverage
+        @semaphore.synchronize do
+          raise 'no Coverband store set' unless @store
 
-        ###
-        # Hack to prevent processes and threads from reporting first Coverage hit
-        # when we are in runtime collection mode, which do not have a cache of previous
-        # coverage to remove the initial stdlib Coverage loading data
-        ###
-        if ((original_previous_set.nil? && @store.type == Coverband::EAGER_TYPE) ||
-           (original_previous_set && @store.type != Coverband::EAGER_TYPE))
+          files_with_line_usage = filtered_files(Delta.results)
           @store.save_report(files_with_line_usage)
         end
-      rescue StandardError => err
+      rescue StandardError => e
         if @verbose
-          @logger&.error 'coverage failed to store'
-          @logger&.error "error: #{err.inspect} #{err.message}"
-          @logger&.error err.backtrace
+          @logger.error 'coverage failed to store'
+          @logger.error "error: #{e.inspect} #{e.message}"
+          @logger.error e.backtrace
         end
-        raise err if @test_env
+        raise e if @test_env
       end
 
       protected
@@ -78,30 +82,22 @@ module Coverband
       private
 
       def filtered_files(new_results)
-        new_results.each_with_object({}) do |(file, line_counts), file_line_usage|
-          file_line_usage[file] = line_counts if track_file?(file)
-        end.select { |_file_name, coverage| coverage.any? { |value| value&.nonzero? } }
-      end
-
-      def ready_to_report?
-        (rand * 100.0) >= (100.0 - @reporting_frequency)
+        new_results.select! { |file, coverage| track_file?(file) && coverage.any? { |value| value&.nonzero? } }
+        new_results
       end
 
       def initialize
-        if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3.0')
-          raise NotImplementedError, 'not supported until Ruby 2.3.0 and later'
-        end
+        @semaphore = Mutex.new
+        raise NotImplementedError, 'Coverage needs Ruby > 2.3.0' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3.0')
+
         require 'coverage'
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+        if Coverage.ruby_version_greater_than_or_equal_to?('2.6.0')
+          ::Coverage.start(oneshot_lines: Coverband.configuration.use_oneshot_lines_coverage) unless ::Coverage.running?
+        elsif Coverage.ruby_version_greater_than_or_equal_to?('2.5.0')
           ::Coverage.start unless ::Coverage.running?
         else
           ::Coverage.start
         end
-        if Coverband.configuration.safe_reload_files
-          Coverband.configuration.safe_reload_files.each do |safe_file|
-            load safe_file
-          end
-        end
         reset_instance
       end
     end

data/lib/coverband/collectors/delta.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+
 module Coverband
   module Collectors
     class Delta
-      @semaphore = Mutex.new
-      @@previous_coverage = nil
+      @@previous_coverage = {}
+      @@stubs = {}
+
       attr_reader :current_coverage
 
       def initialize(current_coverage)
@@ -12,54 +14,58 @@ module Coverband
 
       class RubyCoverage
         def self.results
-          ::Coverage.peek_result.dup
+          if Coverband.configuration.use_oneshot_lines_coverage
+            ::Coverage.result(clear: true, stop: false)
+          else
+            ::Coverage.peek_result
+          end
         end
       end
 
       def self.results(process_coverage = RubyCoverage)
-        @semaphore.synchronize do
-          set_default_results
-          new(process_coverage.results).results
-        end
-      end
-
-      def self.previous_results
-        @@previous_coverage
-      end
-
-      def self.set_default_results
-        @@previous_coverage ||= {}
+        coverage_results = process_coverage.results
+        new(coverage_results).results
       end
 
       def results
-        new_results = generate
-        @@previous_coverage = current_coverage
-        new_results
+        if Coverband.configuration.use_oneshot_lines_coverage
+          transform_oneshot_lines_results(current_coverage)
+        else
+          new_results = generate
+          @@previous_coverage = current_coverage unless Coverband.configuration.simulate_oneshot_lines_coverage
+          new_results
+        end
       end
 
       def self.reset
-        @@previous_coverage = nil
+        @@previous_coverage = {}
       end
 
       private
 
       def generate
         current_coverage.each_with_object({}) do |(file, line_counts), new_results|
-          if @@previous_coverage[file]
-            new_results[file] = array_diff(line_counts, @@previous_coverage[file])
-          else
-            new_results[file] = line_counts
-          end
+          new_results[file] = if @@previous_coverage && @@previous_coverage[file]
+                                array_diff(line_counts, @@previous_coverage[file])
+                              else
+                                line_counts
+                              end
         end
       end
 
       def array_diff(latest, original)
         latest.map.with_index do |v, i|
-          if (v && original[i])
-            [0, v - original[i]].max
-          else
-            nil
+          [0, v - original[i]].max if v && original[i]
+        end
+      end
+
+      def transform_oneshot_lines_results(results)
+        results.each_with_object({}) do |(file, coverage), new_results|
+          @@stubs[file] ||= ::Coverage.line_stub(file)
+          transformed_line_counts = coverage[:oneshot_lines].each_with_object(@@stubs[file].dup) do |line_number, line_counts|
+            line_counts[line_number - 1] = 1
           end
+          new_results[file] = transformed_line_counts
         end
       end
     end

data/lib/coverband/configuration.rb

@@ -3,15 +3,32 @@
 module Coverband
   class Configuration
     attr_accessor :root_paths, :root,
-                  :ignore, :additional_files, :verbose,
-                  :reporter, :reporting_frequency,
-                  :redis_namespace, :redis_ttl,
-                  :safe_reload_files, :background_reporting_enabled,
+                  :additional_files, :verbose,
+                  :reporter, :redis_namespace, :redis_ttl,
+                  :background_reporting_enabled,
                   :background_reporting_sleep_seconds, :test_env,
-                  :web_enable_clear, :gem_details, :web_debug
+                  :web_enable_clear, :gem_details, :web_debug, :report_on_exit,
+                  :simulate_oneshot_lines_coverage
 
-    attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id, :s3_secret_access_key
-    attr_reader :track_gems
+    attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id, :s3_secret_access_key, :password
+    attr_reader :track_gems, :ignore, :use_oneshot_lines_coverage
+
+    #####
+    # TODO: This is is brittle and not a great solution to avoid deploy time
+    # actions polluting the 'runtime' metrics
+    #
+    # * should we skip /bin/rails webpacker:compile ?
+    # * Perhaps detect heroku deployment ENV var opposed to tasks?
+    #####
+    IGNORE_TASKS = ['coverband:clear',
+                    'coverband:coverage',
+                    'coverband:coverage_server',
+                    'coverband:migrate']
+
+    # Heroku when building assets runs code from a dynamic directory
+    # /tmp was added to avoid coverage from /tmp/build directories during
+    # heroku asset compilation
+    IGNORE_DEFAULTS = %w[vendor .erb$ .slim$ /tmp internal:prelude schema.rb]
 
     def initialize
       reset
@@ -20,12 +37,8 @@ module Coverband
     def reset
       @root = Dir.pwd
       @root_paths = []
-      # Heroku when building assets runs code from a dynamic directory
-      # /tmp was added to avoid coverage from /tmp/build directories during
-      # heroku asset compilation
-      @ignore = %w[vendor .erb$ .slim$ /tmp]
+      @ignore = IGNORE_DEFAULTS.dup
       @additional_files = []
-      @reporting_frequency = 0.0
       @verbose = false
       @reporter = 'scov'
       @logger = nil
@@ -38,6 +51,13 @@ module Coverband
       @gem_details = false
       @groups = {}
       @web_debug = false
+      @report_on_exit = true
+      @use_oneshot_lines_coverage = ENV['ONESHOT'] || false
+      @simulate_oneshot_lines_coverage = ENV['SIMULATE_ONESHOT'] || false
+      @current_root = nil
+      @all_root_paths = nil
+      @all_root_patterns = nil
+      @password = nil
 
       # TODO: should we push these to adapter configs
       @s3_region = nil
@@ -45,17 +65,21 @@ module Coverband
       @s3_access_key_id = nil
       @s3_secret_access_key = nil
       @redis_namespace = nil
-      @redis_ttl = nil
+      @redis_ttl = 2_592_000 # in seconds. Default is 30 days.
     end
 
     def logger
-      @logger ||= if defined?(Rails.logger)
+      @logger ||= if defined?(Rails.logger) && Rails.logger
                     Rails.logger
                   else
                     Logger.new(STDOUT)
                   end
     end
 
+    def password
+      @password || ENV['COVERBAND_PASSWORD']
+    end
+
     def s3_bucket
       @s3_bucket || ENV['AWS_BUCKET']
     end
@@ -77,29 +101,33 @@ module Coverband
     end
 
     def store=(store)
-      if store.is_a?(Coverband::Adapters::Base)
-        @store = store
-      else
-        raise 'please pass in an subclass of Coverband::Adapters for supported stores'
-      end
+      raise 'Pass in an instance of Coverband::Adapters' unless store.is_a?(Coverband::Adapters::Base)
+
+      @store = store
+    end
+
+    ###
+    # Don't allow the ignore to override things like gem tracking
+    ###
+    def ignore=(ignored_array)
+      @ignore = (@ignore + ignored_array).uniq
     end
 
     def track_gems=(value)
       @track_gems = value
       return unless @track_gems
+
       # by default we ignore vendor where many deployments put gems
       # we will remove this default if track_gems is set
       @ignore.delete('vendor')
       # while we want to allow vendored gems we don't want to track vendored ruby STDLIB
-      @ignore << 'vendor/ruby-*'
+      @ignore << 'vendor/ruby-*' unless @ignore.include?('vendor/ruby-*')
       add_group('App', root)
       # TODO: rework support for multiple gem paths
-      # currently this supports GEM_HOME (which should be first path)
-      # but various gem managers setup multiple gem paths
-      # gem_paths.each_with_index do |path, index|
-      #   add_group("gems_#{index}", path)
-      # end
-      add_group('Gems', gem_paths.first)
+      # this works but seems hacky and error prone
+      # basically since it is converted to a regex we join all the paths
+      # with a regex 'OR' using '|'
+      add_group('Gems', gem_paths.join('|'))
     end
 
     #
@@ -125,17 +153,23 @@ module Coverband
     end
 
     def current_root
-      File.expand_path(Coverband.configuration.root)
+      @current_root ||= File.expand_path(Coverband.configuration.root).freeze
     end
 
     def all_root_paths
-      roots = Coverband.configuration.root_paths.dup
-      roots += Coverband.configuration.gem_paths.dup if Coverband.configuration.track_gems
-      roots << "#{Coverband.configuration.current_root}/"
-      roots
+      return @all_root_paths if @all_root_paths
+
+      @all_root_paths = Coverband.configuration.root_paths.dup
+      @all_root_paths += Coverband.configuration.gem_paths.dup if Coverband.configuration.track_gems
+      @all_root_paths << "#{Coverband.configuration.current_root}/"
+      @all_root_paths
+    end
+
+    def all_root_patterns
+      @all_root_patterns ||= all_root_paths.map { |path| /^#{path}/ }.freeze
     end
 
-    SKIPPED_SETTINGS = %w(@s3_secret_access_key @store)
+    SKIPPED_SETTINGS = %w[@s3_secret_access_key @store]
     def to_h
       instance_variables
         .each_with_object('gem_paths': gem_paths) do |var, hash|
@@ -143,6 +177,16 @@ module Coverband
         end
     end
 
+    def use_oneshot_lines_coverage=(value)
+      raise(Exception, 'One shot line coverage is only available in ruby >= 2.6') unless one_shot_coverage_implemented_in_ruby_version? || !value
+
+      @use_oneshot_lines_coverage = value
+    end
+
+    def one_shot_coverage_implemented_in_ruby_version?
+      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6.0')
+    end
+
     private
 
     def redis_url

data/lib/coverband/integrations/background.rb

@@ -7,6 +7,7 @@ module Coverband
 
     def self.stop
       return unless @thread
+
       @semaphore.synchronize do
         if @thread
           @thread.exit
@@ -16,7 +17,7 @@ module Coverband
     end
 
     def self.running?
-      @thread && @thread.alive?
+      @thread&.alive?
     end
 
     def self.start
@@ -25,12 +26,15 @@ module Coverband
       logger = Coverband.configuration.logger
       @semaphore.synchronize do
         return if running?
-        logger&.debug('Coverband: Starting background reporting')
+
+        logger.debug('Coverband: Starting background reporting')
         sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds
         @thread = Thread.new do
           loop do
-            Coverband.report_coverage(true)
-            logger&.debug("Coverband: Reported coverage via thread. Sleeping #{sleep_seconds}s") if Coverband.configuration.verbose
+            Coverband.report_coverage
+            if Coverband.configuration.verbose
+              logger.debug("Coverband: background reporting coverage (#{Coverband.configuration.store.type}). Sleeping #{sleep_seconds}s")
+            end
             sleep(sleep_seconds)
           end
         end

data/lib/coverband/integrations/{middleware.rb → background_middleware.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Coverband
-  class Middleware
+  class BackgroundMiddleware
     def initialize(app)
       @app = app
     end
@@ -10,11 +10,7 @@ module Coverband
       @app.call(env)
     ensure
       AtExit.register
-      if Coverband.configuration.background_reporting_enabled
-        Background.start
-      else
-        Collectors::Coverage.instance.report_coverage
-      end
+      Background.start if Coverband.configuration.background_reporting_enabled
     end
   end
 end

data/lib/coverband/integrations/bundler.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module BundlerEagerLoad
+  def require(*groups)
+    Coverband.eager_loading_coverage { super }
+  end
+end
+Bundler.singleton_class.prepend BundlerEagerLoad

data/lib/coverband/integrations/report_middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coverband
+  class ReportMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      Collectors::Coverage.instance.report_coverage
+    end
+  end
+end

data/lib/coverband/integrations/resque.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-Resque.after_fork do |job|
+Resque.after_fork do |_job|
   Coverband.start
   Coverband.runtime_coverage!
-  # no reason to miss coverage on a first resque job
-  Coverband::Collectors::Delta.set_default_results
 end
 
 Resque.before_first_fork do
   Coverband.eager_loading_coverage!
   Coverband.configuration.background_reporting_enabled = false
   Coverband::Background.stop
-  Coverband::Collectors::Coverage.instance.report_coverage(true)
+  Coverband.report_coverage
 end
 
 module Coverband
@@ -19,7 +17,7 @@ module Coverband
     def perform
       super
     ensure
-      Coverband.report_coverage(true)
+      Coverband.report_coverage
     end
   end
 end