coverband 5.0.0.rc.3 → 5.0.0.rc.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c59cff2fa063db7a0c165e9cfefa8607151ee39699bf57cbb6bb6fce849abe97
-  data.tar.gz: 6fedd5cc2efd695370b3136f293209184b8c633e093ae75ac2f7d083c1eec13d
+  metadata.gz: 2e236d323d6ce3fdb2d3bf5ea9a7514e2cc5758c50d422573cd0ffe0bf8a3f5b
+  data.tar.gz: 93c4a362420b64444efa41f74c4f21259e5891e23481885a3acd7472e2577c63
 SHA512:
-  metadata.gz: 75740ba292febb787cbb40beaa47b1a355d9303b23b43fc949d77f918848497fca538e080e86baf5d898b4a5001a9a838ed64846cb5a039a6aaa2a300f39edf0
-  data.tar.gz: 6ed03c519ee7a4a5d24f6399c8a1a747d2de58d0a6370575f72bed528a18cd4d24c941c6e7f60902ced21883e4f664158a91881b3518577722323cb5cc5b904c
+  metadata.gz: ce5500c42de344046f55a277635f7f406e6e6675b7a77cbff0ba9986c86c5b066e3969ea8540043dc4aaa70c91b9648cda531660569209257d7ce04c7831180c
+  data.tar.gz: 9927e92ef9749a079ee56774d6e112cfa4ca2c21f9fd56cd60e0896bf588198fc5ff8e133baff74cc1bf1bb2d4ca2d9cbe8f99a655702879db464d90a71a5dbb

data/.standard.yml

@@ -13,6 +13,7 @@ ignore: # default: []
       - Style/RedundantRegexpEscape # fix later, enforcement changed
       - Layout/ArrayAlignment # WTF all of master broken from a few changes in rubo
       - Performance/RegexpMatch # Rubocop / standardrb have this WRONG for Ruby 2.3/2.4 not compatiable
+      - Style/GlobalStdStream # Rubocop / standardrb have this WRONG for Ruby 2.3/2.4 not compatiable
   - "vendor/**/*"
   - "pkg/**/*"
   - "test/**/*":

data/changes.md

@@ -7,7 +7,7 @@
   - [redis bitfield](https://stackoverflow.com/questions/47100606/optimal-way-to-store-array-of-integers-in-redis-database)
 - Add support for [zadd](http://redis.io/topics/data-types-intro) so one could determine single call versus multiple calls on a line, letting us determine the most executed code in production.
 
-### Coverband 4.X
+### Coverband Future...
 
 Will be the fully modern release that drops maintenance legacy support in favor of increased performance, ease of use, and maintainability.
 
@@ -60,7 +60,18 @@ Will be the fully modern release that drops maintenance legacy support in favor
   - drops S3 support
   - drops static report support
   - drops gem support
-- ?
+  - only loaded web reporter files when required
+- configuration improvements
+	- improved load order allowing more time for ENV vars (better dotenv, figaro, rails secrets support)
+	- all config options can be set via coverband config, not requiring ENV var support
+	- deprecation notices on soon to be removed config options
+	- config exceptions on invalid configuration combinations
+- improved resque patching pattern
+- improved default ignores
+- additional adapters
+  - supports web-service adapter for http coverage collection
+  - support log/file adapter
+- reduce logs / errors / alerts on bad startup configurations
 
 # Released
 

data/coverband.gemspec

@@ -25,15 +25,18 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "memory_profiler"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-fork_executor"
+  spec.add_development_dependency "minitest-stub-const"
   spec.add_development_dependency "mocha", "~> 1.7.0"
   spec.add_development_dependency "rack"
   spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "resque"
+  spec.add_development_dependency "standard", "= 0.2.5"
   spec.add_development_dependency "standardrb"
 
   spec.add_development_dependency "coveralls"
   spec.add_development_dependency "minitest-profile"
+  spec.add_development_dependency "webmock"
 
   # TODO: Remove when other production adapters exist
   # because the default configuration of redis store, we really do require

data/lib/coverband.rb

@@ -12,9 +12,11 @@ require "coverband/adapters/base"
 require "coverband/adapters/redis_store"
 require "coverband/adapters/hash_redis_store"
 require "coverband/adapters/file_store"
+require "coverband/adapters/stdout_store"
 require "coverband/utils/file_hasher"
 require "coverband/collectors/coverage"
 require "coverband/collectors/view_tracker"
+require "coverband/collectors/view_tracker_service"
 require "coverband/reporters/base"
 require "coverband/reporters/console_report"
 require "coverband/integrations/background"
@@ -25,6 +27,7 @@ Coverband::Adapters::RedisStore = Coverband::Adapters::HashRedisStore if ENV["CO
 
 module Coverband
   @@configured = false
+  SERVICE_CONFIG = "./config/coverband_service.rb"
   CONFIG_FILE = "./config/coverband.rb"
   RUNTIME_TYPE = :runtime
   EAGER_TYPE = :eager_loading
@@ -33,7 +36,11 @@ module Coverband
   ALL_TYPES = TYPES + [:merged]
 
   def self.configure(file = nil)
-    configuration_file = file || ENV.fetch("COVERBAND_CONFIG", CONFIG_FILE)
+    configuration_file = file || ENV["COVERBAND_CONFIG"]
+    if configuration_file.nil?
+      configuration_file = coverband_service? ? SERVICE_CONFIG : CONFIG_FILE
+    end
+
     configuration
     if block_given?
       yield(configuration)
@@ -46,6 +53,10 @@ module Coverband
     coverage_instance.reset_instance
   end
 
+  def self.coverband_service?
+    !!File.exist?(SERVICE_CONFIG)
+  end
+
   def self.configured?
     @@configured
   end
@@ -87,6 +98,7 @@ module Coverband
   private_class_method def self.coverage_instance
     Coverband::Collectors::Coverage.instance
   end
+
   unless ENV["COVERBAND_DISABLE_AUTO_START"]
     begin
       # Coverband should be setup as early as possible

data/lib/coverband/adapters/base.rb

@@ -112,7 +112,6 @@ module Coverband
         # transparently update from RUNTIME_TYPE = nil to RUNTIME_TYPE = :runtime
         # transparent update for format coveband_3_2
         old_report = coverage(nil, override_type: nil) if old_report.nil? && type == Coverband::RUNTIME_TYPE
-
         new_report = expand_report(new_report) unless options[:skip_expansion]
         keys = (new_report.keys + old_report.keys).uniq
         keys.each do |file|

data/lib/coverband/adapters/file_store.rb

@@ -3,14 +3,38 @@
 module Coverband
   module Adapters
     ###
-    # FilesStore store a merged coverage file to local disk
-    # Generally this is for testing and development
-    # Not recommended for production deployment, as it doesn't handle concurrency
+    # FileStore store a merged coverage file to local disk
+    #
+    # Notes: Concurrency
+    # * threadsafe as the caller to save_report uses @semaphore.synchronize
+    # * file access process safe as each file written per process PID
+    #
+    # Usage:
+    # config.store = Coverband::Adapters::FileStore.new('log/coverage.log')
+    #
+    # View Reports:
+    # Using this assumes you are syncing the coverage files
+    # to some shared storage that is accessable outside of the production server
+    # download files to a system where you want to view the reports..
+    # When viewing coverage from the filestore adapter it merges all coverage
+    # files matching the path pattern, in this case `log/coverage.log.*`
+    #
+    # run: `bundle exec rake coverband:coverage_server`
+    # open http://localhost:1022/
+    #
+    # one could also build a report via code, the output is suitable to feed into SimpleCov
+    #
+    # ```
+    # coverband.configuration.store.merge_mode = true
+    # coverband.configuration.store.coverage
+    # ```
     ###
     class FileStore < Base
+      attr_accessor :merge_mode
       def initialize(path, _opts = {})
         super()
-        @path = path
+        @path = "#{path}.#{::Process.pid}"
+        @merge_mode = false
 
         config_dir = File.dirname(@path)
         Dir.mkdir config_dir unless File.exist?(config_dir)
@@ -29,17 +53,25 @@ module Coverband
       end
 
       def coverage(_local_type = nil)
-        if File.exist?(path)
+        if merge_mode
+          data = {}
+          Dir[path.sub(/\.\d+/, ".*")].each do |path|
+            data = merge_reports(data, JSON.parse(File.read(path)), skip_expansion: true)
+          end
+          data
+        elsif File.exist?(path)
           JSON.parse(File.read(path))
         else
           {}
         end
+      rescue Errno::ENOENT
+        {}
       end
 
       def save_report(report)
         data = report.dup
         data = merge_reports(data, coverage)
-        File.open(path, "w") { |f| f.write(data.to_json) }
+        File.write(path, JSON.dump(data))
       end
 
       def raw_store

data/lib/coverband/adapters/stdout_store.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Adapters
+    ###
+    # StdoutStore is for testing and development
+    #
+    # Usage:
+    # config.store = Coverband::Adapters::StdoutStore.new
+    ###
+    class StdoutStore < Base
+      def initialize(_opts = {})
+        super()
+      end
+
+      def clear!
+        # NOOP
+      end
+
+      def size
+        0
+      end
+
+      def migrate!
+        raise NotImplementedError, "StdoutStore doesn't support migrations"
+      end
+
+      def coverage(_local_type = nil)
+        {}
+      end
+
+      def save_report(report)
+        $stdout.puts(report.to_json)
+      end
+
+      def raw_store
+        raise NotImplementedError, "StdoutStore doesn't support raw_store"
+      end
+    end
+  end
+end

data/lib/coverband/adapters/web_service_store.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Adapters
+    ###
+    # WebServiceStore: store a checkpoint of coverage to a remote service
+    ###
+    class WebServiceStore < Base
+      attr_reader :coverband_url, :process_type, :runtime_env, :hostname, :pid
+
+      def initialize(coverband_url, opts = {})
+        super()
+        require "socket"
+        require "securerandom"
+        @coverband_url = coverband_url
+        @process_type = opts.fetch(:process_type) { $PROGRAM_NAME&.split("/")&.last || Coverband.configuration.process_type }
+        @hostname = opts.fetch(:hostname) { ENV["DYNO"] || Socket.gethostname.force_encoding("utf-8").encode }
+        @hostname = @hostname.delete("'", "").delete("’", "")
+        @runtime_env = opts.fetch(:runtime_env) { Coverband.configuration.coverband_env }
+        @failed_coverage_reports = []
+      end
+
+      def logger
+        Coverband.configuration.logger
+      end
+
+      def clear!
+        # done via service UI
+        raise "not supported via service"
+      end
+
+      def clear_file!(filename)
+        # done via service UI
+        raise "not supported via service"
+      end
+
+      # NOTE: Should support nil to mean not supported
+      # the size feature doesn't really makde sense for the service
+      def size
+        0
+      end
+
+      ###
+      # Fetch coverband coverage via the API
+      # This would allow one to expore from the service and move back to the open source
+      # without having to reset coverage
+      ###
+      def coverage(local_type = nil, opts = {})
+        return if Coverband.configuration.service_disabled_dev_test_env?
+
+        local_type ||= opts.key?(:override_type) ? opts[:override_type] : type
+        env_filter = opts.key?(:env_filter) ? opts[:env_filter] : "production"
+        uri = URI("#{coverband_url}/api/coverage?type=#{local_type}&env_filter=#{env_filter}")
+        req = Net::HTTP::Get.new(uri, "Content-Type" => "application/json", "Coverband-Token" => Coverband.configuration.api_key)
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(req)
+        end
+        JSON.parse(res.body)
+      rescue => e
+        logger&.error "Coverband: Error while retrieving coverage #{e}" if Coverband.configuration.verbose || Coverband.configuration.service_dev_mode
+      end
+
+      def save_report(report)
+        return if report.empty?
+
+        # We set here vs initialize to avoid setting on the primary process vs child processes
+        @pid ||= ::Process.pid
+
+        # TODO: do we need dup
+        # TODO: we don't need upstream timestamps, server will track first_seen
+        Thread.new do
+          data = expand_report(report.dup)
+          full_package = {
+            collection_type: "coverage_delta",
+            collection_data: {
+              tags: {
+                process_type: process_type,
+                app_loading: type == Coverband::EAGER_TYPE,
+                runtime_env: runtime_env,
+                pid: pid,
+                hostname: hostname
+              },
+              file_coverage: data
+            }
+          }
+
+          save_coverage(full_package)
+          retry_failed_reports
+        end&.join
+      end
+
+      def raw_store
+        raise "not supported via service"
+      end
+
+      private
+
+      def retry_failed_reports
+        retries = []
+        @failed_coverage_reports.any? do
+          begin
+            report_body = @failed_coverage_reports.pop
+            send_report_body(report_body)
+          rescue
+            retries << report_body
+          end
+        end
+        retries.each do |report_body|
+          add_retry_message(report_body)
+        end
+      end
+
+      def add_retry_message(report_body)
+        if @failed_coverage_reports.length > 5
+          logger&.info "Coverband: The errored reporting queue has reached 5. Subsequent reports will not be transmitted"
+        else
+          @failed_coverage_reports << report_body
+        end
+      end
+
+      def save_coverage(data)
+        if Coverband.configuration.api_key.nil?
+          puts "Coverband: Error: no Coverband API key was found!"
+          return
+        end
+
+        coverage_body = {remote_uuid: SecureRandom.uuid, data: data}.to_json
+        send_report_body(coverage_body)
+      rescue => e
+        add_retry_message(coverage_body)
+        logger&.info "Coverband: Error while saving coverage #{e}" if Coverband.configuration.verbose || Coverband.configuration.service_dev_mode
+      end
+
+      def send_report_body(coverage_body)
+        uri = URI("#{coverband_url}/api/collector")
+        req = ::Net::HTTP::Post.new(uri, "Content-Type" => "application/json", "Coverband-Token" => Coverband.configuration.api_key)
+        req.body = coverage_body
+        logger&.info "Coverband: saving (#{uri}) #{req.body}" if Coverband.configuration.verbose
+        res = ::Net::HTTP.start(
+          uri.hostname,
+          uri.port,
+          open_timeout: Coverband.configuration.coverband_timeout,
+          read_timeout: Coverband.configuration.coverband_timeout,
+          ssl_timeout: Coverband.configuration.coverband_timeout,
+          use_ssl: uri.scheme == "https"
+        ) do |http|
+          http.request(req)
+        end
+        if res.code.to_i >= 500
+          add_retry_message(coverage_body)
+        end
+      end
+    end
+  end
+end

data/lib/coverband/collectors/delta.rb

@@ -77,6 +77,16 @@ module Coverband
 
       def transform_oneshot_lines_results(results)
         results.each_with_object({}) do |(file, coverage), new_results|
+          ###
+          # Eager filter:
+          # 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.
+          ###
+          next unless @@ignore_patterns.none? { |pattern| file.match(pattern) } &&
+            file.start_with?(@@project_directory)
+
           @@stubs[file] ||= ::Coverage.line_stub(file)
           transformed_line_counts = coverage[:oneshot_lines].each_with_object(@@stubs[file].dup) { |line_number, line_counts|
             line_counts[line_number - 1] = 1

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,23 +3,23 @@
 module Coverband
   class Configuration
     attr_accessor :root_paths, :root,
-      :additional_files, :verbose,
+      :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
-
+      :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",
@@ -27,6 +27,7 @@ module Coverband
                     "coverband:coverage_server",
                     "coverband:migrate",
                     "assets:precompile",
+                    "webpacker:compile",
                     "db:version",
                     "db:create",
                     "db:drop",
@@ -55,18 +56,16 @@ module Coverband
       @root_paths = []
       @ignore = IGNORE_DEFAULTS.dup
       @search_paths = TRACKED_DEFAULT_PATHS.dup
-      @additional_files = []
       @verbose = false
       @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
+      @track_views = true
+      @view_tracker = nil
       @web_debug = false
       @report_on_exit = true
       @use_oneshot_lines_coverage = ENV["ONESHOT"] || false
@@ -76,15 +75,26 @@ module Coverband
       @all_root_patterns = nil
       @password = nil
 
+      # 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
@@ -99,37 +109,47 @@ module Coverband
       @password || ENV["COVERBAND_PASSWORD"]
     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"
+    # 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_secret_access_key
-      puts "deprecated, s3 is no longer support"
+    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 ENV["COVERBAND_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 "invalid configuration: only coverband service expects an API Key" if api_key && store.class.to_s != "Coverband::Adapters::WebServiceStore"
+      raise "invalid configuration: coverband service shouldn't have redis url set" if ENV["COVERBAND_REDIS_URL"] && store.class.to_s == "Coverband::Adapters::WebServiceStore"
 
       @store = store
     end
 
+    def track_views
+      @track_views ||= service_disabled_dev_test_env? ? false : true
+    end
+
     ###
     # Search Paths
     ###
@@ -151,10 +171,6 @@ module Coverband
       @ignore = (@ignore + ignored_array).uniq
     end
 
-    def track_gems=(_value)
-      puts "gem tracking is deprecated, setting this will be ignored"
-    end
-
     def current_root
       @current_root ||= File.expand_path(Coverband.configuration.root).freeze
     end
@@ -171,7 +187,7 @@ 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({}) do |var, hash|
@@ -189,12 +205,69 @@ module Coverband
       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}

data/lib/coverband/integrations/background.rb

@@ -28,18 +28,18 @@ module Coverband
         return if running?
 
         logger.debug("Coverband: Starting background reporting") if Coverband.configuration.verbose
-        sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds
+        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

data/lib/coverband/reporters/base.rb

@@ -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

data/lib/coverband/reporters/web.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "coverband"
+
 begin
   require "rack"
 rescue LoadError
@@ -11,10 +13,6 @@ module Coverband
     class Web
       attr_reader :request
 
-      def initialize
-        init_web
-      end
-
       def init_web
         full_path = Gem::Specification.find_by_name("coverband").full_gem_path
         @static = Rack::Static.new(self,

data/lib/coverband/utils/railtie.rb

@@ -15,11 +15,16 @@ module Coverband
         app.middleware.use Coverband::BackgroundMiddleware
 
         if Coverband.configuration.track_views
-          CoverbandViewTracker = Coverband::Collectors::ViewTracker.new
-          Coverband.configuration.view_tracker = CoverbandViewTracker
+          COVERBAND_VIEW_TRACKER = if Coverband.coverband_service?
+            Coverband::Collectors::ViewTrackerService.new
+          else
+            Coverband::Collectors::ViewTracker.new
+          end
+
+          Coverband.configuration.view_tracker = COVERBAND_VIEW_TRACKER
 
           ActiveSupport::Notifications.subscribe(/render_partial.action_view|render_template.action_view/) do |name, start, finish, id, payload|
-            CoverbandViewTracker.track_views(name, start, finish, id, payload) unless name.include?("!")
+            COVERBAND_VIEW_TRACKER.track_views(name, start, finish, id, payload) unless name.include?("!")
           end
         end
       rescue Redis::CannotConnectError => error
@@ -30,6 +35,7 @@ module Coverband
 
     config.after_initialize do
       unless Coverband.tasks_to_ignore?
+        Coverband.configure
         Coverband.eager_loading_coverage!
         Coverband.report_coverage
         Coverband.runtime_coverage!
@@ -39,7 +45,6 @@ module Coverband
     config.before_configuration do
       unless ENV["COVERBAND_DISABLE_AUTO_START"]
         begin
-          Coverband.configure
           Coverband.start
         rescue Redis::CannotConnectError => error
           Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"

data/lib/coverband/utils/tasks.rb

@@ -12,6 +12,7 @@ namespace :coverband do
   desc "report runtime Coverband code coverage"
   task :coverage_server do
     Rake.application["environment"].invoke if Rake::Task.task_defined?("environment")
+    Coverband.configuration.store.merge_mode = true if Coverband.configuration.store.is_a?(Coverband::Adapters::FileStore)
     Rack::Server.start app: Coverband::Reporters::Web.new, Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 1022).to_i
   end
 

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format '4.2.1.rc.1' ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "5.0.0.rc.3"
+  VERSION = "5.0.0.rc.8"
 end

data/test/coverband/adapters/file_store_test.rb

@@ -13,14 +13,13 @@ class AdaptersFileStoreTest < Minitest::Test
     def setup
       super
       @test_file_path = "/tmp/coverband_filestore_test_path.json"
-      File.open(@test_file_path, "w") { |f| f.write(test_data.to_json) }
+      previous_file_path = "#{@test_file_path}.#{::Process.pid}"
+      `rm #{@test_file_path}` if File.exist?(@test_file_path)
+      `rm #{previous_file_path}` if File.exist?(previous_file_path)
+      File.open(previous_file_path, "w") { |f| f.write(test_data.to_json) }
       @store = Coverband::Adapters::FileStore.new(@test_file_path)
     end
 
-    def test_size
-      assert @store.size > 1
-    end
-
     def test_coverage
       assert_equal @store.coverage["dog.rb"]["data"][0], 1
       assert_equal @store.coverage["dog.rb"]["data"][1], 2
@@ -31,7 +30,7 @@ class AdaptersFileStoreTest < Minitest::Test
     end
 
     def test_covered_files
-      assert_equal @store.covered_files, ["dog.rb"]
+      assert @store.covered_files.include?("dog.rb")
     end
 
     def test_clear
@@ -43,6 +42,7 @@ class AdaptersFileStoreTest < Minitest::Test
       mock_file_hash
       @store.send(:save_report, "cat.rb" => [0, 1])
       assert_equal @store.coverage["cat.rb"]["data"][1], 1
+      assert @store.size > 1
     end
 
     def test_data

data/test/coverband/adapters/web_service_store_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require File.expand_path("../../../lib/coverband/adapters/web_service_store", File.dirname(__FILE__))
+
+class WebServiceStoreTest < Minitest::Test
+  COVERBAND_SERVICE_URL = "http://localhost:12345"
+  FAKE_API_KEY = "12345"
+
+  def setup
+    WebMock.disable_net_connect!
+    super
+    @store = Coverband::Adapters::WebServiceStore.new(COVERBAND_SERVICE_URL)
+    Coverband.configuration.store = @store
+  end
+
+  def test_coverage
+    Coverband.configuration.api_key = FAKE_API_KEY
+    stub_request(:post, "#{COVERBAND_SERVICE_URL}/api/collector").to_return(body: {status: "OK"}.to_json, status: 200)
+    mock_file_hash
+    @store.save_report(basic_coverage)
+  end
+
+  # TODO: sort out a retry test
+  # def test_retries
+  #   Coverband.configuration.api_key = FAKE_API_KEY
+  #   stub_request(:post, "#{COVERBAND_SERVICE_URL}/api/collector").to_return(body: {status: "OK"}.to_json, status: 200)
+  #   mock_file_hash
+  #   @store.save_report(basic_coverage)
+  # end
+
+  def test_no_webservice_call_without_api_key
+    Coverband.configuration.api_key = nil
+    mock_file_hash
+    @store.save_report(basic_coverage)
+  end
+
+  def test_clear
+    assert_raises RuntimeError do
+      @store.clear!
+    end
+  end
+
+  def test_clear_file
+    assert_raises RuntimeError do
+      @store.clear_file!("app_path/dog.rb")
+    end
+  end
+
+  def test_size
+    mock_file_hash
+    @store.type = :eager_loading
+    @store.save_report("app_path/dog.rb" => [0, 1, 1])
+    assert @store.size, 1
+  end
+end

data/test/coverband/collectors/delta_test.rb

@@ -114,6 +114,7 @@ class CollectorsDeltaTest < Minitest::Test
           oneshot_lines: [2, 3]
         }
       }
+      Coverband::Collectors::Delta.class_variable_set(:@@project_directory, "dealership.rb")
       ::Coverage.expects(:line_stub).with("dealership.rb").returns([nil, 0, 0, nil])
       results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
       expected = {

data/test/coverband/configuration_test.rb

@@ -4,6 +4,7 @@ require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class BaseTest < Minitest::Test
   def setup
+    Coverband.configuration.reset
     super
     Coverband.configuration.reset
     Coverband.configure do |config|
@@ -52,7 +53,7 @@ class BaseTest < Minitest::Test
     assert_equal current_paths, Coverband.configuration.root_paths
   end
 
-  test "store raises issues" do
+  test "store raises when not set to supported adapter" do
     Coverband::Collectors::Coverage.instance.reset_instance
     assert_raises RuntimeError do
       Coverband.configure do |config|
@@ -61,6 +62,56 @@ class BaseTest < Minitest::Test
     end
   end
 
+  test "store defaults to redis store" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    assert_equal Coverband.configuration.store.class, Coverband::Adapters::RedisStore
+  end
+
+  test "store is a service store when api_key is set" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.reset
+    Coverband.configure do |config|
+      config.redis_url = nil
+      config.api_key = "test-key"
+    end
+    assert_equal Coverband.configuration.store.class.to_s, "Coverband::Adapters::WebServiceStore"
+  end
+
+  test "store raises when api key set but not set to service" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.reset
+    assert_raises RuntimeError do
+      Coverband.configure do |config|
+        config.api_key = "test-key"
+        config.redis_url = "redis://localhost:3333"
+        config.store = Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: "coverband_test")
+      end
+    end
+  end
+
+  test "store raises when api key and coverband redis env" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.reset
+
+    env = ENV.to_hash.merge("COVERBAND_REDIS_URL" => "redis://localhost:3333")
+    Object.stub_const(:ENV, env) do
+      assert_raises RuntimeError do
+        Coverband.configure do |config|
+          config.api_key = "test-key"
+        end
+      end
+    end
+  end
+
+  test "store doesnt raises when api key and redis_url" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.reset
+    Coverband.configure do |config|
+      config.api_key = "test-key"
+      config.redis_url = "redis://localhost:3333"
+    end
+  end
+
   test "use_oneshot_lines_coverage" do
     refute Coverband.configuration.use_oneshot_lines_coverage
 

data/test/coverband/integrations/background_test.rb

@@ -12,18 +12,29 @@ class BackgroundTest < Minitest::Test
     end
   end
 
+  def setup
+    Coverband.configuration.reset
+    super
+    Coverband.configure do |config|
+      config.background_reporting_sleep_seconds = 60
+      Coverband.configuration.reporting_wiggle = 0
+    end
+  end
+
   def test_start
+    sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds.to_i
     Thread.expects(:new).yields.returns(ThreadDouble.new(true))
     Coverband::Background.expects(:loop).yields
-    Coverband::Background.expects(:sleep).with(30)
+    Coverband::Background.expects(:sleep).with(sleep_seconds)
     Coverband::Collectors::Coverage.instance.expects(:report_coverage).once
     2.times { Coverband::Background.start }
   end
 
   def test_start_with_wiggle
+    sleep_seconds = Coverband.configuration.background_reporting_sleep_seconds.to_i
     Thread.expects(:new).yields.returns(ThreadDouble.new(true))
     Coverband::Background.expects(:loop).yields
-    Coverband::Background.expects(:sleep).with(35)
+    Coverband::Background.expects(:sleep).with(sleep_seconds + 5)
     Coverband::Background.expects(:rand).with(10).returns(5)
     Coverband.configuration.reporting_wiggle = 10
     Coverband::Collectors::Coverage.instance.expects(:report_coverage).once
@@ -33,7 +44,7 @@ class BackgroundTest < Minitest::Test
   def test_start_dead_thread
     Thread.expects(:new).yields.returns(ThreadDouble.new(false)).twice
     Coverband::Background.expects(:loop).yields.twice
-    Coverband::Background.expects(:sleep).with(30).twice
+    Coverband::Background.expects(:sleep).with(60).twice
     Coverband::Collectors::Coverage.instance.expects(:report_coverage).twice
     2.times { Coverband::Background.start }
   end

data/test/jruby_check.rb

@@ -2,7 +2,7 @@ require "coverage"
 
 Coverage.start
 
-require "./test/dog.rb"
+require "./test/dog"
 
 puts Coverage.peek_result
 

data/test/test_helper.rb

@@ -6,6 +6,7 @@ require "rubygems"
 require "simplecov"
 require "coveralls"
 require "minitest/autorun"
+require "minitest/stub_const"
 require "mocha/minitest"
 require "ostruct"
 require "json"
@@ -21,6 +22,7 @@ require "coverband/utils/source_file"
 require "coverband/utils/lines_classifier"
 require "coverband/utils/results"
 require "coverband/reporters/html_report"
+require "webmock/minitest"
 
 # require 'pry-byebug' unless ENV['CI'] # Ruby 2.3 on CI crashes on pry & JRuby doesn't support it
 require_relative "unique_files"
@@ -44,6 +46,7 @@ module Coverband
     end
 
     def self.reset
+      Coverband.configuration.reset
       Coverband.configuration.redis_namespace = "coverband_test"
       Coverband.configuration.store.instance_variable_set(:@redis_namespace, "coverband_test")
       Coverband.configuration.store.class.class_variable_set(:@@path_cache, {})
@@ -51,6 +54,7 @@ module Coverband
       Coverband::Collectors::Coverage.instance.reset_instance
       Coverband::Utils::RelativeFileConverter.reset
       Coverband::Utils::AbsoluteFileConverter.reset
+      Coverband.configuration.reporting_wiggle = 0
       Coverband.configuration.redis_namespace = "coverband_test"
       Coverband::Background.stop
       Coverband.configuration.store.instance_variable_set(:@redis, redis)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coverband
 version: !ruby/object:Gem::Version
-  version: 5.0.0.rc.3
+  version: 5.0.0.rc.8
 platform: ruby
 authors:
 - Dan Mayer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -95,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-stub-const
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +179,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.5
 - !ruby/object:Gem::Dependency
   name: standardrb
   requirement: !ruby/object:Gem::Requirement
@@ -207,6 +235,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -249,10 +291,13 @@ files:
 - lib/coverband/adapters/file_store.rb
 - lib/coverband/adapters/hash_redis_store.rb
 - lib/coverband/adapters/redis_store.rb
+- lib/coverband/adapters/stdout_store.rb
+- lib/coverband/adapters/web_service_store.rb
 - lib/coverband/at_exit.rb
 - lib/coverband/collectors/coverage.rb
 - lib/coverband/collectors/delta.rb
 - lib/coverband/collectors/view_tracker.rb
+- lib/coverband/collectors/view_tracker_service.rb
 - lib/coverband/configuration.rb
 - lib/coverband/integrations/background.rb
 - lib/coverband/integrations/background_middleware.rb
@@ -319,6 +364,7 @@ files:
 - test/coverband/adapters/file_store_test.rb
 - test/coverband/adapters/hash_redis_store_test.rb
 - test/coverband/adapters/redis_store_test.rb
+- test/coverband/adapters/web_service_store_test.rb
 - test/coverband/at_exit_test.rb
 - test/coverband/collectors/coverage_test.rb
 - test/coverband/collectors/delta_test.rb
@@ -420,7 +466,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Rack middleware to measure production code usage (LOC runtime usage)
@@ -436,6 +482,7 @@ test_files:
 - test/coverband/adapters/file_store_test.rb
 - test/coverband/adapters/hash_redis_store_test.rb
 - test/coverband/adapters/redis_store_test.rb
+- test/coverband/adapters/web_service_store_test.rb
 - test/coverband/at_exit_test.rb
 - test/coverband/collectors/coverage_test.rb
 - test/coverband/collectors/delta_test.rb