coverband 4.2.0 → 4.2.4

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,13 +14,16 @@ 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
+        @verbose = Coverband.configuration.verbose
+        @logger = Coverband.configuration.logger
         @test_env = Coverband.configuration.test_env
         @track_gems = Coverband.configuration.track_gems
         Delta.reset
@@ -27,36 +31,34 @@ 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
-        if @verbose
-          @logger&.error 'coverage failed to store'
-          @logger&.error "error: #{err.inspect} #{err.message}"
-          @logger&.error err.backtrace
-        end
-        raise err if @test_env
+      rescue StandardError => e
+        @logger&.error 'coverage failed to store'
+        @logger&.error "Coverband Error: #{e.inspect} #{e.message}"
+        e.backtrace.each { |line| @logger&.error line } if @verbose
+        raise e if @test_env
       end
 
       protected
@@ -69,7 +71,7 @@ module Coverband
       ###
       def track_file?(file)
         @ignore_patterns.none? do |pattern|
-          file.include?(pattern)
+          file.match(pattern)
         end && (file.start_with?(@project_directory) ||
                 (@track_gems &&
                  Coverband.configuration.gem_paths.any? { |path| file.start_with?(path) }))
@@ -78,30 +80,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/collectors/view_tracker.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Coverband
+  module Collectors
+    ###
+    # This class tracks view file usage via ActiveSupport::Notifications
+    #
+    # This is a port of Flatfoot, a project I open sourced years ago,
+    # but am now rolling into Coverband
+    # https://github.com/livingsocial/flatfoot
+    #
+    # TODO: test and ensure slim, haml, and other support
+    ###
+    class ViewTracker
+      DEFAULT_TARGET = Dir.glob('app/views/**/*.html.erb').reject { |file| file.match(/(_mailer)/) }
+      attr_accessor :target, :logged_views, :views_to_record
+      attr_reader :logger, :roots, :store, :ignore_patterns
+
+      def initialize(options = {})
+        raise NotImplementedError, 'View Tracker requires Rails 4 or greater' unless self.class.supported_version?
+
+        @project_directory = File.expand_path(Coverband.configuration.root)
+        @ignore_patterns = Coverband.configuration.ignore
+        @store = options.fetch(:store) { Coverband.configuration.store }
+        @logger = options.fetch(:logger) { Coverband.configuration.logger }
+        @target = options.fetch(:target) { DEFAULT_TARGET }
+
+        @roots = options.fetch(:roots) { Coverband.configuration.all_root_patterns }
+        @roots = @roots.split(',') if @roots.is_a?(String)
+        @one_time_timestamp = false
+
+        @logged_views = []
+        @views_to_record = []
+      end
+
+      ###
+      # This method is called on every render call, so we try to reduce method calls
+      # and ensure high performance
+      ###
+      def track_views(_name, _start, _finish, _id, payload)
+        if (file = payload[:identifier])
+          if newly_seen_file?(file)
+            logged_views << file
+            views_to_record << file if track_file?(file)
+          end
+        end
+
+        ###
+        # Annoyingly while you get full path for templates
+        # notifications only pass part of the path for layouts dropping any format info
+        # such as .html.erb or .js.erb
+        # http://edgeguides.rubyonrails.org/active_support_instrumentation.html#render_partial-action_view
+        ###
+        return unless (layout_file = payload[:layout])
+        return unless newly_seen_file?(layout_file)
+
+        logged_views << layout_file
+        views_to_record << layout_file if track_file?(layout_file, layout: true)
+      end
+
+      def used_views
+        views = redis_store.hgetall(tracker_key)
+        normalized_views = {}
+        views.each_pair do |view, time|
+          roots.each do |root|
+            view = view.gsub(/#{root}/, '')
+          end
+          normalized_views[view] = time
+        end
+        normalized_views
+      end
+
+      def unused_views
+        recently_used_views = used_views.keys
+        all_views = target.reject { |view| recently_used_views.include?(view) }
+        # since layouts don't include format we count them used if they match with ANY formats
+        all_views.reject { |view| view.match(/\/layouts\//) && recently_used_views.any? { |used_view| view.include?(used_view) } }
+      end
+
+      def as_json
+        {
+          unused_views: unused_views,
+          used_views: used_views
+        }.to_json
+      end
+
+      def tracking_since
+        if (tracking_time = redis_store.get(tracker_time_key))
+          Time.at(tracking_time.to_i).iso8601
+        else
+          'N/A'
+        end
+      end
+
+      def reset_recordings
+        redis_store.del(tracker_key)
+        redis_store.del(tracker_time_key)
+      end
+
+      def clear_file!(filename)
+        return unless filename
+
+        filename = "#{@project_directory}/#{filename}"
+        redis_store.hdel(tracker_key, filename)
+        logged_views.delete(filename)
+      end
+
+      def report_views_tracked
+        redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || redis_store.exists(tracker_time_key)
+        @one_time_timestamp = true
+        reported_time = Time.now.to_i
+        views_to_record.each do |file|
+          redis_store.hset(tracker_key, file, reported_time)
+        end
+        self.views_to_record = []
+      rescue StandardError => e
+        # we don't want to raise errors if Coverband can't reach redis.
+        # This is a nice to have not a bring the system down
+        logger&.error "Coverband: view_tracker failed to store, error #{e.class.name}"
+      end
+
+      def self.supported_version?
+        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split('.').first.to_i >= 4
+      end
+
+      protected
+
+      def newly_seen_file?(file)
+        return false if logged_views.include?(file)
+
+        true
+      end
+
+      def track_file?(file, options = {})
+        @ignore_patterns.none? do |pattern|
+          file.include?(pattern)
+        end && (file.start_with?(@project_directory) || options[:layout])
+      end
+
+      private
+
+      def redis_store
+        store.raw_store
+      end
+
+      def tracker_key
+        'render_tracker_2'
+      end
+
+      def tracker_time_key
+        'render_tracker_time'
+      end
+    end
+  end
+end

data/lib/coverband/configuration.rb

@@ -3,15 +3,48 @@
 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, :track_views, :view_tracker,
+                  :reporting_wiggle
 
-    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',
+                    'assets:precompile',
+                    'db:version',
+                    'db:create',
+                    'db:drop',
+                    'db:seed',
+                    'db:setup',
+                    'db:test:prepare',
+                    'db:structure:dump',
+                    'db:structure:load',
+                    'db:version']
+
+    # 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]
+
+    # Add in missing files which were never loaded
+    # we need to know what all paths to check for unloaded files
+    TRACKED_DEFAULT_PATHS = %w[app lib config]
 
     def initialize
       reset
@@ -20,12 +53,9 @@ 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
+      @seach_paths = TRACKED_DEFAULT_PATHS.dup
       @additional_files = []
-      @reporting_frequency = 0.0
       @verbose = false
       @reporter = 'scov'
       @logger = nil
@@ -36,8 +66,16 @@ module Coverband
       @web_enable_clear = false
       @track_gems = false
       @gem_details = false
+      @track_views = 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 +83,22 @@ 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.
+      @reporting_wiggle = nil
     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 +120,52 @@ 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)
+
+      # Default to 5 minutes if using the hash redis store
+      # This is a safer default for the high server volumes that need the hash store
+      # it should avoid overloading the redis with lots of load
+      @background_reporting_sleep_seconds = 300 if store.is_a?(Coverband::Adapters::HashRedisStore)
+
+      @store = store
+    end
+
+    ###
+    # Search Paths
+    ###
+    def tracked_search_paths
+      "#{Coverband.configuration.current_root}/{#{@seach_paths.join(',')}}/**/*.{rb}"
+    end
+
+    ###
+    # Don't allow the to override defaults
+    ###
+    def search_paths=(path_array)
+      @seach_paths = (@seach_paths + path_array).uniq
+    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')
+      @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 +191,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 +215,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,19 @@ module Coverband
       logger = Coverband.configuration.logger
       @semaphore.synchronize do
         return if running?
-        logger&.debug('Coverband: Starting background reporting')
+
+        logger.debug('Coverband: Starting background reporting') if Coverband.configuration.verbose
         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
+            Coverband.configuration.view_tracker&.report_views_tracked
+            if Coverband.configuration.reporting_wiggle
+              sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds + rand(Coverband.configuration.reporting_wiggle.to_i)
+            end
+            if Coverband.configuration.verbose
+              logger.debug("Coverband: background reporting coverage (#{Coverband.configuration.store.type}). Sleeping #{sleep_seconds}s")
+            end
             sleep(sleep_seconds)
           end
         end