coverband 5.2.6.rc.1 → 5.2.6.rc.3

data/lib/coverband/collectors/view_tracker.rb

@@ -12,45 +12,35 @@ module Coverband
     # but am now rolling into Coverband
     # https://github.com/livingsocial/flatfoot
     ###
-    class ViewTracker
-      attr_accessor :target
-      attr_reader :logger, :roots, :store, :ignore_patterns
+    class ViewTracker < AbstractTracker
+      attr_reader :roots
 
-      def initialize(options = {})
-        raise NotImplementedError, "View Tracker requires Rails 4 or greater" unless self.class.supported_version?
-        raise "Coverband: view tracker initialized before configuration!" if !Coverband.configured? && ENV["COVERBAND_TEST"] == "test"
+      REPORT_ROUTE = "views_tracker"
+      TITLE = "Views"
 
+      def initialize(options = {})
         @project_directory = File.expand_path(Coverband.configuration.root)
-        @ignore_patterns = Coverband.configuration.ignore
-        @store = options.fetch(:store) { Coverband.configuration.store }
-        @logger = options.fetch(:logger) { Coverband.configuration.logger }
-        @target = options.fetch(:target) { Dir.glob("#{@project_directory}/app/views/**/*.html.{erb,haml,slim}") }
-
         @roots = options.fetch(:roots) { Coverband.configuration.all_root_patterns }
         @roots = @roots.split(",") if @roots.is_a?(String)
-        @one_time_timestamp = false
-
-        @logged_views = Set.new
-        @views_to_record = Set.new
-      end
 
-      def logged_views
-        @logged_views.to_a
+        super
       end
 
-      def views_to_record
-        @views_to_record.to_a
+      def railtie!
+        ActiveSupport::Notifications.subscribe(/render_(template|partial|collection).action_view/) do |name, start, finish, id, payload|
+          Coverband.configuration.view_tracker.track_key(payload) unless name.include?("!")
+        end
       end
 
       ###
       # This method is called on every render call, so we try to reduce method calls
       # and ensure high performance
       ###
-      def track_views(_name, _start, _finish, _id, payload)
+      def track_key(payload)
         if (file = payload[:identifier])
-          if newly_seen_file?(file)
-            @logged_views << file
-            @views_to_record << file if track_file?(file)
+          if newly_seen_key?(file)
+            @logged_keys << file
+            @keys_to_record << file if track_file?(file)
           end
         end
 
@@ -61,13 +51,13 @@ module Coverband
         # http://edgeguides.rubyonrails.org/active_support_instrumentation.html#render_partial-action_view
         ###
         return unless (layout_file = payload[:layout])
-        return unless newly_seen_file?(layout_file)
+        return unless newly_seen_key?(layout_file)
 
-        @logged_views << layout_file
-        @views_to_record << layout_file if track_file?(layout_file, layout: true)
+        @logged_keys << layout_file
+        @keys_to_record << layout_file if track_file?(layout_file, layout: true)
       end
 
-      def used_views
+      def used_keys
         views = redis_store.hgetall(tracker_key)
         normalized_views = {}
         views.each_pair do |view, time|
@@ -79,7 +69,7 @@ module Coverband
         normalized_views
       end
 
-      def all_views
+      def all_keys
         all_views = []
         target.each do |view|
           roots.each do |root|
@@ -90,92 +80,35 @@ module Coverband
         all_views.uniq
       end
 
-      def unused_views(used_views = nil)
-        recently_used_views = (used_views || self.used_views).keys
-        unused_views = all_views - recently_used_views
+      def unused_keys(used_views = nil)
+        recently_used_views = (used_keys || used_keys).keys
+        unused_views = all_keys - recently_used_views
         # since layouts don't include format we count them used if they match with ANY formats
         unused_views.reject { |view| view.match(/\/layouts\//) && recently_used_views.any? { |used_view| view.include?(used_view) } }
       end
 
-      def as_json
-        used_views = self.used_views
-        {
-          unused_views: unused_views(used_views),
-          used_views: used_views
-        }.to_json
-      end
-
-      def tracking_since
-        if (tracking_time = redis_store.get(tracker_time_key))
-          Time.at(tracking_time.to_i).iso8601
-        else
-          "N/A"
-        end
-      end
-
-      def reset_recordings
-        redis_store.del(tracker_key)
-        redis_store.del(tracker_time_key)
-      end
-
-      def clear_file!(filename)
+      def clear_key!(filename)
         return unless filename
 
         filename = "#{@project_directory}/#{filename}"
         redis_store.hdel(tracker_key, filename)
-        @logged_views.delete(filename)
-      end
-
-      def report_views_tracked
-        redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || tracker_time_key_exists?
-        @one_time_timestamp = true
-        reported_time = Time.now.to_i
-        @views_to_record.to_a.each do |file|
-          redis_store.hset(tracker_key, file, reported_time)
-        end
-        @views_to_record.clear
-      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
+        @logged_keys.delete(filename)
       end
 
-      protected
-
-      def newly_seen_file?(file)
-        !@logged_views.include?(file)
-      end
+      private
 
       def track_file?(file, options = {})
         (file.start_with?(@project_directory) || options[:layout]) &&
           @ignore_patterns.none? { |pattern| file.include?(pattern) }
       end
 
-      private
-
-      def redis_store
-        store.raw_store
-      end
-
-      def tracker_time_key_exists?
-        if defined?(redis_store.exists?)
-          redis_store.exists?(tracker_time_key)
+      def concrete_target
+        if defined?(Rails.application)
+          Dir.glob("#{@project_directory}/app/views/**/*.html.{erb,haml,slim}")
         else
-          redis_store.exists(tracker_time_key)
+          []
         end
       end
-
-      def tracker_key
-        "render_tracker_2"
-      end
-
-      def tracker_time_key
-        "render_tracker_time"
-      end
     end
   end
 end

data/lib/coverband/collectors/view_tracker_service.rb

@@ -6,7 +6,7 @@ module Coverband
     # This class extends view tracker to support web service reporting
     ###
     class ViewTrackerService < ViewTracker
-      def report_views_tracked
+      def save_report
         reported_time = Time.now.to_i
         if @views_to_record.any?
           relative_views = @views_to_record.map! do |view|

data/lib/coverband/configuration.rb

@@ -10,7 +10,9 @@ module Coverband
       :simulate_oneshot_lines_coverage,
       :view_tracker, :defer_eager_loading_data,
       :track_routes, :route_tracker,
-      :track_translations, :translations_tracker
+      :track_translations, :translations_tracker,
+      :trackers, :csp_policy
+
     attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id,
       :s3_secret_access_key, :password, :api_key, :service_url, :coverband_timeout, :service_dev_mode,
       :service_test_mode, :process_type, :track_views, :redis_url,
@@ -81,6 +83,7 @@ module Coverband
       @all_root_paths = nil
       @all_root_patterns = nil
       @password = nil
+      @csp_policy = false
 
       # coverband service settings
       @api_key = nil
@@ -95,6 +98,8 @@ module Coverband
       @redis_ttl = 2_592_000 # in seconds. Default is 30 days.
       @reporting_wiggle = nil
 
+      @trackers = []
+
       # TODO: these are deprecated
       @s3_region = nil
       @s3_bucket = nil
@@ -104,6 +109,31 @@ module Coverband
       @gem_details = false
     end
 
+    def railtie!
+      if Coverband.configuration.track_routes
+        Coverband.configuration.route_tracker = Coverband::Collectors::RouteTracker.new
+        trackers << Coverband.configuration.route_tracker
+      end
+
+      if Coverband.configuration.track_translations
+        Coverband.configuration.translations_tracker = Coverband::Collectors::TranslationTracker.new
+        trackers << Coverband.configuration.translations_tracker
+      end
+
+      if Coverband.configuration.track_views
+        Coverband.configuration.view_tracker = if Coverband.coverband_service?
+          Coverband::Collectors::ViewTrackerService.new
+        else
+          Coverband::Collectors::ViewTracker.new
+        end
+        trackers << Coverband.configuration.view_tracker
+      end
+      trackers.each { |tracker| tracker.railtie! }
+    rescue Redis::CannotConnectError => error
+      Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
+      Coverband.configuration.logger.info "If this is a setup task like assets:precompile feel free to ignore"
+    end
+
     def logger
       @logger ||= if defined?(Rails.logger) && Rails.logger
         Rails.logger
@@ -177,7 +207,10 @@ module Coverband
     # Don't allow the ignore to override things like gem tracking
     ###
     def ignore=(ignored_array)
+      ignored_array.map { |ignore_str| Regexp.new(ignore_str) }
       @ignore = (@ignore + ignored_array).uniq
+    rescue RegexpError
+      logger.error "an invalid regular expression was passed in, ensure string are valid regex patterns #{ignored_array.join(",")}"
     end
 
     def current_root

data/lib/coverband/integrations/background.rb

@@ -38,9 +38,7 @@ module Coverband
             # if deferred is set also sleep frst to spread load
             sleep(sleep_seconds.to_i) if Coverband.configuration.defer_eager_loading_data?
             Coverband.report_coverage
-            Coverband.configuration.view_tracker&.report_views_tracked
-            Coverband.configuration.route_tracker&.report_routes_tracked
-            Coverband.configuration.translations_tracker&.save_report
+            Coverband.configuration.trackers.each { |tracker| tracker.save_report }
             if Coverband.configuration.verbose
               logger.debug("Coverband: background reporting coverage (#{Coverband.configuration.store.type}). Sleeping #{sleep_seconds}s")
             end

data/lib/coverband/reporters/web.rb

@@ -13,6 +13,22 @@ module Coverband
     class Web
       attr_reader :request
 
+      CSP_HEADER = [
+        "default-src 'self' https: http:",
+        "child-src 'self'",
+        "connect-src 'self' https: http: wss: ws:",
+        "font-src 'self' https: http:",
+        "frame-src 'self'",
+        "img-src 'self' https: http: data:",
+        "manifest-src 'self'",
+        "media-src 'self'",
+        "object-src 'none'",
+        "script-src 'self' https: http: 'unsafe-inline'",
+        "style-src 'self' https: http: 'unsafe-inline'",
+        "worker-src 'self'",
+        "base-uri 'self'"
+      ].join("; ").freeze
+
       def init_web
         full_path = Gem::Specification.find_by_name("coverband").full_gem_path
         @static = Rack::Static.new(self,
@@ -36,51 +52,49 @@ module Coverband
         return [401, {"www-authenticate" => 'Basic realm=""'}, [""]] unless check_auth
 
         request_path_info = request.path_info == "" ? "/" : request.path_info
-        if request.post?
-          case request_path_info
-          when %r{\/clear_route_tracking_route}
-            clear_route_tracking_route
-          when %r{\/clear_route_tracking}
-            clear_route_tracking
-          when %r{\/clear_translation_tracking_key}
-            clear_route_translation_key
-          when %r{\/clear_translation_tracking}
-            clear_translation_tracking
-          when %r{\/clear_view_tracking_file}
-            clear_view_tracking_file
-          when %r{\/clear_view_tracking}
-            clear_view_tracking
-          when %r{\/clear_file}
-            clear_file
-          when %r{\/clear}
-            clear
-          else
-            [404, {"Content-Type" => "text/html"}, ["404 error!"]]
+        tracker_route = false
+        Coverband.configuration.trackers.each do |tracker|
+          if request_path_info.match(tracker.class::REPORT_ROUTE)
+            tracker_route = true
+            if request_path_info =~ %r{\/clear_.*_key}
+              return clear_abstract_tracking_key(tracker)
+            elsif request_path_info =~ %r{\/clear_.*}
+              return clear_abstract_tracking(tracker)
+            else
+              return [200, {"Content-Type" => "text/html"}, [display_abstract_tracker(tracker)]]
+            end
           end
-        else
-          case request_path_info
-          when /.*\.(css|js|gif|png)/
-            @static.call(env)
-          when %r{\/settings}
-            [200, {"Content-Type" => "text/html"}, [settings]]
-          when %r{\/view_tracker_data}
-            [200, {"Content-Type" => "text/json"}, [view_tracker_data]]
-          when %r{\/view_tracker}
-            [200, {"Content-Type" => "text/html"}, [view_tracker]]
-          when %r{\/route_tracker}
-            [200, {"Content-Type" => "text/html"}, [route_tracker]]
-          when %r{\/translations_tracker}
-            [200, {"Content-Type" => "text/html"}, [translations_tracker]]
-          when %r{\/enriched_debug_data}
-            [200, {"Content-Type" => "text/json"}, [enriched_debug_data]]
-          when %r{\/debug_data}
-            [200, {"Content-Type" => "text/json"}, [debug_data]]
-          when %r{\/load_file_details}
-            [200, {"Content-Type" => "text/json"}, [load_file_details]]
-          when %r{\/$}
-            [200, {"Content-Type" => "text/html"}, [index]]
+        end
+
+        unless tracker_route
+          if request.post?
+            case request_path_info
+            when %r{\/clear_file}
+              clear_file
+            when %r{\/clear}
+              clear
+            else
+              [404, coverband_headers, ["404 error!"]]
+            end
           else
-            [404, {"Content-Type" => "text/html"}, ["404 error!"]]
+            case request_path_info
+            when /.*\.(css|js|gif|png)/
+              @static.call(env)
+            when %r{\/settings}
+              [200, coverband_headers, [settings]]
+            when %r{\/view_tracker_data}
+              [200, coverband_headers(content_type: "text/json"), [view_tracker_data]]
+            when %r{\/enriched_debug_data}
+              [200, coverband_headers(content_type: "text/json"), [enriched_debug_data]]
+            when %r{\/debug_data}
+              [200, coverband_headers(content_type: "text/json"), [debug_data]]
+            when %r{\/load_file_details}
+              [200, coverband_headers(content_type: "text/json"), [load_file_details]]
+            when %r{\/$}
+              [200, coverband_headers, [index]]
+            else
+              [404, coverband_headers, ["404 error!"]]
+            end
           end
         end
       end
@@ -99,32 +113,17 @@ module Coverband
         Coverband::Utils::HTMLFormatter.new(nil, base_path: base_path).format_settings!
       end
 
-      def view_tracker
-        notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params["notice"])}<br/>"
-        notice = request.params["notice"] ? notice : ""
-        Coverband::Utils::HTMLFormatter.new(nil,
-          notice: notice,
-          base_path: base_path).format_view_tracker!
-      end
-
-      def route_tracker
-        notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params["notice"])}<br/>"
-        notice = request.params["notice"] ? notice : ""
-        Coverband::Utils::HTMLFormatter.new(nil,
-          notice: notice,
-          base_path: base_path).format_route_tracker!
-      end
-
-      def translations_tracker
+      def display_abstract_tracker(tracker)
         notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params["notice"])}<br/>"
         notice = request.params["notice"] ? notice : ""
         Coverband::Utils::HTMLFormatter.new(nil,
+          tracker: tracker,
           notice: notice,
-          base_path: base_path).format_translations_tracker!
+          base_path: base_path).format_abstract_tracker!
       end
 
       def view_tracker_data
-        Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store).as_json
+        Coverband::Collectors::ViewTracker.new.as_json
       end
 
       def debug_data
@@ -168,77 +167,37 @@ module Coverband
         [302, {"Location" => "#{base_path}?notice=#{notice}"}, []]
       end
 
-      def clear_view_tracking
+      def clear_abstract_tracking(tracker)
         if Coverband.configuration.web_enable_clear
-          tracker = Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store)
           tracker.reset_recordings
-          notice = "view tracking reset"
+          notice = "#{tracker.title} tracking reset"
         else
           notice = "web_enable_clear isn't enabled in your configuration"
         end
-        [302, {"Location" => "#{base_path}/view_tracker?notice=#{notice}"}, []]
+        [302, {"Location" => "#{base_path}/#{tracker.route}?notice=#{notice}"}, []]
       end
 
-      def clear_view_tracking_file
+      def clear_abstract_tracking_key(tracker)
         if Coverband.configuration.web_enable_clear
-          tracker = Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store)
-          filename = request.params["filename"]
-          tracker.clear_file!(filename)
-          notice = "coverage for file #{filename} cleared"
-        else
-          notice = "web_enable_clear isn't enabled in your configuration"
-        end
-        [302, {"Location" => "#{base_path}/view_tracker?notice=#{notice}"}, []]
-      end
-
-      def clear_route_tracking
-        if Coverband.configuration.web_enable_clear
-          tracker = Coverband::Collectors::RouteTracker.new(store: Coverband.configuration.store)
-          tracker.reset_recordings
-          notice = "route tracking reset"
-        else
-          notice = "web_enable_clear isn't enabled in your configuration"
-        end
-        [302, {"Location" => "#{base_path}/route_tracker?notice=#{notice}"}, []]
-      end
-
-      def clear_route_tracking_route
-        if Coverband.configuration.web_enable_clear
-          tracker = Coverband::Collectors::RouteTracker.new(store: Coverband.configuration.store)
-          route = request.params["route"]
-          tracker.clear_route!(route)
-          notice = "coverage for route #{route} cleared"
-        else
-          notice = "web_enable_clear isn't enabled in your configuration"
-        end
-        [302, {"Location" => "#{base_path}/route_tracker?notice=#{notice}"}, []]
-      end
-
-      def clear_translation_tracking
-        if Coverband.configuration.web_enable_clear
-          tracker = Coverband::Collectors::TranslationTracker.new(store: Coverband.configuration.store)
-          tracker.reset_recordings
-          notice = "translation tracking reset"
-        else
-          notice = "web_enable_clear isn't enabled in your configuration"
-        end
-        [302, {"Location" => "#{base_path}/translations_tracker?notice=#{notice}"}, []]
-      end
-
-      def clear_translation_tracking_key
-        if Coverband.configuration.web_enable_clear
-          tracker = Coverband::Collectors::TranslationTracker.new(store: Coverband.configuration.store)
           key = request.params["key"]
           tracker.clear_key!(key)
-          notice = "coverage for route #{key} cleared"
+          notice = "coverage for #{tracker.title} #{key} cleared"
         else
           notice = "web_enable_clear isn't enabled in your configuration"
         end
-        [302, {"Location" => "#{base_path}/translations_tracker?notice=#{notice}"}, []]
+        [302, {"Location" => "#{base_path}/#{tracker.route}?notice=#{notice}"}, []]
       end
 
       private
 
+      def coverband_headers(content_type: "text/html")
+        web_headers = {
+          "Content-Type" => content_type
+        }
+        web_headers["Content-Security-Policy-Report-Only"] = CSP_HEADER if Coverband.configuration.csp_policy
+        web_headers
+      end
+
       # This method should get the root mounted endpoint
       # for example if the app is mounted like so:
       # mount Coverband::Web, at: '/coverage'

data/lib/coverband/utils/html_formatter.rb

@@ -13,11 +13,12 @@ require "time"
 module Coverband
   module Utils
     class HTMLFormatter
-      attr_reader :notice, :base_path
+      attr_reader :notice, :base_path, :tracker
 
       def initialize(report, options = {})
         @notice = options.fetch(:notice, nil)
         @base_path = options.fetch(:base_path, "./")
+        @tracker = options.fetch(:tracker, nil)
         @coverage_result = Coverband::Utils::Results.new(report) if report
       end
 
@@ -33,16 +34,8 @@ module Coverband
         format_settings
       end
 
-      def format_view_tracker!
-        format_view_tracker
-      end
-
-      def format_route_tracker!
-        format_route_tracker
-      end
-
-      def format_translations_tracker!
-        format_translations_tracker
+      def format_abstract_tracker!
+        template("abstract_tracker").result(binding)
       end
 
       def format_source_file!(filename)
@@ -61,18 +54,6 @@ module Coverband
         template("settings").result(binding)
       end
 
-      def format_view_tracker
-        template("view_tracker").result(binding)
-      end
-
-      def format_route_tracker
-        template("route_tracker").result(binding)
-      end
-
-      def format_translations_tracker
-        template("translations_tracker").result(binding)
-      end
-
       def format(result)
         Dir[File.join(File.dirname(__FILE__), "../../../public/*")].each do |path|
           FileUtils.cp_r(path, asset_output_path)

data/lib/coverband/utils/railtie.rb

@@ -27,51 +27,7 @@ module Coverband
         Coverband.runtime_coverage!
       end
 
-      begin
-        if Coverband.configuration.track_routes
-          if Gem::Version.new(Rails.version) >= Gem::Version.new("6.0.0") && Gem::Version.new(Rails.version) < Gem::Version.new("7.1.0")
-            require_relative "rails6_ext"
-          end
-
-          Coverband.configuration.route_tracker = Coverband::Collectors::RouteTracker.new
-
-          ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
-            Coverband.configuration.route_tracker.track_routes(name, start, finish, id, payload)
-          end
-
-          # NOTE: This event was instrumented in Aug 10th 2022, but didn't make the 7.0.4 release and should be in the next release
-          # https://github.com/rails/rails/pull/43755
-          # Automatic tracking of redirects isn't avaible before Rails 7.1.0 (currently tested against the 7.1.0.alpha)
-          # We could consider back porting or patching a solution that works on previous Rails versions
-          ActiveSupport::Notifications.subscribe("redirect.action_dispatch") do |name, start, finish, id, payload|
-            Coverband.configuration.route_tracker.track_routes(name, start, finish, id, payload)
-          end
-        end
-
-        if Coverband.configuration.track_translations
-          Coverband.configuration.translations_tracker = Coverband::Collectors::TranslationTracker.new
-
-          # plugin to i18n
-          I18n::Backend::Simple.send :include, Coverband::Collectors::I18n::KeyRegistry
-        end
-
-        if Coverband.configuration.track_views
-          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_(template|partial|collection).action_view/) do |name, start, finish, id, payload|
-            COVERBAND_VIEW_TRACKER.track_views(name, start, finish, id, payload) unless name.include?("!")
-          end
-        end
-      rescue Redis::CannotConnectError => error
-        Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
-        Coverband.configuration.logger.info "If this is a setup task like assets:precompile feel free to ignore"
-      end
+      Coverband.configuration.railtie!
     end
 
     config.before_configuration do

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.2.6.rc.1"
+  VERSION = "5.2.6.rc.3"
 end

data/lib/coverband.rb

@@ -16,6 +16,7 @@ require "coverband/adapters/stdout_store"
 require "coverband/adapters/null_store"
 require "coverband/utils/file_hasher"
 require "coverband/collectors/coverage"
+require "coverband/collectors/abstract_tracker"
 require "coverband/collectors/view_tracker"
 require "coverband/collectors/view_tracker_service"
 require "coverband/collectors/route_tracker"