coverband 4.2.5 → 5.0.0.rc.4

data/lib/coverband/collectors/view_tracker_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Collectors
+    ###
+    # This class extends view tracker to support web service reporting
+    ###
+    class ViewTrackerService < ViewTracker
+      def report_views_tracked
+        reported_time = Time.now.to_i
+        if views_to_record.any?
+          relative_views = views_to_record.map! do |view|
+            roots.each do |root|
+              view = view.gsub(/#{root}/, "")
+            end
+            view
+          end
+          save_tracked_views(views: relative_views, reported_time: reported_time)
+        end
+        self.views_to_record = []
+      rescue => e
+        # we don't want to raise errors if Coverband can't reach the service
+        logger&.error "Coverband: view_tracker failed to store, error #{e.class.name}" if Coverband.configuration.verbose || Coverband.configuration.service_dev_mode
+      end
+
+      def self.supported_version?
+        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 4
+      end
+
+      private
+
+      def logger
+        Coverband.configuration.logger
+      end
+
+      def save_tracked_views(views:, reported_time:)
+        uri = URI("#{Coverband.configuration.service_url}/api/collector")
+        req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json", "Coverband-Token" => Coverband.configuration.api_key)
+        data = {
+          collection_type: "view_tracker_delta",
+          collection_data: {
+            tags: {
+              runtime_env: Coverband.configuration.coverband_env
+            },
+            collection_time: reported_time,
+            tracked_views: views
+          }
+        }
+        # puts "sending #{data}"
+        req.body = {remote_uuid: SecureRandom.uuid, data: data}.to_json
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(req)
+        end
+      rescue => e
+        logger&.error "Coverband: Error while saving coverage #{e}" if Coverband.configuration.verbose || Coverband.configuration.service_dev_mode
+      end
+    end
+  end
+end

data/lib/coverband/configuration.rb

@@ -3,16 +3,17 @@
 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
-
+      :additional_files, :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, :proces_type, :report_period, :track_views,
+      :background_reporting_sleep_seconds, :reporting_wiggle
+
     attr_reader :track_gems, :ignore, :use_oneshot_lines_coverage
 
     #####
@@ -22,25 +23,25 @@ module Coverband
     # * 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",
+                    "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
@@ -57,31 +58,41 @@ module Coverband
       @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
+      @report_period = 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
@@ -89,38 +100,59 @@ module Coverband
 
     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']
+      puts "deprecated, s3 is no longer support"
     end
 
     def s3_region
-      @s3_region || ENV['AWS_REGION']
+      puts "deprecated, s3 is no longer support"
     end
 
     def s3_access_key_id
-      @s3_access_key_id || ENV['AWS_ACCESS_KEY_ID']
+      puts "deprecated, s3 is no longer support"
     end
 
     def s3_secret_access_key
-      @s3_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY']
+      puts "deprecated, s3 is no longer support"
+    end
+
+    def background_reporting_sleep_seconds
+      @background_reporting_sleep_seconds ||= if Coverband.coverband_service?
+        Coverband.configuration.coverband_env == "production" ? Coverband.configuration.report_period : 60
+      else
+        60
+      end
+    end
+
+    def reporting_wiggle
+      @reporting_wiggle ||= 30
     end
 
     def store
-      @store ||= Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_store_options)
+      @store ||= if Coverband.coverband_service?
+        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 track_views
+      @track_views ||= service_disabled_dev_test_env? ? false : true
     end
 
     def store=(store)
-      raise 'Pass in an instance of Coverband::Adapters' unless store.is_a?(Coverband::Adapters::Base)
+      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
@@ -134,7 +166,7 @@ module Coverband
     # Search Paths
     ###
     def tracked_search_paths
-      "#{Coverband.configuration.current_root}/{#{@search_paths.join(',')}}/**/*.{rb}"
+      "#{Coverband.configuration.current_root}/{#{@search_paths.join(",")}}/**/*.{rb}"
     end
 
     ###
@@ -151,43 +183,8 @@ 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) }
+    def track_gems=(_value)
+      puts "gem tracking is deprecated, setting this will be ignored"
     end
 
     def current_root
@@ -198,7 +195,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
@@ -210,30 +206,67 @@ module Coverband
     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)
+        .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
+
+    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 proces_type
+      @process_type ||= ENV["PROCESS_TYPE"] || "unknown"
+    end
+
+    def report_period
+      @process_type ||= (ENV["COVERBAND_REPORT_PERIOD"] || 600).to_i
+    end
+
+    def service_disabled_dev_test_env?
+      (coverband_env == "test" && !Coverband.configuration.service_test_mode) ||
+        (coverband_env == "development" && !Coverband.configuration.service_dev_mode)
     end
 
     private
 
     def redis_url
-      ENV['COVERBAND_REDIS_URL'] || ENV['REDIS_URL']
+      ENV["COVERBAND_REDIS_URL"] || ENV["REDIS_URL"]
     end
 
     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