coverband 1.5.0 → 2.0.0

data/changes.md

@@ -1,6 +1,37 @@
+# Future Roadmap
+
+### Coverband 3.0
+
+Will be the fully modern release that drops maintenance legacy support in favor of increased performance, ease of use, and maintainability.
+
+* expects to drop Tracepoint collection engine
+* expects to drop anything below Ruby 2.3
+* Release will be aimed as significantly simplifying ease of use
+   * expects to drop the concept of baseline recordings
+   * improve support for eager-loading
+   * add built-in support for easy loading via Railties
+   * expects to add safe list support to force reload files one wants coverage on that may happen outside of the standard load order
+   * built in support for activejob, sidekiq, and other common frameworks
+
+# Released
+
+### 2.0.0
+
+Major release with various backwards compatibility breaking changes (generally related to the configuration). The 2.0 lifecycle will act as a mostly easy upgrade that supports past users looking to move to the much faster new Coverage Adapter.
+
+* Continues to support Ruby 2.0 and up
+* supports multiple collect engines, introducing the concept of multiple collector adapters
+* extends the concepts of multiple storage adapters, enabling additional authors to help support Kafka, graphite, other adapters
+* old require based loading, but working towards deprecating the entire baseline concept
+* Introduces massive performance enhancements by moving to Ruby `Coverage` based collection
+   * Opposed to sampling this is now a reporting frequency, when using `Coverage` collector
+* Reduced configuration complexity
+* Refactoring the code preparing for more varied storage and reporting options
+* Drop Redis as a gem runtime_dependency
+
 ### 1.5.0
 
-This is a major release with significant refactoring a stepping stone for a 2.0 release.
+This is a significant release with significant refactoring a stepping stone for a 2.0 release.
 
 * staging a changes.md document!
 * refactored out full abstraction for stores
@@ -20,4 +51,4 @@ This is a major release with significant refactoring a stepping stone for a 2.0
 
 * This was a small fix release addressing some issues
 * mostly readme updates
-* last release prior to having a changes document!
+* last release prior to having a changes document!

data/coverband.gemspec

@@ -1,34 +1,41 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'coverband/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "coverband"
+  spec.name          = 'coverband'
   spec.version       = Coverband::VERSION
-  spec.authors       = ["Dan Mayer"]
-  spec.email         = ["dan@mayerdan.com"]
-  spec.description   = %q{Rack middleware to help measure production code usage (LOC runtime usage)}
-  spec.summary       = %q{Rack middleware to help measure production code usage (LOC runtime usage)}
-  spec.homepage      = "https://github.com/danmayer/coverband"
-  spec.license       = "MIT"
+  spec.authors       = ['Dan Mayer']
+  spec.email         = ['dan@mayerdan.com']
+  spec.description   = 'Rack middleware to help measure production code usage (LOC runtime usage)'
+  spec.summary       = 'Rack middleware to help measure production code usage (LOC runtime usage)'
+  spec.homepage      = 'https://github.com/danmayer/coverband'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split("\n")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "mocha", "~> 0.14.0"
-  spec.add_development_dependency "rack"
-  spec.add_development_dependency "rack-test"
-  spec.add_development_dependency "test-unit"
-  spec.add_development_dependency 'sinatra'
-  spec.add_development_dependency 'classifier-reborn'
   spec.add_development_dependency 'aws-sdk', '~> 2'
-  spec.add_runtime_dependency "simplecov"
-  spec.add_runtime_dependency "json"
-  # TODO make redis optional dependancy as we add additional adapters
-  spec.add_runtime_dependency "redis"
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'classifier-reborn'
+  spec.add_development_dependency 'mocha', '~> 0.14.0'
+  spec.add_development_dependency 'rack'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'sinatra'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency 'redis'
+  spec.add_development_dependency 'benchmark-ips'
+  # add when debugging
+  # require 'byebug'; byebug
+  #spec.add_development_dependency 'byebug'
+  # deprecate when dropping support for older ruby
+  spec.add_runtime_dependency 'json'
+  # todo make an optional dependency for simplecov reports
+  # also likely should just require simplecov-html not the whole lib
+  spec.add_runtime_dependency 'simplecov', '> 0.11.1'
 end

data/lib/coverband/adapters/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Adapters
+    class Base
+      def initialize
+        raise 'abstract'
+      end
+
+      def clear!
+        raise 'abstract'
+      end
+
+      def save_report(report)
+        raise 'abstract'
+      end
+
+      def coverage
+        raise 'abstract'
+      end
+
+      def covered_files
+        raise 'abstract'
+      end
+
+      def covered_lines_for_file(file)
+        raise 'abstract'
+      end
+    end
+  end
+end

data/lib/coverband/adapters/file_store.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Coverband
   module Adapters
-    class FileStore
+    class FileStore < Base
       attr_accessor :path
 
-      def initialize(path, opts = {})
+      def initialize(path, _opts = {})
         @path = path
 
         config_dir = File.dirname(@path)
@@ -11,18 +13,16 @@ module Coverband
       end
 
       def clear!
-        if File.exist?(path)
-          File.delete(path)
-        end
+        File.delete(path) if File.exist?(path)
       end
 
       def save_report(report)
         results = existing_data(path)
         report.each_pair do |file, values|
-          if results.has_key?(file)
+          if results.key?(file)
             # convert the keys to "3" opposed to 3
             values = JSON.parse(values.to_json)
-            results[file].merge!( values ){|k, old_v, new_v| old_v.to_i + new_v.to_i}
+            results[file].merge!(values) { |_k, old_v, new_v| old_v.to_i + new_v.to_i }
           else
             results[file] = values
           end
@@ -53,7 +53,6 @@ module Coverband
           {}
         end
       end
-
     end
   end
 end

data/lib/coverband/adapters/memory_cache_store.rb

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
+###
+# TODO current benchmarks aren't showing much advantage from this wrapped cache approach
+# re-evaluate before 2.0.0 release 
+###
 module Coverband
   module Adapters
-    class MemoryCacheStore
+    class MemoryCacheStore < Base
       attr_accessor :store
 
       def initialize(store)
@@ -20,10 +26,11 @@ module Coverband
         store.save_report(filtered_files) if filtered_files.any?
       end
 
+      # rubocop:disable Lint/IneffectiveAccessModifier
       private
 
       def self.files_cache
-        @files_cache ||= Hash.new
+        @files_cache ||= {}
       end
 
       def files_cache
@@ -31,16 +38,16 @@ module Coverband
       end
 
       def filter(files)
-        files.each_with_object(Hash.new) do |(file, lines), filtered_file_hash|
-          #first time we see a file, we pre-init the in memory cache to whatever is in store(redis)
+        files.each_with_object({}) do |(file, lines), filtered_file_hash|
+          # first time we see a file, we pre-init the in memory cache to whatever is in store(redis)
           line_cache = files_cache[file] ||= Set.new(store.covered_lines_for_file(file))
           lines.reject! do |line|
-            line_cache.include?(line) ? true : (line_cache << line and false)
+            line_cache.include?(line) ? true : (line_cache << line && false)
           end
           filtered_file_hash[file] = lines if lines.any?
         end
       end
-
+      # rubocop:enable Lint/IneffectiveAccessModifier
     end
   end
 end

data/lib/coverband/adapters/redis_store.rb

@@ -1,14 +1,12 @@
+# frozen_string_literal: true
+
 module Coverband
   module Adapters
-    class RedisStore
-      BASE_KEY = 'coverband1'
+    class RedisStore < Base
+      BASE_KEY = 'coverband2'
 
       def initialize(redis, opts = {})
         @redis = redis
-        #remove check for coverband 2.0
-        @_sadd_supports_array = recent_gem_version? && recent_server_version?
-        #possibly drop array storage for 2.0
-        @store_as_array = opts.fetch(:array){ false }
       end
 
       def clear!
@@ -17,20 +15,10 @@ module Coverband
       end
 
       def save_report(report)
-        if @store_as_array
-          redis.pipelined do
-            store_array(BASE_KEY, report.keys)
-
-            report.each do |file, lines|
-              store_array("#{BASE_KEY}.#{file}", lines.keys)
-            end
-          end
-        else
-          store_array(BASE_KEY, report.keys)
+        store_array(BASE_KEY, report.keys)
 
-          report.each do |file, lines|
-            store_map("#{BASE_KEY}.#{file}", lines)
-          end
+        report.each do |file, lines|
+          store_map("#{BASE_KEY}.#{file}", lines)
         end
       end
 
@@ -47,55 +35,27 @@ module Coverband
       end
 
       def covered_lines_for_file(file)
-        if @store_as_array
-          @redis.smembers("#{BASE_KEY}.#{file}").map(&:to_i)
-        else
-          @redis.hgetall("#{BASE_KEY}.#{file}")
-        end
+        @redis.hgetall("#{BASE_KEY}.#{file}")
       end
 
       private
 
       attr_reader :redis
 
-      def sadd_supports_array?
-        @_sadd_supports_array
-      end
-
       def store_map(key, values)
         unless values.empty?
           existing = redis.hgetall(key)
-          #in redis all keys are strings
-          values = Hash[values.map{|k,val| [k.to_s,val] } ]
-          values.merge!( existing ){|k, old_v, new_v| old_v.to_i + new_v.to_i}
+          # in redis all keys are strings
+          values = Hash[values.map { |k, val| [k.to_s, val] }]
+          values.merge!(existing) { |_k, old_v, new_v| old_v.to_i + new_v.to_i }
           redis.mapped_hmset(key, values)
         end
       end
 
       def store_array(key, values)
-        if sadd_supports_array?
-          redis.sadd(key, values) if (values.length > 0)
-        else
-          values.each do |value|
-            redis.sadd(key, value)
-          end
-        end
+        redis.sadd(key, values) unless values.empty?
         values
       end
-
-      def recent_server_version?
-        info_data = redis.info
-        if info_data.is_a?(Hash)
-          Gem::Version.new(info_data['redis_version']) >= Gem::Version.new('2.4')
-        else
-          #guess supported
-          true
-        end
-      end
-
-      def recent_gem_version?
-        Gem::Version.new(Redis::VERSION) >= Gem::Version.new('3.0')
-      end
     end
   end
 end

data/lib/coverband/baseline.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Coverband
   class Baseline
-
     def self.record
       require 'coverage'
       Coverage.start
@@ -8,15 +9,24 @@ module Coverband
 
       project_directory = File.expand_path(Coverband.configuration.root)
       results = Coverage.result
-      results = results.reject { |key, val| !key.match(project_directory) || Coverband.configuration.ignore.any? { |pattern| key.match(/#{pattern}/) } }
+      results = results.reject { |key, _val| !key.match(project_directory) || Coverband.configuration.ignore.any? { |pattern| key.match(/#{pattern}/) } }
 
       Coverband.configuration.store.save_report(convert_coverage_format(results))
     end
 
-    def self.parse_baseline(back_compat = nil)
+    def self.parse_baseline(_back_compat = nil)
       Coverband.configuration.store.coverage
     end
 
+    def self.exclude_files(files)
+      Coverband.configuration.ignore.each do |ignore|
+        path = Coverband.configuration.root + "/#{ignore}"
+        excludes = File.directory?(path) ? Dir.glob("#{path}/**/*") : [path]
+        files -= excludes
+      end
+      files
+    end
+
     private
 
     def self.convert_coverage_format(results)
@@ -24,12 +34,11 @@ module Coverband
       results.each_pair do |file, data|
         lines_map = {}
         data.each_with_index do |hits, index|
-          lines_map[(index+1)] = hits unless hits.nil?
+          lines_map[(index + 1)] = hits unless hits.nil?
         end
         file_map[file] = lines_map
       end
       file_map
     end
-
   end
 end

data/lib/coverband/collectors/base.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+####
+# TODO refactor this along with the coverage and trace collector
+####
+module Coverband
+  module Collectors
+    class Base
+      def self.instance
+        if Coverband.configuration.collector == 'trace'
+          Thread.current[:coverband_instance] ||= Coverband::Collectors::Trace.new
+        elsif Coverband.configuration.collector == 'coverage'
+          Thread.current[:coverband_instance] ||= Coverband::Collectors::Coverage.new
+        else
+          raise 'select valid collector [trace, coverage]'
+        end
+      end
+
+      def start
+        @enabled = true
+        record_coverage
+      end
+
+      def stop
+        @enabled = false
+        stop_coverage
+      end
+
+      def sample
+        configure_sampling
+        record_coverage
+        result = yield
+        report_coverage
+        result
+      end
+
+      def save
+        @enabled = true
+        report_coverage
+        @enabled = false
+      end
+
+      def reset_instance
+        @project_directory = File.expand_path(Coverband.configuration.root)
+        @enabled = false
+        @disable_on_failure_for = Coverband.configuration.disable_on_failure_for
+        @file_line_usage = {}
+        @ignored_files = Set.new
+        @startup_delay = Coverband.configuration.startup_delay
+        @ignore_patterns = Coverband.configuration.ignore + ['internal:prelude', 'schema.rb']
+        @ignore_patterns += ['gems'] unless Coverband.configuration.include_gems
+        @sample_percentage = Coverband.configuration.percentage
+        @store = Coverband.configuration.store
+        @store = Coverband::Adapters::MemoryCacheStore.new(@store) if Coverband.configuration.memory_caching
+        @verbose  = Coverband.configuration.verbose
+        @logger   = Coverband.configuration.logger
+        @current_thread = Thread.current
+        Thread.current[:coverband_instance] = nil
+        self
+      end
+
+      def configure_sampling
+        if @startup_delay != 0 || (rand * 100.0) > @sample_percentage
+          @startup_delay -= 1 if @startup_delay > 0
+          @enabled = false
+        else
+          @enabled = true
+        end
+      end
+
+      def record_coverage
+        raise 'abstract'
+      end
+
+      def stop_coverage
+        raise 'abstract'
+      end
+
+      def report_coverage
+        raise 'abstract'
+      end
+
+      protected
+
+      def track_file?(file)
+        @ignore_patterns.none? { |pattern| file.include?(pattern) } && file.start_with?(@project_directory)
+      end
+
+      def output_file_line_usage
+        @logger.info 'coverband debug coverband file:line usage:'
+        @file_line_usage.sort_by { |_key, value| value.length }.each do |pair|
+          file = pair.first
+          lines = pair.last
+          @logger.info "file: #{file} => #{lines.sort_by { |_key, value| value }}"
+        end
+      end
+
+      private
+
+      def failed_at_thread_key
+        "__#{self.class.name}__failed_at"
+      end
+
+      def failed_at
+        Thread.current[failed_at_thread_key]
+      end
+
+      def failed_at=(time)
+        Thread.current[failed_at_thread_key] = time
+      end
+
+      def failed!
+        self.failed_at = Time.now
+      end
+
+      def failed_recently?
+        return false unless @disable_on_failure_for && failed_at
+        failed_at + @disable_on_failure_for > Time.now
+      end
+
+      def initialize
+        reset_instance
+      end
+    end
+  end
+end

data/lib/coverband/collectors/coverage.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Collectors
+    class Coverage < Base
+      def record_coverage
+        # noop
+      end
+
+      def stop_coverage
+        # noop
+      end
+
+      def report_coverage
+        unless @enabled
+          @logger.info 'coverage disabled' if @verbose
+          return
+        end
+
+        if failed_recently?
+          @logger.info 'coverage reporting standing-by because of recent failure' if @verbose
+          return
+        end
+
+        new_results = nil
+        @semaphore.synchronize { new_results = new_coverage(::Coverage.peek_result.dup) }
+        new_results.each_pair do |file, line_counts|
+          next if @ignored_files.include?(file)
+          next unless track_file?(file)
+          add_file(file, line_counts)
+        end
+
+        if @verbose
+          @logger.info "coverband file usage: #{file_usage.inspect}"
+          output_file_line_usage if @verbose == 'debug'
+        end
+
+        if @store
+          @store.save_report(@file_line_usage)
+          @file_line_usage.clear
+        elsif @verbose
+          @logger.info 'coverage report: '
+          @logger.info @file_line_usage.inspect
+        end
+      # StandardError might be better option
+      # coverband previously had RuntimeError here
+      # but runtime error can let a large number of error crash this method
+      # and this method is currently in a ensure block in middleware
+      rescue StandardError => err
+        failed!
+        if @verbose
+          @logger.info 'coverage missing'
+          @logger.info "error: #{err.inspect} #{err.message}"
+        end
+      end
+
+      private
+
+      def array_diff(latest, original)
+        latest.map.with_index { |v, i| v ? v - original[i] : nil }
+      end
+
+      def previous_results
+        @@previous_results
+      end
+
+      def add_previous_results(val)
+        @@previous_results = val
+      end
+
+      def new_coverage(current_coverage)
+        if previous_results
+          new_results = {}
+          current_coverage.each_pair do |file, line_counts|
+            if previous_results[file]
+              new_results[file] = array_diff(line_counts, previous_results[file])
+            else
+              new_results[file] = line_counts
+            end
+          end
+        else
+          new_results = current_coverage
+        end
+
+        add_previous_results(current_coverage)
+        new_results.dup
+      end
+
+      # TODO this seems like a dumb conversion for the already good coverage format
+      # coverage is 0 based other implementation matches line number
+      def add_file(file, line_counts)
+        @file_line_usage[file] = Hash.new(0) unless @file_line_usage.include?(file)
+        line_counts.each_with_index do |line_count, index|
+          @file_line_usage[file][(index + 1)] = line_count if line_count
+        end
+      end
+
+      def file_usage
+        hash = {}
+        @file_line_usage.each do |file, lines|
+          hash[file] = lines.values.compact.inject(0, :+)
+        end
+        hash.sort_by { |_key, value| value }
+      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
+        unless defined?(::Coverage)
+          # puts 'loading coverage'
+          require 'coverage'
+        end
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+          ::Coverage.start unless ::Coverage.running?
+        else
+          ::Coverage.start
+        end
+        @semaphore = Mutex.new
+        @@previous_results = nil
+        reset_instance
+      end
+    end
+  end
+end