coverband 4.2.6 → 5.0.0.rc.5

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/at_exit.rb

@@ -6,7 +6,7 @@ module Coverband
 
     @at_exit_registered = nil
     def self.register
-      return if ENV['COVERBAND_DISABLE_AT_EXIT']
+      return if ENV["COVERBAND_DISABLE_AT_EXIT"]
       return if @at_exit_registered
 
       @semaphore.synchronize do

data/lib/coverband/collectors/coverage.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'singleton'
-require_relative 'delta'
+require "singleton"
+require_relative "delta"
 
 module Coverband
   module Collectors
@@ -25,7 +25,6 @@ module Coverband
         @verbose = Coverband.configuration.verbose
         @logger = Coverband.configuration.logger
         @test_env = Coverband.configuration.test_env
-        @track_gems = Coverband.configuration.track_gems
         Delta.reset
         self
       end
@@ -49,53 +48,42 @@ module Coverband
 
       def report_coverage
         @semaphore.synchronize do
-          raise 'no Coverband store set' unless @store
+          raise "no Coverband store set" unless @store
 
           files_with_line_usage = filtered_files(Delta.results)
           @store.save_report(files_with_line_usage)
         end
-      rescue StandardError => e
-        @logger&.error 'coverage failed to store'
+      rescue => e
+        @logger&.error "coverage failed to store"
         @logger&.error "Coverband Error: #{e.inspect} #{e.message}"
         e.backtrace.each { |line| @logger&.error line } if @verbose
         raise e if @test_env
       end
 
-      protected
-
-      ###
-      # 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.
-      ###
-      def track_file?(file)
-        @ignore_patterns.none? do |pattern|
-          file.match(pattern)
-        end && (file.start_with?(@project_directory) ||
-                (@track_gems &&
-                 Coverband.configuration.gem_paths.any? { |path| file.start_with?(path) }))
-      end
-
       private
 
       def filtered_files(new_results)
-        new_results.select! { |file, coverage| track_file?(file) && coverage.any? { |value| value&.nonzero? } }
+        new_results.select! { |_file, coverage| coverage.any? { |value| value&.nonzero? } }
         new_results
       end
 
       def initialize
         @semaphore = Mutex.new
-        raise NotImplementedError, 'Coverage needs Ruby > 2.3.0' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3.0')
+        raise NotImplementedError, "Coverage needs Ruby > 2.3.0" if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.3.0")
 
-        require 'coverage'
+        require "coverage"
+        if RUBY_PLATFORM == "java"
+          unless ::Coverage.respond_to?(:line_stub)
+            require "coverband/utils/jruby_ext"
+          end
+        end
         if defined?(SimpleCov) && defined?(Rails) && defined?(Rails.env) && Rails.env.test?
           puts "Coverband: detected SimpleCov in test Env, allowing it to start Coverage"
           puts "Coverband: to ensure no error logs or missing Coverage call `SimpleCov.start` prior to requiring Coverband"
         else
-          if Coverage.ruby_version_greater_than_or_equal_to?('2.6.0')
+          if Coverage.ruby_version_greater_than_or_equal_to?("2.6.0")
             ::Coverage.start(oneshot_lines: Coverband.configuration.use_oneshot_lines_coverage) unless ::Coverage.running?
-          elsif Coverage.ruby_version_greater_than_or_equal_to?('2.5.0')
+          elsif Coverage.ruby_version_greater_than_or_equal_to?("2.5.0")
             ::Coverage.start unless ::Coverage.running?
           else
             ::Coverage.start

data/lib/coverband/collectors/delta.rb

@@ -39,23 +39,33 @@ module Coverband
 
       def self.reset
         @@previous_coverage = {}
+        @@project_directory = File.expand_path(Coverband.configuration.root)
+        @@ignore_patterns = Coverband.configuration.ignore
       end
 
       private
 
       def generate
-        # TODO: if we filtered before doing this we would avoid calculating the line diff on a ton of files
-        # This would be a fairly noticeable perf win
         current_coverage.each_with_object({}) do |(file, line_counts), 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)
+
           # This handles Coverage branch support, setup by default in
           # simplecov 0.18.x
           arr_line_counts = line_counts.is_a?(Hash) ? line_counts[:lines] : line_counts
           new_results[file] = if @@previous_coverage && @@previous_coverage[file]
-                                prev_line_counts = @@previous_coverage[file].is_a?(Hash) ? @@previous_coverage[file][:lines] : @@previous_coverage[file]
-                                array_diff(arr_line_counts, prev_line_counts)
-                              else
-                                arr_line_counts
-                              end
+            prev_line_counts = @@previous_coverage[file].is_a?(Hash) ? @@previous_coverage[file][:lines] : @@previous_coverage[file]
+            array_diff(arr_line_counts, prev_line_counts)
+          else
+            arr_line_counts
+          end
         end
       end
 
@@ -67,10 +77,20 @@ 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) do |line_number, line_counts|
+          transformed_line_counts = coverage[:oneshot_lines].each_with_object(@@stubs[file].dup) { |line_number, line_counts|
             line_counts[line_number - 1] = 1
-          end
+          }
           new_results[file] = transformed_line_counts
         end
       end

data/lib/coverband/collectors/view_tracker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'singleton'
+require "singleton"
 
 module Coverband
   module Collectors
@@ -14,12 +14,12 @@ module Coverband
     # TODO: test and ensure slim, haml, and other support
     ###
     class ViewTracker
-      DEFAULT_TARGET = Dir.glob('app/views/**/*.html.erb').reject { |file| file.match(/(_mailer)/) }
+      DEFAULT_TARGET = Dir.glob("app/views/**/*.html.erb").reject { |file| file.match(/(_mailer)/) }
       attr_accessor :target, :logged_views, :views_to_record
       attr_reader :logger, :roots, :store, :ignore_patterns
 
       def initialize(options = {})
-        raise NotImplementedError, 'View Tracker requires Rails 4 or greater' unless self.class.supported_version?
+        raise NotImplementedError, "View Tracker requires Rails 4 or greater" unless self.class.supported_version?
 
         @project_directory = File.expand_path(Coverband.configuration.root)
         @ignore_patterns = Coverband.configuration.ignore
@@ -28,7 +28,7 @@ module Coverband
         @target = options.fetch(:target) { DEFAULT_TARGET }
 
         @roots = options.fetch(:roots) { Coverband.configuration.all_root_patterns }
-        @roots = @roots.split(',') if @roots.is_a?(String)
+        @roots = @roots.split(",") if @roots.is_a?(String)
         @one_time_timestamp = false
 
         @logged_views = []
@@ -65,7 +65,7 @@ module Coverband
         normalized_views = {}
         views.each_pair do |view, time|
           roots.each do |root|
-            view = view.gsub(/#{root}/, '')
+            view = view.gsub(/#{root}/, "")
           end
           normalized_views[view] = time
         end
@@ -90,7 +90,7 @@ module Coverband
         if (tracking_time = redis_store.get(tracker_time_key))
           Time.at(tracking_time.to_i).iso8601
         else
-          'N/A'
+          "N/A"
         end
       end
 
@@ -115,14 +115,14 @@ module Coverband
           redis_store.hset(tracker_key, file, reported_time)
         end
         self.views_to_record = []
-      rescue StandardError => e
+      rescue => e
         # we don't want to raise errors if Coverband can't reach redis.
         # This is a nice to have not a bring the system down
         logger&.error "Coverband: view_tracker failed to store, error #{e.class.name}"
       end
 
       def self.supported_version?
-        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split('.').first.to_i >= 4
+        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 4
       end
 
       protected
@@ -154,11 +154,11 @@ module Coverband
       end
 
       def tracker_key
-        'render_tracker_2'
+        "render_tracker_2"
       end
 
       def tracker_time_key
-        'render_tracker_time'
+        "render_tracker_time"
       end
     end
   end

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