coverband 4.2.6 → 5.0.0.rc.5

data/lib/coverband/configuration.rb

@@ -3,44 +3,45 @@
 module Coverband
   class Configuration
     attr_accessor :root_paths, :root,
-                  :additional_files, :verbose,
-                  :reporter, :redis_namespace, :redis_ttl,
-                  :background_reporting_enabled,
-                  :background_reporting_sleep_seconds, :test_env,
-                  :web_enable_clear, :gem_details, :web_debug, :report_on_exit,
-                  :simulate_oneshot_lines_coverage, :track_views, :view_tracker,
-                  :reporting_wiggle
-
+      :verbose,
+      :reporter, :redis_namespace, :redis_ttl,
+      :background_reporting_enabled,
+      :test_env, :web_enable_clear, :gem_details, :web_debug, :report_on_exit,
+      :simulate_oneshot_lines_coverage,
+      :view_tracker
     attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id,
-                :s3_secret_access_key, :password
+      :s3_secret_access_key, :password, :api_key, :service_url, :coverband_timeout, :service_dev_mode,
+      :service_test_mode, :process_type, :track_views, :redis_url,
+      :background_reporting_sleep_seconds, :reporting_wiggle
+
     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']
+    IGNORE_TASKS = ["coverband:clear",
+                    "coverband:coverage",
+                    "coverband:coverage_server",
+                    "coverband:migrate",
+                    "assets:precompile",
+                    "webpacker:compile",
+                    "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]
+    IGNORE_DEFAULTS = %w[vendor/ .erb$ .slim$ /tmp internal:prelude db/schema.rb]
 
     # Add in missing files which were never loaded
     # we need to know what all paths to check for unloaded files
@@ -55,86 +56,105 @@ module Coverband
       @root_paths = []
       @ignore = IGNORE_DEFAULTS.dup
       @search_paths = TRACKED_DEFAULT_PATHS.dup
-      @additional_files = []
       @verbose = false
-      @reporter = 'scov'
+      @reporter = "scov"
       @logger = nil
       @store = nil
       @background_reporting_enabled = true
-      @background_reporting_sleep_seconds = 30
+      @background_reporting_sleep_seconds = nil
       @test_env = nil
       @web_enable_clear = false
-      @track_gems = false
-      @gem_details = false
-      @track_views = false
-      @groups = {}
+      @track_views = true
+      @view_tracker = nil
       @web_debug = false
       @report_on_exit = true
-      @use_oneshot_lines_coverage = ENV['ONESHOT'] || false
-      @simulate_oneshot_lines_coverage = ENV['SIMULATE_ONESHOT'] || false
+      @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
+      # coverband service settings
+      @api_key = nil
+      @service_url = nil
+      @coverband_timeout = nil
+      @service_dev_mode = nil
+      @service_test_mode = nil
+      @proces_type = nil
+
+      @redis_url = nil
+      @redis_namespace = nil
+      @redis_ttl = 2_592_000 # in seconds. Default is 30 days.
+      @reporting_wiggle = nil
+
+      # TODO: these are deprecated
       @s3_region = nil
       @s3_bucket = nil
       @s3_access_key_id = nil
       @s3_secret_access_key = nil
-      @redis_namespace = nil
-      @redis_ttl = 2_592_000 # in seconds. Default is 30 days.
-      @reporting_wiggle = nil
+      @track_gems = false
+      @gem_details = false
     end
 
     def logger
       @logger ||= if defined?(Rails.logger) && Rails.logger
-                    Rails.logger
-                  else
-                    Logger.new(STDOUT)
-                  end
+        Rails.logger
+      else
+        Logger.new(STDOUT)
+      end
     end
 
     def password
-      @password || ENV['COVERBAND_PASSWORD']
+      @password || ENV["COVERBAND_PASSWORD"]
     end
 
-    def s3_bucket
-      @s3_bucket || ENV['AWS_BUCKET']
+    # The adjustments here either protect the redis or service from being overloaded
+    # the tradeoff being the delay in when reporting data is available
+    # if running your own redis increasing this number reduces load on the redis CPU
+    def background_reporting_sleep_seconds
+      @background_reporting_sleep_seconds ||= if service?
+        # default to 10m for service
+        Coverband.configuration.coverband_env == "production" ? 600 : 60
+      elsif store.is_a?(Coverband::Adapters::HashRedisStore)
+        # Default to 5 minutes if using the hash redis store
+        300
+      else
+        60
+      end
     end
 
-    def s3_region
-      @s3_region || ENV['AWS_REGION']
-    end
-
-    def s3_access_key_id
-      @s3_access_key_id || ENV['AWS_ACCESS_KEY_ID']
-    end
-
-    def s3_secret_access_key
-      @s3_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY']
+    def reporting_wiggle
+      @reporting_wiggle ||= 30
     end
 
     def store
-      @store ||= Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_store_options)
+      @store ||= if service?
+        raise "invalid configuration: unclear default store coverband expects either api_key or redis_url" if redis_url
+        require "coverband/adapters/web_service_store"
+        Coverband::Adapters::WebServiceStore.new(service_url)
+      else
+        Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_store_options)
+      end
     end
 
     def store=(store)
-      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)
+      raise "Pass in an instance of Coverband::Adapters" unless store.is_a?(Coverband::Adapters::Base)
+      raise "invalid configuration: only coverband service expects an API Key" if api_key && !store.is_a?(Coverband::Adapters::WebServiceStore)
+      raise "invalid configuration: coverband service shouldn't have redis url set" if redis_url && store.is_a?(Coverband::Adapters::WebServiceStore)
 
       @store = store
     end
 
+    def track_views
+      @track_views ||= service_disabled_dev_test_env? ? false : true
+    end
+
     ###
     # Search Paths
     ###
     def tracked_search_paths
-      "#{Coverband.configuration.current_root}/{#{@search_paths.join(',')}}/**/*.{rb}"
+      "#{Coverband.configuration.current_root}/{#{@search_paths.join(",")}}/**/*.{rb}"
     end
 
     ###
@@ -151,45 +171,6 @@ module Coverband
       @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-*' unless @ignore.include?('vendor/ruby-*')
-      add_group('App', root)
-      # TODO: rework support for multiple gem paths
-      # 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
-
-    #
-    # 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
       @current_root ||= File.expand_path(Coverband.configuration.root).freeze
     end
@@ -198,7 +179,6 @@ module Coverband
       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
@@ -207,33 +187,90 @@ module Coverband
       @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 @api_key @password]
     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)
+        .each_with_object({}) do |var, hash|
+          hash[var.to_s.delete("@")] = instance_variable_get(var) unless SKIPPED_SETTINGS.include?(var.to_s)
         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
+      raise(StandardError, "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')
+      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
     end
 
-    private
-
     def redis_url
-      ENV['COVERBAND_REDIS_URL'] || ENV['REDIS_URL']
+      @redis_url ||= ENV["COVERBAND_REDIS_URL"] || ENV["REDIS_URL"]
+    end
+
+    def api_key
+      @api_key ||= ENV["COVERBAND_API_KEY"]
+    end
+
+    def service_url
+      @service_url ||= ENV["COVERBAND_URL"] || "https://coverband.io"
+    end
+
+    def coverband_env
+      ENV["RACK_ENV"] || ENV["RAILS_ENV"] || (defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : "unknown")
+    end
+
+    def coverband_timeout
+      @coverband_timeout ||= coverband_env == "development" ? 5 : 2
+    end
+
+    def service_dev_mode
+      @service_dev_mode ||= ENV["COVERBAND_ENABLE_DEV_MODE"] || false
+    end
+
+    def service_test_mode
+      @service_dev_mode ||= ENV["COVERBAND_ENABLE_TEST_MODE"] || false
+    end
+
+    def process_type
+      @process_type ||= ENV["PROCESS_TYPE"] || "unknown"
+    end
+
+    def service?
+      Coverband.coverband_service? || !api_key.nil?
     end
 
+    def service_disabled_dev_test_env?
+      (coverband_env == "test" && !Coverband.configuration.service_test_mode) ||
+        (coverband_env == "development" && !Coverband.configuration.service_dev_mode)
+    end
+
+    def s3_bucket
+      puts "deprecated, s3 is no longer support"
+    end
+
+    def s3_region
+      puts "deprecated, s3 is no longer support"
+    end
+
+    def s3_access_key_id
+      puts "deprecated, s3 is no longer support"
+    end
+
+    def s3_secret_access_key
+      puts "deprecated, s3 is no longer support"
+    end
+
+    def track_gems=(_value)
+      puts "gem tracking is deprecated, setting this will be ignored"
+    end
+
+    private
+
     def redis_store_options
-      { ttl: Coverband.configuration.redis_ttl,
-        redis_namespace: Coverband.configuration.redis_namespace }
+      {ttl: Coverband.configuration.redis_ttl,
+       redis_namespace: Coverband.configuration.redis_namespace}
     end
   end
 end

data/lib/coverband/integrations/background.rb

@@ -27,21 +27,21 @@ module Coverband
       @semaphore.synchronize do
         return if running?
 
-        logger.debug('Coverband: Starting background reporting') if Coverband.configuration.verbose
-        sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds
-        @thread = Thread.new do
+        logger.debug("Coverband: Starting background reporting") if Coverband.configuration.verbose
+        sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds.to_i
+        @thread = Thread.new {
           loop do
             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)
+              sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds.to_i + 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)
+            sleep(sleep_seconds.to_i)
           end
-        end
+        }
       end
     end
   end

data/lib/coverband/integrations/rack_server_check.rb

@@ -15,14 +15,14 @@ module Coverband
     end
 
     def rack_server?
-      @stack.any? { |line| line.path.include?('lib/rack/') }
+      @stack.any? { |line| line.path.include?("lib/rack/") }
     end
 
     def rails_server?
       @stack.any? do |location|
         (
-          location.path.include?('rails/commands/commands_tasks.rb') && location.label == 'server' ||
-          location.path.include?('rails/commands/server/server_command.rb') && location.label == 'perform'
+          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

data/lib/coverband/integrations/resque.rb

@@ -22,4 +22,16 @@ module Coverband
   end
 end
 
-Resque::Job.prepend(Coverband::ResqueWorker)
+if defined?(Coverband::COVERBAND_ALTERNATE_PATCH)
+  Resque::Job.class_eval do
+    def perform_with_coverband
+      perform_without_coverband
+    ensure
+      Coverband.report_coverage
+    end
+    alias perform_without_coverband perform
+    alias perform perform_with_coverband
+  end
+else
+  Resque::Job.prepend(Coverband::ResqueWorker)
+end

data/lib/coverband/reporters/base.rb

@@ -8,7 +8,7 @@ module Coverband
     ###
     class Base
       class << self
-        DATA_KEY = 'data'
+        DATA_KEY = "data"
 
         def report(store, _options = {})
           all_roots = Coverband.configuration.all_root_paths
@@ -49,7 +49,7 @@ module Coverband
         protected
 
         def fix_file_names(report_hash, roots)
-          Coverband.configuration.logger.debug "fixing root: #{roots.join(', ')}" if Coverband.configuration.verbose
+          Coverband.configuration.logger.debug "fixing root: #{roots.join(", ")}" if Coverband.configuration.verbose
 
           # normalize names across servers
           report_hash.each_with_object({}) do |(name, report), fixed_report|
@@ -57,12 +57,12 @@ module Coverband
             report.each_pair do |key, vals|
               filename = Coverband::Utils::AbsoluteFileConverter.convert(key)
               fixed_report[name][filename] = if fixed_report[name].key?(filename) && fixed_report[name][filename][DATA_KEY] && vals[DATA_KEY]
-                                               merged_data = merge_arrays(fixed_report[name][filename][DATA_KEY], vals[DATA_KEY])
-                                               vals[DATA_KEY] = merged_data
-                                               vals
-                                             else
-                                               vals
-                                             end
+                merged_data = merge_arrays(fixed_report[name][filename][DATA_KEY], vals[DATA_KEY])
+                vals[DATA_KEY] = merged_data
+                vals
+              else
+                vals
+              end
             end
           end
         end
@@ -75,8 +75,8 @@ module Coverband
 
           longest.each_with_index do |_line, index|
             merged[index] = if first[index] || second[index]
-                              (first[index].to_i + second[index].to_i)
-                            end
+              (first[index].to_i + second[index].to_i)
+            end
           end
 
           merged
@@ -101,8 +101,7 @@ module Coverband
             end
           end
 
-          scov_style_report = fix_file_names(scov_style_report, roots)
-          scov_style_report
+          fix_file_names(scov_style_report, roots)
         end
       end
     end