activesupport 6.0.6.1 → 7.1.3.2

data/lib/active_support/error_reporter.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support \Error Reporter
+  #
+  # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
+  #
+  # To rescue and report any unhandled error, you can use the #handle method:
+  #
+  #   Rails.error.handle do
+  #     do_something!
+  #   end
+  #
+  # If an error is raised, it will be reported and swallowed.
+  #
+  # Alternatively, if you want to report the error but not swallow it, you can use #record:
+  #
+  #   Rails.error.record do
+  #     do_something!
+  #   end
+  #
+  # Both methods can be restricted to handle only a specific error class:
+  #
+  #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+  #
+  class ErrorReporter
+    SEVERITIES = %i(error warning info)
+    DEFAULT_SOURCE = "application"
+
+    attr_accessor :logger
+
+    def initialize(*subscribers, logger: nil)
+      @subscribers = subscribers.flatten
+      @logger = logger
+    end
+
+    # Evaluates the given block, reporting and swallowing any unhandled error.
+    # If no error is raised, returns the return value of the block. Otherwise,
+    # returns the result of +fallback.call+, or +nil+ if +fallback+ is not
+    # specified.
+    #
+    #   # Will report a TypeError to all subscribers and return nil.
+    #   Rails.error.handle do
+    #     1 + '1'
+    #   end
+    #
+    # Can be restricted to handle only specific error classes:
+    #
+    #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:warning+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.handle(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:fallback+ - A callable that provides +handle+'s return value when an
+    #   unhandled error is raised. For example:
+    #
+    #     user = Rails.error.handle(fallback: -> { User.anonymous }) do
+    #       User.find_by(params)
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)
+      error_classes = [StandardError] if error_classes.blank?
+      yield
+    rescue *error_classes => error
+      report(error, handled: true, severity: severity, context: context, source: source)
+      fallback.call if fallback
+    end
+
+    # Evaluates the given block, reporting and re-raising any unhandled error.
+    # If no error is raised, returns the return value of the block.
+    #
+    #   # Will report a TypeError to all subscribers and re-raise it.
+    #   Rails.error.record do
+    #     1 + '1'
+    #   end
+    #
+    # Can be restricted to handle only specific error classes:
+    #
+    #   tags = Rails.error.record(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:error+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.record(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)
+      error_classes = [StandardError] if error_classes.blank?
+      yield
+    rescue *error_classes => error
+      report(error, handled: false, severity: severity, context: context, source: source)
+      raise
+    end
+
+    # Register a new error subscriber. The subscriber must respond to
+    #
+    #   report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)
+    #
+    # The +report+ method <b>should never</b> raise an error.
+    def subscribe(subscriber)
+      unless subscriber.respond_to?(:report)
+        raise ArgumentError, "Error subscribers must respond to #report"
+      end
+      @subscribers << subscriber
+    end
+
+    # Unregister an error subscriber. Accepts either a subscriber or a class.
+    #
+    #   subscriber = MyErrorSubscriber.new
+    #   Rails.error.subscribe(subscriber)
+    #
+    #   Rails.error.unsubscribe(subscriber)
+    #   # or
+    #   Rails.error.unsubscribe(MyErrorSubscriber)
+    def unsubscribe(subscriber)
+      @subscribers.delete_if { |s| subscriber === s }
+    end
+
+    # Prevent a subscriber from being notified of errors for the
+    # duration of the block. You may pass in the subscriber itself, or its class.
+    #
+    # This can be helpful for error reporting service integrations, when they wish
+    # to handle any errors higher in the stack.
+    def disable(subscriber)
+      disabled_subscribers = (ActiveSupport::IsolatedExecutionState[self] ||= [])
+      disabled_subscribers << subscriber
+      begin
+        yield
+      ensure
+        disabled_subscribers.delete(subscriber)
+      end
+    end
+
+    # Update the execution context that is accessible to error subscribers. Any
+    # context passed to #handle, #record, or #report will be merged with the
+    # context set here.
+    #
+    #   Rails.error.set_context(section: "checkout", user_id: @user.id)
+    #
+    def set_context(...)
+      ActiveSupport::ExecutionContext.set(...)
+    end
+
+    # Report an error directly to subscribers. You can use this method when the
+    # block-based #handle and #record methods are not suitable.
+    #
+    #   Rails.error.report(error)
+    #
+    def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
+      return if error.instance_variable_defined?(:@__rails_error_reported)
+
+      unless SEVERITIES.include?(severity)
+        raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
+      end
+
+      full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
+      disabled_subscribers = ActiveSupport::IsolatedExecutionState[self]
+      @subscribers.each do |subscriber|
+        unless disabled_subscribers&.any? { |s| s === subscriber }
+          subscriber.report(error, handled: handled, severity: severity, context: full_context, source: source)
+        end
+      rescue => subscriber_error
+        if logger
+          logger.fatal(
+            "Error subscriber raised an error: #{subscriber_error.message} (#{subscriber_error.class})\n" +
+            subscriber_error.backtrace.join("\n")
+          )
+        else
+          raise
+        end
+      end
+
+      unless error.frozen?
+        error.instance_variable_set(:@__rails_error_reported, true)
+      end
+
+      nil
+    end
+  end
+end

data/lib/active_support/evented_file_update_checker.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+gem "listen", "~> 3.5"
+require "listen"
+
 require "set"
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
+require "active_support/fork_tracker"
 
 module ActiveSupport
   # Allows you to "listen" to changes in a file system.
-  # The evented file updater does not hit disk when checking for updates
-  # instead it uses platform specific file system events to trigger a change
+  # The evented file updater does not hit disk when checking for updates.
+  # Instead, it uses platform-specific file system events to trigger a change
   # in state.
   #
   # The file checker takes an array of files to watch or a hash specifying directories
@@ -15,8 +19,6 @@ module ActiveSupport
   # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
   # is run and there have been changes to the file system.
   #
-  # Note: Forking will cause the first call to `updated?` to return `true`.
-  #
   # Example:
   #
   #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
@@ -32,68 +34,32 @@ module ActiveSupport
   #     checker.execute_if_updated
   #     # => "changed"
   #
-  class EventedFileUpdateChecker #:nodoc: all
+  class EventedFileUpdateChecker # :nodoc: all
     def initialize(files, dirs = {}, &block)
       unless block
         raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
       end
 
-      @ph    = PathHelper.new
-      @files = files.map { |f| @ph.xpath(f) }.to_set
-
-      @dirs = {}
-      dirs.each do |dir, exts|
-        @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
-      end
+      @block = block
+      @core = Core.new(files, dirs)
+      ObjectSpace.define_finalizer(self, @core.finalizer)
+    end
 
-      @block      = block
-      @updated    = Concurrent::AtomicBoolean.new(false)
-      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
-      @pid        = Process.pid
-      @boot_mutex = Mutex.new
-
-      dtw = directories_to_watch
-      @dtw, @missing = dtw.partition(&:exist?)
-
-      if @dtw.any?
-        # Loading listen triggers warnings. These are originated by a legit
-        # usage of attr_* macros for private attributes, but adds a lot of noise
-        # to our test suite. Thus, we lazy load it and disable warnings locally.
-        silence_warnings do
-          require "listen"
-        rescue LoadError => e
-          raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
-        end
-      end
-      boot!
+    def inspect
+      "#<ActiveSupport::EventedFileUpdateChecker:#{object_id} @files=#{@core.files.to_a.inspect}"
     end
 
     def updated?
-      @boot_mutex.synchronize do
-        if @pid != Process.pid
-          boot!
-          @pid = Process.pid
-          @updated.make_true
-        end
+      if @core.restart?
+        @core.thread_safely(&:restart)
+        @core.updated.make_true
       end
 
-      if @missing.any?(&:exist?)
-        @boot_mutex.synchronize do
-          appeared, @missing = @missing.partition(&:exist?)
-          shutdown!
-
-          @dtw += appeared
-          boot!
-
-          @updated.make_true
-        end
-      end
-
-      @updated.true?
+      @core.updated.true?
     end
 
     def execute
-      @updated.make_false
+      @core.updated.make_false
       @block.call
     end
 
@@ -105,17 +71,68 @@ module ActiveSupport
       end
     end
 
-    private
-      def boot!
-        normalize_dirs!
+    class Core
+      attr_reader :updated, :files
+
+      def initialize(files, dirs)
+        @files = files.map { |file| Pathname(file).expand_path }.to_set
 
-        unless @dtw.empty?
-          Listen.to(*@dtw, &method(:changed)).start
+        @dirs = dirs.each_with_object({}) do |(dir, exts), hash|
+          hash[Pathname(dir).expand_path] = Array(exts).map { |ext| ext.to_s.sub(/\A\.?/, ".") }.to_set
         end
+
+        @common_path = common_path(@dirs.keys)
+
+        @dtw = directories_to_watch
+        @missing = []
+
+        @updated = Concurrent::AtomicBoolean.new(false)
+        @mutex = Mutex.new
+
+        start
+        # inotify / FSEvents file descriptors are inherited on fork, so
+        # we need to reopen them otherwise only the parent or the child
+        # will be notified.
+        # FIXME: this callback is keeping a reference on the instance
+        @after_fork = ActiveSupport::ForkTracker.after_fork { start }
+      end
+
+      def finalizer
+        proc do
+          stop
+          ActiveSupport::ForkTracker.unregister(@after_fork)
+        end
+      end
+
+      def thread_safely
+        @mutex.synchronize do
+          yield self
+        end
+      end
+
+      def start
+        normalize_dirs!
+        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
+        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
+        @listener&.start
+
+        # Wait for the listener to be ready to avoid race conditions
+        # Unfortunately this isn't quite enough on macOS because the Darwin backend
+        # has an extra private thread we can't wait on.
+        @listener&.wait_for_state(:processing_events)
+      end
+
+      def stop
+        @listener&.stop
+      end
+
+      def restart
+        stop
+        start
       end
 
-      def shutdown!
-        Listen.stop
+      def restart?
+        @missing.any?(&:exist?)
       end
 
       def normalize_dirs!
@@ -125,27 +142,27 @@ module ActiveSupport
       end
 
       def changed(modified, added, removed)
-        unless updated?
+        unless @updated.true?
           @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
         end
       end
 
       def watching?(file)
-        file = @ph.xpath(file)
+        file = Pathname(file)
 
         if @files.member?(file)
           true
         elsif file.directory?
           false
         else
-          ext = @ph.normalize_extension(file.extname)
+          ext = file.extname
 
           file.dirname.ascend do |dir|
             matching = @dirs[dir]
 
             if matching && (matching.empty? || matching.include?(ext))
               break true
-            elsif dir == @lcsp || dir.root?
+            elsif dir == @common_path || dir.root?
               break false
             end
           end
@@ -153,82 +170,14 @@ module ActiveSupport
       end
 
       def directories_to_watch
-        dtw = @files.map(&:dirname) + @dirs.keys
-        dtw.compact!
-        dtw.uniq!
-
-        normalized_gem_paths = Gem.path.map { |path| File.join path, "" }
-        dtw = dtw.reject do |path|
-          normalized_gem_paths.any? { |gem_path| path.to_s.start_with?(gem_path) }
-        end
-
-        @ph.filter_out_descendants(dtw)
+        dtw = @dirs.keys | @files.map(&:dirname)
+        accounted_for = dtw.to_set + Gem.path.map { |path| Pathname(path) }
+        dtw.reject { |dir| dir.ascend.drop(1).any? { |parent| accounted_for.include?(parent) } }
       end
 
-      class PathHelper
-        def xpath(path)
-          Pathname.new(path).expand_path
-        end
-
-        def normalize_extension(ext)
-          ext.to_s.sub(/\A\./, "")
-        end
-
-        # Given a collection of Pathname objects returns the longest subpath
-        # common to all of them, or +nil+ if there is none.
-        def longest_common_subpath(paths)
-          return if paths.empty?
-
-          lcsp = Pathname.new(paths[0])
-
-          paths[1..-1].each do |path|
-            until ascendant_of?(lcsp, path)
-              if lcsp.root?
-                # If we get here a root directory is not an ascendant of path.
-                # This may happen if there are paths in different drives on
-                # Windows.
-                return
-              else
-                lcsp = lcsp.parent
-              end
-            end
-          end
-
-          lcsp
-        end
-
-        # Returns the deepest existing ascendant, which could be the argument itself.
-        def existing_parent(dir)
-          dir.ascend do |ascendant|
-            break ascendant if ascendant.directory?
-          end
-        end
-
-        # Filters out directories which are descendants of others in the collection (stable).
-        def filter_out_descendants(dirs)
-          return dirs if dirs.length < 2
-
-          dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
-          descendants = []
-
-          until dirs_sorted_by_nparts.empty?
-            dir = dirs_sorted_by_nparts.shift
-
-            dirs_sorted_by_nparts.reject! do |possible_descendant|
-              ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
-            end
-          end
-
-          # Array#- preserves order.
-          dirs - descendants
-        end
-
-        private
-          def ascendant_of?(base, other)
-            base != other && other.ascend do |ascendant|
-              break true if base == ascendant
-            end
-          end
+      def common_path(paths)
+        paths.map { |path| path.ascend.to_a }.reduce(&:&)&.first
       end
+    end
   end
 end

data/lib/active_support/execution_context/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ExecutionContext::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::ExecutionContext.clear
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::ExecutionContext.clear
+  end
+end

data/lib/active_support/execution_context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ExecutionContext # :nodoc:
+    @after_change_callbacks = []
+    class << self
+      def after_change(&block)
+        @after_change_callbacks << block
+      end
+
+      # Updates the execution context. If a block is given, it resets the provided keys to their
+      # previous value once the block exits.
+      def set(**options)
+        options.symbolize_keys!
+        keys = options.keys
+
+        store = self.store
+
+        previous_context = keys.zip(store.values_at(*keys)).to_h
+
+        store.merge!(options)
+        @after_change_callbacks.each(&:call)
+
+        if block_given?
+          begin
+            yield
+          ensure
+            store.merge!(previous_context)
+            @after_change_callbacks.each(&:call)
+          end
+        end
+      end
+
+      def []=(key, value)
+        store[key.to_sym] = value
+        @after_change_callbacks.each(&:call)
+      end
+
+      def to_h
+        store.dup
+      end
+
+      def clear
+        store.clear
+      end
+
+      private
+        def store
+          IsolatedExecutionState[:active_support_execution_context] ||= {}
+        end
+    end
+  end
+end

data/lib/active_support/execution_wrapper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/error_reporter"
 require "active_support/callbacks"
 require "concurrent/hash"
 
@@ -65,7 +66,7 @@ module ActiveSupport
     # Where possible, prefer +wrap+.
     def self.run!(reset: false)
       if reset
-        lost_instance = active.delete(Thread.current)
+        lost_instance = IsolatedExecutionState.delete(active_key)
         lost_instance&.complete!
       else
         return Null if active?
@@ -83,34 +84,48 @@ module ActiveSupport
     end
 
     # Perform the work in the supplied block as an execution.
-    def self.wrap
+    def self.wrap(source: "application.active_support")
       return yield if active?
 
       instance = run!
       begin
         yield
+      rescue => error
+        error_reporter&.report(error, handled: false, source: source)
+        raise
       ensure
         instance.complete!
       end
     end
 
-    class << self # :nodoc:
-      attr_accessor :active
+    def self.perform # :nodoc:
+      instance = new
+      instance.run
+      begin
+        yield
+      ensure
+        instance.complete
+      end
     end
 
-    def self.inherited(other) # :nodoc:
-      super
-      other.active = Concurrent::Hash.new
+    def self.error_reporter # :nodoc:
+      ActiveSupport.error_reporter
     end
 
-    self.active = Concurrent::Hash.new
+    def self.active_key # :nodoc:
+      @active_key ||= :"active_execution_wrapper_#{object_id}"
+    end
 
     def self.active? # :nodoc:
-      @active.key?(Thread.current)
+      IsolatedExecutionState.key?(active_key)
     end
 
     def run! # :nodoc:
-      self.class.active[Thread.current] = self
+      IsolatedExecutionState[self.class.active_key] = self
+      run
+    end
+
+    def run # :nodoc:
       run_callbacks(:run)
     end
 
@@ -119,9 +134,13 @@ module ActiveSupport
     #
     # Where possible, prefer +wrap+.
     def complete!
-      run_callbacks(:complete)
+      complete
     ensure
-      self.class.active.delete Thread.current
+      IsolatedExecutionState.delete(self.class.active_key)
+    end
+
+    def complete # :nodoc:
+      run_callbacks(:complete)
     end
 
     private

data/lib/active_support/executor/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Executor::TestHelper # :nodoc:
+  def run(...)
+    Rails.application.executor.perform { super }
+  end
+end

data/lib/active_support/file_update_checker.rb

@@ -3,7 +3,9 @@
 require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
-  # FileUpdateChecker specifies the API used by Rails to watch files
+  # = \File Update Checker
+  #
+  # FileUpdateChecker specifies the API used by \Rails to watch files
   # and control reloading. The API depends on four methods:
   #
   # * +initialize+ which expects two parameters and one block as
@@ -20,7 +22,7 @@ module ActiveSupport
   # After initialization, a call to +execute_if_updated+ must execute
   # the block only if there was really a change in the filesystem.
   #
-  # This class is used by Rails to reload the I18n framework whenever
+  # This class is used by \Rails to reload the I18n framework whenever
   # they are changed upon a new request.
   #
   #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do