coverband 5.2.5 → 5.2.6.rc.2

data/lib/coverband/at_exit.rb

@@ -22,7 +22,8 @@ module Coverband
             Coverband.report_coverage
             # to ensure we track mailer views we now need to report views tracking
             # at exit as well for rake tasks and background tasks that can trigger email
-            Coverband.configuration.view_tracker&.report_views_tracked
+            Coverband.configuration.view_tracker&.save_report
+            Coverband.configuration.translations_tracker&.save_report
           end
         end
       end

data/lib/coverband/collectors/abstract_tracker.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "set"
+require "singleton"
+
+module Coverband
+  module Collectors
+    ###
+    # This abstract class makes it easy to track any used/unused with timestamp set of usage
+    ###
+    class AbstractTracker
+      REPORT_ROUTE = "/"
+      TITLE = "abstract"
+
+      attr_accessor :target
+      attr_reader :logger, :store, :ignore_patterns
+
+      def initialize(options = {})
+        raise NotImplementedError, "#{self.class.name} requires a newer version of Rails" unless self.class.supported_version?
+        raise "Coverband: #{self.class.name} initialized before configuration!" if !Coverband.configured? && ENV["COVERBAND_TEST"] == "test"
+
+        @ignore_patterns = Coverband.configuration.ignore
+        @store = options.fetch(:store) { Coverband.configuration.store }
+        @logger = options.fetch(:logger) { Coverband.configuration.logger }
+        @target = options.fetch(:target) do
+          concrete_target
+        end
+
+        @one_time_timestamp = false
+
+        @logged_keys = Set.new
+        @keys_to_record = Set.new
+      end
+
+      def logged_keys
+        @logged_keys.to_a
+      end
+
+      def keys_to_record
+        @keys_to_record.to_a
+      end
+
+      ###
+      # This method is called on every translation usage
+      ###
+      def track_key(key)
+        if key
+          if newly_seen_key?(key)
+            @logged_keys << key
+            @keys_to_record << key if track_key?(key)
+          end
+        end
+      end
+
+      def used_keys
+        redis_store.hgetall(tracker_key)
+      end
+
+      def all_keys
+        target.uniq
+      end
+
+      def unused_keys(used_keys = nil)
+        recently_used_keys = (used_keys || self.used_keys).keys
+        all_keys.reject { |k| recently_used_keys.include?(k.to_s) }
+      end
+
+      def as_json
+        used_keys = self.used_keys
+        {
+          unused_keys: unused_keys(used_keys),
+          used_keys: used_keys
+        }.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_key!(key)
+        return unless key
+        puts "#{tracker_key} key #{key}"
+        redis_store.hdel(tracker_key, key)
+        @logged_keys.delete(key)
+      end
+
+      def save_report
+        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
+        @keys_to_record.to_a.each do |key|
+          redis_store.hset(tracker_key, key.to_s, reported_time)
+        end
+        @keys_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: #{self.class.name} failed to store, error #{e.class.name} info #{e.message}"
+      end
+
+      # This is the basic rails version supported, if there is something more unique over ride in subclass
+      def self.supported_version?
+        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 5
+      end
+
+      def route
+        self.class::REPORT_ROUTE
+      end
+
+      def title
+        self.class::TITLE
+      end
+
+      protected
+
+      def newly_seen_key?(key)
+        !@logged_keys.include?(key)
+      end
+
+      def track_key?(key, options = {})
+        @ignore_patterns.none? { |pattern| key.to_s.include?(pattern) }
+      end
+
+      private
+
+      def concrete_target
+        raise "subclass must implement"
+      end
+
+      def redis_store
+        store.raw_store
+      end
+
+      def tracker_time_key_exists?
+        if defined?(redis_store.exists?)
+          redis_store.exists?(tracker_time_key)
+        else
+          redis_store.exists(tracker_time_key)
+        end
+      end
+
+      def tracker_key
+        "#{class_key}_tracker"
+      end
+
+      def tracker_time_key
+        "#{class_key}_tracker_time"
+      end
+
+      def class_key
+        @class_key ||= self.class.name.split("::").last
+      end
+    end
+  end
+end

data/lib/coverband/collectors/route_tracker.rb

@@ -8,51 +8,23 @@ module Coverband
     ###
     # This class tracks route usage via ActiveSupport::Notifications
     ###
-    class RouteTracker
-      attr_accessor :target
-      attr_reader :logger, :store, :ignore_patterns
+    class RouteTracker < AbstractTracker
+      REPORT_ROUTE = "routes_tracker"
+      TITLE = "Routes"
 
       def initialize(options = {})
-        raise NotImplementedError, "Route Tracker requires Rails 4 or greater" unless self.class.supported_version?
-        raise "Coverband: route tracker initialized before configuration!" if !Coverband.configured? && ENV["COVERBAND_TEST"] == "test"
-
-        @ignore_patterns = Coverband.configuration.ignore
-        @store = options.fetch(:store) { Coverband.configuration.store }
-        @logger = options.fetch(:logger) { Coverband.configuration.logger }
-        @target = options.fetch(:target) do
-          if defined?(Rails.application)
-            Rails.application.routes.routes.map do |route|
-              {
-                controller: route.defaults[:controller],
-                action: route.defaults[:action],
-                url_path: route.path.spec.to_s.gsub("(.:format)", ""),
-                verb: route.verb
-              }
-            end
-          else
-            []
-          end
+        if Rails&.respond_to?(:version) && Gem::Version.new(Rails.version) >= Gem::Version.new("6.0.0") && Gem::Version.new(Rails.version) < Gem::Version.new("7.1.0")
+          require_relative "../utils/rails6_ext"
         end
 
-        @one_time_timestamp = false
-
-        @logged_routes = Set.new
-        @routes_to_record = Set.new
-      end
-
-      def logged_routes
-        @logged_routes.to_a
-      end
-
-      def routes_to_record
-        @routes_to_record.to_a
+        super
       end
 
       ###
       # This method is called on every routing call, so we try to reduce method calls
       # and ensure high performance
       ###
-      def track_routes(_name, _start, _finish, _id, payload)
+      def track_key(payload)
         route = if payload[:request]
           {
             controller: nil,
@@ -69,104 +41,53 @@ module Coverband
           }
         end
         if route
-          if newly_seen_route?(route)
-            @logged_routes << route
-            @routes_to_record << route if track_route?(route)
+          if newly_seen_key?(route)
+            @logged_keys << route
+            @keys_to_record << route if track_key?(route)
           end
         end
       end
 
-      def used_routes
-        redis_store.hgetall(tracker_key)
-      end
-
-      def all_routes
-        target.uniq
+      def self.supported_version?
+        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 6
       end
 
-      def unused_routes(used_routes = nil)
-        recently_used_routes = (used_routes || self.used_routes).keys
+      def unused_keys(used_keys = nil)
+        recently_used_routes = (used_keys || self.used_keys).keys
         # NOTE: we match with or without path to handle paths with named params like `/user/:user_id` to used routes filling with all the variable named paths
-        all_routes.reject { |r| recently_used_routes.include?(r.to_s) || recently_used_routes.include?(r.merge(url_path: nil).to_s) }
-      end
-
-      def as_json
-        used_routes = self.used_routes
-        {
-          unused_routes: unused_routes(used_routes),
-          used_routes: used_routes
-        }.to_json
+        all_keys.reject { |r| recently_used_routes.include?(r.to_s) || recently_used_routes.include?(r.merge(url_path: nil).to_s) }
       end
 
-      def tracking_since
-        if (tracking_time = redis_store.get(tracker_time_key))
-          Time.at(tracking_time.to_i).iso8601
-        else
-          "N/A"
+      def railtie!
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
+          Coverband.configuration.route_tracker.track_key(payload)
         end
-      end
-
-      def reset_recordings
-        redis_store.del(tracker_key)
-        redis_store.del(tracker_time_key)
-      end
-
-      def clear_route!(route)
-        return unless route
 
-        redis_store.hdel(tracker_key, route)
-        @logged_routes.delete(route)
-      end
-
-      def report_routes_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
-        @routes_to_record.to_a.each do |route|
-          redis_store.hset(tracker_key, route.to_s, reported_time)
+        # 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_key(payload)
         end
-        @routes_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: route_tracker failed to store, error #{e.class.name} info #{e.message}"
-      end
-
-      def self.supported_version?
-        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 4
-      end
-
-      protected
-
-      def newly_seen_route?(route)
-        !@logged_routes.include?(route)
-      end
-
-      def track_route?(route, options = {})
-        @ignore_patterns.none? { |pattern| route.to_s.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)
+          Rails.application.routes.routes.map do |route|
+            {
+              controller: route.defaults[:controller],
+              action: route.defaults[:action],
+              url_path: route.path.spec.to_s.gsub("(.:format)", ""),
+              verb: route.verb
+            }
+          end
         else
-          redis_store.exists(tracker_time_key)
+          []
         end
       end
-
-      def tracker_key
-        "route_tracker_2"
-      end
-
-      def tracker_time_key
-        "route_tracker_time"
-      end
     end
   end
 end

data/lib/coverband/collectors/translation_tracker.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "set"
+require "singleton"
+
+module Coverband
+  module Collectors
+    module I18n
+      module KeyRegistry
+        def lookup(locale, key, scope = [], options = {})
+          separator = options[:separator] || ::I18n.default_separator
+          flat_key = ::I18n.normalize_keys(locale, key, scope, separator).join(separator)
+          Coverband.configuration.translations_tracker.track_key(flat_key)
+
+          super
+        end
+      end
+    end
+
+    ###
+    # This class tracks translation usage via I18n::Backend
+    ###
+    class TranslationTracker < AbstractTracker
+      REPORT_ROUTE = "translations_tracker"
+      TITLE = "Translations"
+
+      def railtie!
+        # plugin to i18n
+        ::I18n::Backend::Simple.send :include, ::Coverband::Collectors::I18n::KeyRegistry
+      end
+
+      private
+
+      def concrete_target
+        if defined?(Rails.application)
+          app_translation_keys = []
+          app_translation_files = ::I18n.load_path.select { |f| f.match(/config\/locales/) }
+          app_translation_files.each do |file|
+            app_translation_keys += flatten_hash(YAML.load_file(file)).keys
+          end
+          app_translation_keys.uniq
+        else
+          []
+        end
+      end
+
+      def flatten_hash(hash)
+        hash.each_with_object({}) do |(k, v), h|
+          if v.is_a? Hash
+            flatten_hash(v).map do |h_k, h_v|
+              h["#{k}.#{h_k}".to_sym] = h_v
+            end
+          else
+            h[k] = v
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,9 @@ module Coverband
       :test_env, :web_enable_clear, :gem_details, :web_debug, :report_on_exit,
       :simulate_oneshot_lines_coverage,
       :view_tracker, :defer_eager_loading_data,
-      :track_routes, :route_tracker
+      :track_routes, :route_tracker,
+      :track_translations, :translations_tracker,
+      :trackers
     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,
@@ -70,6 +72,8 @@ module Coverband
       @view_tracker = nil
       @track_routes = false
       @route_tracker = nil
+      @track_translations = false
+      @translations_tracker = nil
       @web_debug = false
       @report_on_exit = true
       @use_oneshot_lines_coverage = ENV["ONESHOT"] || false
@@ -92,6 +96,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
@@ -101,6 +107,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