coverband 4.2.0 → 4.2.1

data/lib/coverband/utils/source_file.rb

@@ -11,6 +11,8 @@ module Coverband
   module Utils
     class SourceFile
       include Coverband::Utils::FilePathHelper
+
+      # TODO: Refactor Line into its own file
       # Representation of a single line in a source file including
       # this specific line's source code, line_number and code coverage,
       # with the coverage being either nil (coverage not applicable, e.g. comment
@@ -35,6 +37,7 @@ module Coverband
           raise ArgumentError, 'Only String accepted for source' unless src.is_a?(String)
           raise ArgumentError, 'Only Integer accepted for line_number' unless line_number.is_a?(Integer)
           raise ArgumentError, 'Only Integer and nil accepted for coverage' unless coverage.is_a?(Integer) || coverage.nil?
+
           @src         = src
           @line_number = line_number
           @coverage    = coverage
@@ -48,7 +51,7 @@ module Coverband
 
         # Returns true if this is a line that has been covered
         def covered?
-          !never? && !skipped? && coverage > 0
+          !never? && !skipped? && coverage.positive?
         end
 
         # Returns true if this line is not relevant for coverage
@@ -64,7 +67,7 @@ module Coverband
         # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
         # # :nocov: comment lines.
         def skipped?
-          !!skipped
+          skipped
         end
 
         # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
@@ -90,18 +93,27 @@ module Coverband
 
       def initialize(filename, file_data)
         @filename = filename
+        @runtime_relavant_lines = nil
         if file_data.is_a?(Hash)
           @coverage = file_data['data']
           @first_updated_at = @last_updated_at = NOT_AVAILABLE
           @first_updated_at = Time.at(file_data['first_updated_at']) if file_data['first_updated_at']
           @last_updated_at =  Time.at(file_data['last_updated_at']) if file_data['last_updated_at']
         else
+          # TODO: Deprecate this code path this was backwards compatability from 3-4
           @coverage = file_data
           @first_updated_at = NOT_AVAILABLE
           @last_updated_at = NOT_AVAILABLE
         end
       end
 
+      def runtime_relavant_calculations(runtime_relavant_lines)
+        @runtime_relavant_lines = runtime_relavant_lines
+        yield self
+      ensure
+        @runtime_relavant_lines = nil
+      end
+
       # The path to this source file relative to the projects directory
       def project_filename
         @filename.sub(/^#{Coverband.configuration.root}/, '')
@@ -148,7 +160,12 @@ module Coverband
 
         return 0.0 if relevant_lines.zero?
 
-        Float(covered_lines.size * 100.0 / relevant_lines.to_f)
+        # handle edge case where runtime in dev can go over 100%
+        [Float(covered_lines.size * 100.0 / relevant_lines.to_f), 100.0].min
+      end
+
+      def formatted_covered_percent
+        covered_percent&.round(2)
       end
 
       def covered_strength
@@ -166,7 +183,7 @@ module Coverband
       end
 
       def relevant_lines
-        lines.size - never_lines.size - skipped_lines.size
+        @runtime_relavant_lines || (lines.size - never_lines.size - skipped_lines.size)
       end
 
       # Returns all covered lines as SimpleCov::SourceFile::Line
@@ -174,6 +191,14 @@ module Coverband
         @covered_lines ||= lines.select(&:covered?)
       end
 
+      def covered_lines_count
+        covered_lines&.count
+      end
+
+      def line_coverage(index)
+        lines[index]&.coverage
+      end
+
       # Returns all lines that should have been, but were not covered
       # as instances of SimpleCov::SourceFile::Line
       def missed_lines
@@ -216,7 +241,7 @@ module Coverband
       # I had previously patched this in my local Rails app
       def short_name
         filename.sub(/^#{Coverband.configuration.root}/, '.')
-                .sub(%r{^.*\/gems}, '.')
+                .sub(%r{^.*\/gems\/}, '.')
                 .gsub(%r{^\.\/}, '')
       end
 
@@ -229,7 +254,7 @@ module Coverband
       end
 
       def gem_name
-        gem? ? short_name.split('/').first : nil
+        gem? ? short_name.split('/').first.gsub(%r{^\.}, '') : nil
       end
 
       private

data/lib/coverband/utils/tasks.rb

@@ -1,37 +1,36 @@
 # frozen_string_literal: true
 
 namespace :coverband do
-  Coverband.configure
-
-  def environment
-    Rake.application['environment'].invoke if Rake::Task.task_defined?('environment')
-  end
+  # handles configuring in require => false and COVERBAND_DISABLE_AUTO_START cases
+  Coverband.configure unless Coverband.configured?
 
   desc 'report runtime Coverband code coverage'
   task :coverage do
-    environment
     if Coverband.configuration.reporter == 'scov'
-      Coverband::Reporters::HTMLReport.report(Coverband.configuration.store)
+      Coverband::Reporters::HTMLReport.new(Coverband.configuration.store).report
     else
       Coverband::Reporters::ConsoleReport.report(Coverband.configuration.store)
     end
   end
 
+  desc 'report runtime Coverband code coverage'
+  task :coverage_server do
+    Rack::Server.start app: Coverband::Reporters::Web.new, Port: ENV.fetch('COVERBAND_COVERAGE_PORT', 1022).to_i
+  end
+
   ###
   # clear data helpful for development or after configuration issues
   ###
   desc 'reset Coverband coverage data, helpful for development, debugging, etc'
   task :clear do
-    environment
     Coverband.configuration.store.clear!
   end
 
   ###
-  # clear data helpful for development or after configuration issues
+  # Updates the data in the coverband store from one format to another
   ###
   desc 'upgrade previous Coverband datastore to latest format'
   task :migrate do
-    environment
     Coverband.configuration.store.migrate!
   end
 end

data/lib/coverband/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coverband
-  VERSION = '4.2.0'
+  VERSION = '4.2.1'
 end

data/lib/coverband.rb

@@ -23,24 +23,20 @@ require 'coverband/collectors/coverage'
 require 'coverband/reporters/base'
 require 'coverband/reporters/html_report'
 require 'coverband/reporters/console_report'
-require 'coverband/integrations/background'
-require 'coverband/integrations/rack_server_check'
 require 'coverband/reporters/web'
-require 'coverband/integrations/middleware'
 require 'coverband/integrations/background'
+require 'coverband/integrations/background_middleware'
+require 'coverband/integrations/rack_server_check'
 
 module Coverband
+  @@configured = false
   CONFIG_FILE = './config/coverband.rb'
-  RUNTIME_TYPE = nil
+  RUNTIME_TYPE = :runtime
   EAGER_TYPE = :eager_loading
   MERGED_TYPE = :merged
   TYPES = [RUNTIME_TYPE, EAGER_TYPE]
   ALL_TYPES = TYPES + [:merged]
 
-  class << self
-    attr_accessor :configuration_data
-  end
-
   def self.configure(file = nil)
     configuration_file = file || ENV.fetch('COVERBAND_CONFIG', CONFIG_FILE)
     configuration
@@ -49,45 +45,60 @@ module Coverband
     elsif File.exist?(configuration_file)
       load configuration_file
     else
-      configuration.logger&.debug('using default configuration')
+      configuration.logger.debug('using default configuration')
     end
-    coverage.reset_instance
+    @@configured = true
+    coverage_instance.reset_instance
+  end
+
+  def self.configured?
+    @@configured
   end
 
-  def self.report_coverage(force_report = false)
-    Coverband::Collectors::Coverage.instance.report_coverage(force_report)
+  def self.report_coverage
+    coverage_instance.report_coverage
   end
 
   def self.configuration
-    self.configuration_data ||= Configuration.new
+    @configuration ||= Configuration.new
   end
 
   def self.start
     Coverband::Collectors::Coverage.instance
-    # TODO Railtie sets up at_exit after forks, via middleware, perhaps this hsould be
+    # TODO: Railtie sets up at_exit after forks, via middleware, perhaps this should be
     # added if not rails or if rails but not rackserverrunning
-    AtExit.register
-    Background.start if configuration.background_reporting_enabled && !RackServerCheck.running?
+    AtExit.register unless tasks_to_ignore?
+    Background.start if configuration.background_reporting_enabled && !RackServerCheck.running? && !tasks_to_ignore?
+  end
+
+  def self.tasks_to_ignore?
+    (defined?(Rake) &&
+    Rake.respond_to?(:application) &&
+    (Rake&.application&.top_level_tasks || []).any? { |task| Coverband::Configuration::IGNORE_TASKS.include?(task) })
   end
 
   def self.eager_loading_coverage!
-    coverage.eager_loading!
+    coverage_instance.eager_loading!
+  end
+
+  def self.eager_loading_coverage(&block)
+    coverage_instance.eager_loading(&block)
   end
 
   def self.runtime_coverage!
-    coverage.runtime!
+    coverage_instance.runtime!
   end
 
-  def self.coverage
+  private_class_method def self.coverage_instance
     Coverband::Collectors::Coverage.instance
   end
-
   unless ENV['COVERBAND_DISABLE_AUTO_START']
     # Coverband should be setup as early as possible
     # to capture usage of things loaded by initializers or other Rails engines
     configure
     start
     require 'coverband/utils/railtie' if defined? ::Rails::Railtie
-    require 'coverband/integrations/resque' if defined? Resque
+    require 'coverband/integrations/resque' if defined? ::Resque
+    require 'coverband/integrations/bundler' if defined? ::Bundler
   end
 end

data/public/application.js

@@ -1,4 +1,14 @@
 $(document).ready(function() {
+  // remove the url params like notice=message so they don't stick around
+  window.history.replaceState(
+    "object or string",
+    "Coverband",
+    window.location.href.replace(/notice=.*/, "")
+  );
+  $(".notice")
+    .delay(3000)
+    .fadeOut("slow");
+
   $(".del").click(function() {
     if (!confirm("Do you want to delete")) {
       return false;
@@ -13,8 +23,25 @@ $(document).ready(function() {
     aoColumns: [
       null,
       { sType: "percent" },
+      { sType: "percent" },
+      null,
+      null,
+      null,
       null,
       null,
+      null
+    ]
+  });
+
+  // Configuration for fancy sortable tables for source file groups
+  $(".gem_list").dataTable({
+    aaSorting: [[1, "asc"]],
+    bPaginate: false,
+    bJQueryUI: true,
+    aoColumns: [
+      null,
+      { sType: "percent" },
+      { sType: "percent" },
       null,
       null,
       null,

data/test/benchmarks/benchmark.rake

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 namespace :benchmarks do
   # https://github.com/evanphx/benchmark-ips
   # Enable and start GC before each job run. Disable GC afterwards.
@@ -13,11 +14,9 @@ namespace :benchmarks do
       run_gc
     end
 
-    def warmup_stats(*)
-    end
+    def warmup_stats(*); end
 
-    def add_report(*)
-    end
+    def add_report(*); end
 
     private
 
@@ -33,11 +32,7 @@ namespace :benchmarks do
   end
 
   def clone_classifier
-    # rubocop:disable Style/IfUnlessModifier
-    unless Dir.exist? classifier_dir
-      system "git clone https://github.com/jekyll/classifier-reborn.git #{classifier_dir}"
-    end
-    # rubocop:enable Style/IfUnlessModifier
+    system "git clone https://github.com/jekyll/classifier-reborn.git #{classifier_dir}" unless Dir.exist? classifier_dir
   end
 
   # desc 'setup standard benchmark'
@@ -56,9 +51,9 @@ namespace :benchmarks do
     # moving from 5 second of time to 12 still shows slower based on when classifier is required
     # make sure to be plugged in while benchmarking ;) Otherwise you get very unreliable results
     require 'classifier-reborn'
-    if ENV['COVERAGE']
+    if ENV['COVERAGE'] || ENV['ONESHOT']
       require 'coverage'
-      ::Coverage.start
+      ::Coverage.start(oneshot_lines: !!ENV['ONESHOT'])
     end
     require 'redis'
     require 'coverband'
@@ -79,9 +74,10 @@ namespace :benchmarks do
   task :setup_redis do
     Coverband.configure do |config|
       config.root                = Dir.pwd
-      config.reporting_frequency = 100.0
       config.logger              = $stdout
       config.store               = benchmark_redis_store
+      config.use_oneshot_lines_coverage = true if ENV['ONESHOT']
+      config.simulate_oneshot_lines_coverage = true if ENV['SIMULATE_ONESHOT']
     end
   end
 
@@ -89,7 +85,6 @@ namespace :benchmarks do
   task :setup_file do
     Coverband.configure do |config|
       config.root                = Dir.pwd
-      config.reporting_frequency = 100.0
       config.logger              = $stdout
       file_path                  = '/tmp/benchmark_store.json'
       config.store               = Coverband::Adapters::FileStore.new(file_path)
@@ -134,7 +129,7 @@ namespace :benchmarks do
       x.config(time: 12, warmup: 5, suite: suite)
       x.report 'coverband' do
         work
-        Coverband.report_coverage(true)
+        Coverband.report_coverage
       end
       x.report 'no coverband' do
         work
@@ -160,6 +155,7 @@ namespace :benchmarks do
   def adjust_report(report)
     report.keys.each do |file|
       next unless rand < 0.15
+
       report[file] = fake_line_numbers
     end
     report
@@ -170,11 +166,7 @@ namespace :benchmarks do
     # this is a hack because in the benchmark we don't have real files
     ###
     def store.file_hash(file)
-      if @file_hash_cache[file]
-        @file_hash_cache[file]
-      else
-        @file_hash_cache[file] = Digest::MD5.file(__FILE__).hexdigest
-      end
+      @file_hash_cache[file] || @file_hash_cache[file] = Digest::MD5.file(__FILE__).hexdigest
     end
 
     def store.full_path_to_relative(file)
@@ -214,11 +206,54 @@ namespace :benchmarks do
     end.pretty_print
     data = $stdout.string
     $stdout = previous_out
-    raise 'leaking memory!!!' unless data.match('Total retained:  0 bytes')
+    unless data.match('Total retained:  0 bytes')
+      puts data
+      raise 'leaking memory!!!'
+    end
   ensure
     $stdout = previous_out
   end
 
+  def measure_memory_report_coverage
+    require 'memory_profiler'
+    report = fake_report
+    store = benchmark_redis_store
+    store.clear!
+    mock_files(store)
+
+    # warmup
+    3.times { Coverband.report_coverage }
+
+    previous_out = $stdout
+    capture = StringIO.new
+    $stdout = capture
+
+    MemoryProfiler.report do
+      10.times do
+        Coverband.report_coverage
+        ###
+        # Set to nil not {} as it is easier to verify that no memory is retained when nil gets released
+        # don't use Coverband::Collectors::Delta.reset which sets to {}
+        # we clear this as this one variable is expected to retain memory and is a false positive
+        ###
+        Coverband::Collectors::Delta.class_variable_set(:@@previous_coverage, nil)
+      end
+    end.pretty_print
+    data = $stdout.string
+    $stdout = previous_out
+    unless data.match('Total retained:  0 bytes')
+      puts data
+      raise 'leaking memory!!!'
+    end
+  ensure
+    $stdout = previous_out
+  end
+
+  ###
+  # TODO: This currently fails, as it holds a string in redis adapter
+  # but really Coverband shouldn't be configured multiple times and the leak is small
+  # not including in test suite but we can try to figure it out and fix.
+  ###
   def measure_configure_memory
     require 'memory_profiler'
     # warmup
@@ -232,24 +267,79 @@ namespace :benchmarks do
       10.times do
         Coverband.configure do |config|
           redis_url = ENV['CACHE_REDIS_URL'] || ENV['REDIS_URL']
-          config.store = Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_namespace: 'coverband_data')
+          config.store = Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_namespace: 'coverband_bench_data')
         end
       end
     end.pretty_print
     data = $stdout.string
     $stdout = previous_out
-    puts data
-    raise 'leaking memory!!!' unless data.match('Total retained:  0 bytes')
+    unless data.match('Total retained:  0 bytes')
+      puts data
+      raise 'leaking memory!!!'
+    end
   ensure
     $stdout = previous_out
   end
 
+  desc 'checks memory of collector'
+  task memory_check: [:setup] do
+    require 'pry-byebug'
+    require 'objspace'
+    puts 'memory load check'
+    puts(ObjectSpace.memsize_of_all / 2**20)
+    data = File.read('./tmp/debug_data.json')
+    # about 2mb
+    puts(ObjectSpace.memsize_of(data) / 2**20)
+
+    json_data = JSON.parse(data)
+    # this seems to just show the value of the pointer
+    # puts(ObjectSpace.memsize_of(json_data) / 2**20)
+    # implies json takes 10-12 mb
+    puts(ObjectSpace.memsize_of_all / 2**20)
+
+    json_data = nil
+    GC.start
+    json_data = JSON.parse(data)
+    # this seems to just show the value of the pointer
+    # puts(ObjectSpace.memsize_of(json_data) / 2**20)
+    # implies json takes 10-12 mb
+    puts(ObjectSpace.memsize_of_all / 2**20)
+
+    json_data = nil
+    GC.start
+    json_data = JSON.parse(data)
+    # this seems to just show the value of the pointer
+    # puts(ObjectSpace.memsize_of(json_data) / 2**20)
+    # implies json takes 10-12 mb
+    puts(ObjectSpace.memsize_of_all / 2**20)
+
+    json_data = nil
+    GC.start
+    json_data = JSON.parse(data)
+    # this seems to just show the value of the pointer
+    # puts(ObjectSpace.memsize_of(json_data) / 2**20)
+    # implies json takes 10-12 mb
+    puts(ObjectSpace.memsize_of_all / 2**20)
+
+    json_data = nil
+    GC.start
+    puts(ObjectSpace.memsize_of_all / 2**20)
+    debugger
+    puts 'done'
+  end
+
   desc 'runs memory reporting on Redis store'
   task memory_reporting: [:setup] do
     puts 'runs memory benchmarking to ensure we dont leak'
     measure_memory
   end
 
+  desc 'runs memory reporting on report_coverage'
+  task memory_reporting_report_coverage: [:setup] do
+    puts 'runs memory benchmarking on report_coverage to ensure we dont leak'
+    measure_memory_report_coverage
+  end
+
   desc 'runs memory reporting on configure'
   task memory_configure_reporting: [:setup] do
     puts 'runs memory benchmarking on configure to ensure we dont leak'
@@ -259,7 +349,12 @@ namespace :benchmarks do
   desc 'runs memory leak check via Rails tests'
   task memory_rails: [:setup] do
     puts 'runs memory rails test to ensure we dont leak'
-    puts `COVERBAND_MEMORY_TEST=true bundle exec m test/unit/rails_full_stack_test.rb:22`
+    puts `COVERBAND_MEMORY_TEST=true bundle exec test/forked/rails_full_stack_test.rb`
+  end
+
+  desc 'runs memory leak checks'
+  task memory: %i[memory_reporting memory_reporting_report_coverage memory_rails] do
+    puts 'done'
   end
 
   desc 'runs benchmarks on reporting large sets of files to redis'
@@ -269,13 +364,36 @@ namespace :benchmarks do
   end
 
   # desc 'runs benchmarks on default redis setup'
-  task run_redis: [:setup, :setup_redis] do
+  task run_redis: %i[setup setup_redis] do
     puts 'Coverband configured with default Redis store'
     run_work(true)
   end
 
+  def run_big
+    require 'memory_profiler'
+    require './test/unique_files'
+
+    4000.times { |index| require_unique_file('dog.rb.erb', dog_number: index) }
+    # warmup
+    3.times { Coverband.report_coverage }
+    dogs = 400.times.map { |index| Object.const_get("Dog#{index}") }
+    MemoryProfiler.report do
+      10.times do
+        dogs.each(&:bark)
+        Coverband.report_coverage
+      end
+    end.pretty_print
+  end
+
+  task run_big: %i[setup setup_redis] do
+    # ensure we cleared from last run
+    benchmark_redis_store.clear!
+
+    run_big
+  end
+
   # desc 'runs benchmarks file store'
-  task run_file: [:setup, :setup_file] do
+  task run_file: %i[setup setup_file] do
     puts 'Coverband configured with file store'
     run_work(true)
   end