coverband 4.0.1 → 4.2.0

data/lib/coverband/adapters/base.rb

@@ -3,6 +3,9 @@
 module Coverband
   module Adapters
     class Base
+      include Coverband::Utils::FilePathHelper
+      attr_accessor :type
+
       def initialize
         @file_hash_cache = {}
       end
@@ -11,13 +14,29 @@ module Coverband
         raise 'abstract'
       end
 
+      def clear_file!(_file)
+        raise 'abstract'
+      end
+
+      def migrate!
+        raise 'abstract'
+      end
+
+      def size
+        raise 'abstract'
+      end
+
+      def size_in_mib
+        format('%.2f', (size.to_f / 2**20))
+      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 = report.dup
-        merge_reports(data, get_report)
+        data = merge_reports(data, get_report)
         save_coverage(data)
       end
 
@@ -25,6 +44,11 @@ module Coverband
         get_report
       end
 
+      def get_coverage_report
+        data = Coverband.configuration.store.split_coverage(Coverband::TYPES)
+        data.merge(Coverband::MERGED_TYPE => Coverband.configuration.store.merged_coverage(Coverband::TYPES))
+      end
+
       def covered_files
         coverage.keys || []
       end
@@ -36,6 +60,18 @@ module Coverband
 
       protected
 
+      def split_coverage(types)
+        types.reduce({}) do |data, type|
+          data.update(type => get_report(type))
+        end
+      end
+
+      def merged_coverage(types)
+        types.reduce({}) do |data, type|
+          merge_reports(data, get_report(type), skip_expansion: true)
+        end
+      end
+
       def save_coverage
         raise 'abstract'
       end
@@ -49,20 +85,23 @@ module Coverband
       end
 
       def expand_report(report)
+        expanded = {}
         report_time = Time.now.to_i
+        updated_time = self.type == Coverband::EAGER_TYPE ? nil : report_time
         report.each_pair do |key, line_data|
           extended_data = {
             'first_updated_at' => report_time,
-            'last_updated_at' => report_time,
+            'last_updated_at' => updated_time,
             'file_hash' => file_hash(key),
             'data' => line_data
           }
-          report[key] = extended_data
+          expanded[full_path_to_relative(key)] = extended_data
         end
+        expanded
       end
 
-      def merge_reports(new_report, old_report)
-        new_report = expand_report(new_report)
+      def merge_reports(new_report, old_report, options = {})
+        new_report = expand_report(new_report) unless options[:skip_expansion]
         keys = (new_report.keys + old_report.keys).uniq
         keys.each do |file|
           new_report[file] = if new_report[file] &&
@@ -90,12 +129,6 @@ module Coverband
       def array_add(latest, original)
         latest.map.with_index { |v, i| (v && original[i]) ? v + original[i] : nil }
       end
-
-      def simple_report(report)
-        report.each_with_object({}) do |(key, extended_data), simple|
-          simple[key] = extended_data['data']
-        end
-      end
     end
   end
 end

data/lib/coverband/adapters/file_store.rb

@@ -20,6 +20,14 @@ module Coverband
         File.delete(path) if File.exist?(path)
       end
 
+      def size
+        File.size?(path).to_i
+      end
+
+      def migrate!
+        raise NotImplementedError, "FileStore doesn't support migrations"
+      end
+
       private
 
       attr_accessor :path

data/lib/coverband/adapters/redis_store.rb

@@ -6,34 +6,91 @@ module Coverband
     # RedisStore store a merged coverage file to redis
     ###
     class RedisStore < Base
-      BASE_KEY = 'coverband3_1'
+      ###
+      # This key isn't related to the coverband version, but to the interal format
+      # used to store data to redis. It is changed only when breaking changes to our
+      # redis format are required.
+      ###
+      REDIS_STORAGE_FORMAT_VERSION = 'coverband_3_2'
 
       def initialize(redis, opts = {})
         super()
         @redis           = redis
         @ttl             = opts[:ttl]
         @redis_namespace = opts[:redis_namespace]
+        @format_version  = REDIS_STORAGE_FORMAT_VERSION
       end
 
       def clear!
-        @redis.del(base_key)
+        Coverband::TYPES.each do |type|
+          @redis.del(type_base_key(type))
+        end
+      end
+
+      def clear_file!(filename)
+        Coverband::TYPES.each do |type|
+          data = get_report(type)
+          data.delete(filename)
+          save_coverage(data, type)
+        end
+      end
+
+      def size
+        @redis.get(base_key).bytesize
+      end
+
+      ###
+      # Current implementation moves from coverband3_1 to coverband_3_2
+      # In the future this can be made more general and support a more specific
+      # version format.
+      ###
+      def migrate!
+        reset_base_key
+        @format_version = 'coverband3_1'
+        previous_data = get_report
+        if previous_data.empty?
+          puts 'no previous data to migrate found'
+          exit 0
+        end
+        relative_path_report = previous_data.each_with_object({}) do |(key, vals), fixed_report|
+          fixed_report[full_path_to_relative(key)] = vals
+        end
+        clear!
+        reset_base_key
+        @format_version = REDIS_STORAGE_FORMAT_VERSION
+        save_coverage(merge_reports(get_report, relative_path_report, skip_expansion: true))
+      end
+
+      def type=(type)
+        super
+        reset_base_key
       end
 
       private
 
       attr_reader :redis
 
+      def reset_base_key
+        @base_key = nil
+      end
+
       def base_key
-        @base_key ||= [BASE_KEY, @redis_namespace].compact.join('.')
+        @base_key ||= [@format_version, @redis_namespace, type].compact.join('.')
+      end
+
+      def type_base_key(local_type)
+        [@format_version, @redis_namespace, local_type].compact.join('.')
       end
 
-      def save_coverage(data)
-        redis.set base_key, data.to_json
-        redis.expire(base_key, @ttl) if @ttl
+      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
       end
 
-      def get_report
-        data = redis.get base_key
+      def get_report(local_type = nil)
+        local_type ||= type
+        data = redis.get type_base_key(local_type)
         data ? JSON.parse(data) : {}
       end
     end

data/lib/coverband/at_exit.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Coverband
+  class AtExit
+    @semaphore = Mutex.new
+
+    @at_exit_registered = nil
+    def self.register
+      return if ENV['COVERBAND_DISABLE_AT_EXIT']
+      return if @at_exit_registered
+
+      @semaphore.synchronize do
+        return if @at_exit_registered
+
+        @at_exit_registered = true
+        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) }
+            # skip reporting
+          else
+            Coverband.report_coverage(true)
+            #Coverband.configuration.logger&.debug('Coverband: Reported coverage before exit')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coverband/collectors/coverage.rb

@@ -1,124 +1,97 @@
 # frozen_string_literal: true
+require 'singleton'
+require_relative 'delta'
 
 module Coverband
   module Collectors
     ###
-    # TODO: look at alternatives to semaphore
-    # StandardError seems line be better option
+    # StandardError seems like be better option
     # coverband previously had RuntimeError here
     # but runtime error can let a large number of error crash this method
     # and this method is currently in a ensure block in middleware and threads
     ###
     class Coverage
-      def self.instance
-        Thread.current[:coverband_instance] ||= Coverband::Collectors::Coverage.new
-      end
+      include Singleton
 
       def reset_instance
         @project_directory = File.expand_path(Coverband.configuration.root)
-        @file_line_usage = {}
         @ignore_patterns = Coverband.configuration.ignore + ['internal:prelude', 'schema.rb']
         @reporting_frequency = Coverband.configuration.reporting_frequency
         @store = Coverband.configuration.store
         @verbose  = Coverband.configuration.verbose
         @logger   = Coverband.configuration.logger
-        @current_thread = Thread.current
         @test_env = Coverband.configuration.test_env
-        @@previous_results = nil
-        Thread.current[:coverband_instance] = nil
+        @track_gems = Coverband.configuration.track_gems
+        Delta.reset
         self
       end
 
+      def runtime!
+        @store.type = nil
+      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
 
-        new_results = get_new_coverage_results
-        add_filtered_files(new_results)
-        @store.save_report(files_with_line_usage)
-        @file_line_usage.clear
+        original_previous_set = Delta.previous_results
+        files_with_line_usage = filtered_files(Delta.results)
+
+        ###
+        # 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))
+          @store.save_report(files_with_line_usage)
+        end
       rescue StandardError => err
         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: #{err.inspect} #{err.message}"
+          @logger&.error err.backtrace
         end
         raise err if @test_env
       end
 
       protected
 
+      ###
+      # Normally I would break this out into additional methods
+      # and improve the readability but this is in a tight loop
+      # on the critical performance path, and any refactoring I come up with
+      # would slow down the performance.
+      ###
       def track_file?(file)
         @ignore_patterns.none? do |pattern|
           file.include?(pattern)
-        end && file.start_with?(@project_directory)
+        end && (file.start_with?(@project_directory) ||
+                (@track_gems &&
+                 Coverband.configuration.gem_paths.any? { |path| file.start_with?(path) }))
       end
 
       private
 
-      def add_filtered_files(new_results)
-        new_results.each_pair do |file, line_counts|
-          next unless track_file?(file)
-          add_file(file, line_counts)
-        end
+      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)
       end
 
-      def get_new_coverage_results
-        @semaphore.synchronize { new_coverage(::Coverage.peek_result.dup) }
-      end
-
-      def files_with_line_usage
-        @file_line_usage.select do |_file_name, coverage|
-          coverage.any? { |value| value&.nonzero? }
-        end
-      end
-
-      def array_diff(latest, original)
-        latest.map.with_index { |v, i| (v && original[i]) ? v - original[i] : nil }
-      end
-
-      def previous_results
-        @@previous_results
-      end
-
-      def add_previous_results(val)
-        @@previous_results = val
-      end
-
-      def new_coverage(current_coverage)
-        if previous_results
-          new_results = {}
-          current_coverage.each_pair do |file, line_counts|
-            if previous_results[file]
-              new_results[file] = array_diff(line_counts, previous_results[file])
-            else
-              new_results[file] = line_counts
-            end
-          end
-        else
-          new_results = current_coverage
-        end
-
-        add_previous_results(current_coverage)
-        new_results.dup
-      end
-
-      def add_file(file, line_counts)
-        @file_line_usage[file] = line_counts
-      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
-        unless defined?(::Coverage)
-          # puts 'loading coverage'
-          require 'coverage'
-        end
+        require 'coverage'
         if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
           ::Coverage.start unless ::Coverage.running?
         else
@@ -129,8 +102,6 @@ module Coverband
             load safe_file
           end
         end
-        @semaphore = Mutex.new
-        @@previous_results = nil
         reset_instance
       end
     end

data/lib/coverband/collectors/delta.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module Coverband
+  module Collectors
+    class Delta
+      @semaphore = Mutex.new
+      @@previous_coverage = nil
+      attr_reader :current_coverage
+
+      def initialize(current_coverage)
+        @current_coverage = current_coverage
+      end
+
+      class RubyCoverage
+        def self.results
+          ::Coverage.peek_result.dup
+        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 ||= {}
+      end
+
+      def results
+        new_results = generate
+        @@previous_coverage = current_coverage
+        new_results
+      end
+
+      def self.reset
+        @@previous_coverage = nil
+      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
+        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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coverband/configuration.rb

@@ -7,9 +7,11 @@ module Coverband
                   :reporter, :reporting_frequency,
                   :redis_namespace, :redis_ttl,
                   :safe_reload_files, :background_reporting_enabled,
-                  :background_reporting_sleep_seconds, :test_env
+                  :background_reporting_sleep_seconds, :test_env,
+                  :web_enable_clear, :gem_details, :web_debug
 
     attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id, :s3_secret_access_key
+    attr_reader :track_gems
 
     def initialize
       reset
@@ -18,7 +20,10 @@ module Coverband
     def reset
       @root = Dir.pwd
       @root_paths = []
-      @ignore = %w(vendor .erb$ .slim$)
+      # 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]
       @additional_files = []
       @reporting_frequency = 0.0
       @verbose = false
@@ -28,6 +33,11 @@ module Coverband
       @background_reporting_enabled = true
       @background_reporting_sleep_seconds = 30
       @test_env = nil
+      @web_enable_clear = false
+      @track_gems = false
+      @gem_details = false
+      @groups = {}
+      @web_debug = false
 
       # TODO: should we push these to adapter configs
       @s3_region = nil
@@ -74,6 +84,65 @@ module Coverband
       end
     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-*'
+      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)
+    end
+
+    #
+    # Returns the configured groups. Add groups using SimpleCov.add_group
+    #
+    def groups
+      @groups ||= {}
+    end
+
+    #
+    # Define a group for files. Works similar to add_filter, only that the first
+    # argument is the desired group name and files PASSING the filter end up in the group
+    # (while filters exclude when the filter is applicable).
+    #
+    def add_group(group_name, filter_argument = nil)
+      groups[group_name] = filter_argument
+    end
+
+    def gem_paths
+      # notes ignore any paths that aren't on this system, resolves
+      # bug related to multiple ruby version managers / bad dot files
+      Gem::PathSupport.new(ENV).path.select { |path| File.exist?(path) }
+    end
+
+    def current_root
+      File.expand_path(Coverband.configuration.root)
+    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
+    end
+
+    SKIPPED_SETTINGS = %w(@s3_secret_access_key @store)
+    def to_h
+      instance_variables
+        .each_with_object('gem_paths': gem_paths) do |var, hash|
+          hash[var.to_s.delete('@')] = instance_variable_get(var) unless SKIPPED_SETTINGS.include?(var.to_s)
+        end
+    end
+
     private
 
     def redis_url

data/lib/coverband/integrations/background.rb

@@ -3,8 +3,10 @@
 module Coverband
   class Background
     @semaphore = Mutex.new
+    @thread = nil
 
     def self.stop
+      return unless @thread
       @semaphore.synchronize do
         if @thread
           @thread.exit
@@ -13,28 +15,25 @@ module Coverband
       end
     end
 
+    def self.running?
+      @thread && @thread.alive?
+    end
+
     def self.start
-      return if @thread
+      return if running?
 
       logger = Coverband.configuration.logger
       @semaphore.synchronize do
-        binding.pry if defined?($debug) && $debug
-        return if @thread
+        return if running?
         logger&.debug('Coverband: Starting background reporting')
         sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds
         @thread = Thread.new do
           loop do
-            Coverband::Collectors::Coverage.instance.report_coverage(true)
+            Coverband.report_coverage(true)
             logger&.debug("Coverband: Reported coverage via thread. Sleeping #{sleep_seconds}s") if Coverband.configuration.verbose
             sleep(sleep_seconds)
           end
         end
-        binding.pry if defined?($debug) && $debug
-      end
-      at_exit do
-        stop
-        Coverband::Collectors::Coverage.instance.report_coverage(true)
-        logger&.debug('Coverband: Reported coverage before exit')
       end
     end
   end

data/lib/coverband/integrations/middleware.rb

@@ -9,10 +9,11 @@ module Coverband
     def call(env)
       @app.call(env)
     ensure
+      AtExit.register
       if Coverband.configuration.background_reporting_enabled
-        Coverband::Background.start
+        Background.start
       else
-        Coverband::Collectors::Coverage.instance.report_coverage
+        Collectors::Coverage.instance.report_coverage
       end
     end
   end

data/lib/coverband/integrations/rack_server_check.rb

@@ -20,7 +20,10 @@ module Coverband
 
     def rails_server?
       @stack.any? do |location|
-        location.path.include?('rails/commands/commands_tasks.rb') && location.label == 'server'
+        (
+          location.path.include?('rails/commands/commands_tasks.rb') && location.label == 'server' ||
+          location.path.include?('rails/commands/server/server_command.rb') && location.label == 'perform'
+        )
       end
     end
   end