activesupport 5.2.7.1 → 6.1.4.6

data/lib/active_support/notifications/instrumenter.rb

@@ -13,14 +13,15 @@ module ActiveSupport
         @notifier = notifier
       end
 
-      # Instrument the given block by measuring the time taken to execute it
-      # and publish it. Notice that events get sent even if an error occurs
-      # in the passed-in block.
+      # Given a block, instrument it by measuring the time taken to execute
+      # and publish it. Without a block, simply send a message via the
+      # notifier. Notice that events get sent even if an error occurs in the
+      # passed-in block.
       def instrument(name, payload = {})
         # some of the listeners might have state
         listeners_state = start name, payload
         begin
-          yield payload
+          yield payload if block_given?
         rescue Exception => e
           payload[:exception] = [e.class.name, e.message]
           payload[:exception_object] = e
@@ -45,15 +46,14 @@ module ActiveSupport
       end
 
       private
-
         def unique_id
           SecureRandom.hex(10)
         end
     end
 
     class Event
-      attr_reader :name, :time, :transaction_id, :payload, :children
-      attr_accessor :end
+      attr_reader :name, :time, :end, :transaction_id, :children
+      attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
         @name           = name
@@ -62,7 +62,42 @@ module ActiveSupport
         @transaction_id = transaction_id
         @end            = ending
         @children       = []
-        @duration       = nil
+        @cpu_time_start = 0
+        @cpu_time_finish = 0
+        @allocation_count_start = 0
+        @allocation_count_finish = 0
+      end
+
+      # Record information at the time this event starts
+      def start!
+        @time = now
+        @cpu_time_start = now_cpu
+        @allocation_count_start = now_allocations
+      end
+
+      # Record information at the time this event finishes
+      def finish!
+        @cpu_time_finish = now_cpu
+        @end = now
+        @allocation_count_finish = now_allocations
+      end
+
+      # Returns the CPU time (in milliseconds) passed since the call to
+      # +start!+ and the call to +finish!+
+      def cpu_time
+        (@cpu_time_finish - @cpu_time_start) * 1000
+      end
+
+      # Returns the idle time time (in milliseconds) passed since the call to
+      # +start!+ and the call to +finish!+
+      def idle_time
+        duration - cpu_time
+      end
+
+      # Returns the number of allocations made since the call to +start!+ and
+      # the call to +finish!+
+      def allocations
+        @allocation_count_finish - @allocation_count_start
       end
 
       # Returns the difference in milliseconds between when the execution of the
@@ -78,7 +113,7 @@ module ActiveSupport
       #
       #   @event.duration # => 1000.138
       def duration
-        @duration ||= 1000.0 * (self.end - time)
+        1000.0 * (self.end - time)
       end
 
       def <<(event)
@@ -88,6 +123,33 @@ module ActiveSupport
       def parent_of?(event)
         @children.include? event
       end
+
+      private
+        def now
+          Concurrent.monotonic_time
+        end
+
+        begin
+          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
+
+          def now_cpu
+            Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
+          end
+        rescue
+          def now_cpu
+            0
+          end
+        end
+
+        if defined?(JRUBY_VERSION)
+          def now_allocations
+            0
+          end
+        else
+          def now_allocations
+            GC.stat :total_allocated_objects
+          end
+        end
     end
   end
 end

data/lib/active_support/notifications.rb

@@ -34,10 +34,23 @@ module ActiveSupport
   #     name    # => String, name of the event (such as 'render' from above)
   #     start   # => Time, when the instrumented block started execution
   #     finish  # => Time, when the instrumented block ended execution
-  #     id      # => String, unique ID for this notification
+  #     id      # => String, unique ID for the instrumenter that fired the event
   #     payload # => Hash, the payload
   #   end
   #
+  # Here, the +start+ and +finish+ values represent wall-clock time. If you are
+  # concerned about accuracy, you can register a monotonic subscriber.
+  #
+  #   ActiveSupport::Notifications.monotonic_subscribe('render') do |name, start, finish, id, payload|
+  #     name    # => String, name of the event (such as 'render' from above)
+  #     start   # => Monotonic time, when the instrumented block started execution
+  #     finish  # => Monotonic time, when the instrumented block ended execution
+  #     id      # => String, unique ID for the instrumenter that fired the event
+  #     payload # => Hash, the payload
+  #   end
+  #
+  # The +start+ and +finish+ values above represent monotonic time.
+  #
   # For instance, let's store all "render" events in an array:
   #
   #   events = []
@@ -59,7 +72,7 @@ module ActiveSupport
   #   event.payload   # => { extra: :information }
   #
   # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event
+  # timestamp, end timestamp, a string with a unique identifier for that event's instrumenter
   # (something like "535801666f04d0298cd6"), and a hash with the payload, in
   # that order.
   #
@@ -67,9 +80,12 @@ module ActiveSupport
   # have a key <tt>:exception</tt> with an array of two elements as value: a string with
   # the name of the exception class, and the exception message.
   # The <tt>:exception_object</tt> key of the payload will have the exception
-  # itself as the value.
+  # itself as the value:
   #
-  # As the previous example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
+  #   event.payload[:exception]         # => ["ArgumentError", "Invalid value"]
+  #   event.payload[:exception_object]  # => #<ArgumentError: Invalid value>
+  #
+  # As the earlier example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
   # is able to take the arguments as they come and provide an object-oriented
   # interface to that data.
   #
@@ -132,6 +148,16 @@ module ActiveSupport
   # during the execution of the block. The callback is unsubscribed automatically
   # after that.
   #
+  # To record +started+ and +finished+ values with monotonic time,
+  # specify the optional <tt>:monotonic</tt> option to the
+  # <tt>subscribed</tt> method. The <tt>:monotonic</tt> option is set
+  # to +false+ by default.
+  #
+  #   callback = lambda {|name, started, finished, unique_id, payload| ... }
+  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record", monotonic: true) do
+  #     ...
+  #   end
+  #
   # === Manual Unsubscription
   #
   # The +subscribe+ method returns a subscriber object:
@@ -150,6 +176,15 @@ module ActiveSupport
   #
   #   ActiveSupport::Notifications.unsubscribe("render")
   #
+  # Subscribers using a regexp or other pattern-matching object will remain subscribed
+  # to all events that match their original pattern, unless those events match a string
+  # passed to +unsubscribe+:
+  #
+  #   subscriber = ActiveSupport::Notifications.subscribe(/render/) { }
+  #   ActiveSupport::Notifications.unsubscribe('render_template.action_view')
+  #   subscriber.matches?('render_template.action_view') # => false
+  #   subscriber.matches?('render_partial.action_view') # => true
+  #
   # == Default Queue
   #
   # Notifications ships with a queue implementation that consumes and publishes events
@@ -171,12 +206,41 @@ module ActiveSupport
         end
       end
 
-      def subscribe(*args, &block)
-        notifier.subscribe(*args, &block)
+      # Subscribe to a given event name with the passed +block+.
+      #
+      # You can subscribe to events by passing a String to match exact event
+      # names, or by passing a Regexp to match all events that match a pattern.
+      #
+      #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
+      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   end
+      #
+      # The +block+ will receive five parameters with information about the event:
+      #
+      #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
+      #     name    # => String, name of the event (such as 'render' from above)
+      #     start   # => Time, when the instrumented block started execution
+      #     finish  # => Time, when the instrumented block ended execution
+      #     id      # => String, unique ID for the instrumenter that fired the event
+      #     payload # => Hash, the payload
+      #   end
+      #
+      # If the block passed to the method only takes one parameter,
+      # it will yield an event object to the block:
+      #
+      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
+      #     @event = event
+      #   end
+      def subscribe(pattern = nil, callback = nil, &block)
+        notifier.subscribe(pattern, callback, monotonic: false, &block)
+      end
+
+      def monotonic_subscribe(pattern = nil, callback = nil, &block)
+        notifier.subscribe(pattern, callback, monotonic: true, &block)
       end
 
-      def subscribed(callback, *args, &block)
-        subscriber = subscribe(*args, &callback)
+      def subscribed(callback, pattern = nil, monotonic: false, &block)
+        subscriber = notifier.subscribe(pattern, callback, monotonic: monotonic)
         yield
       ensure
         unsubscribe(subscriber)

data/lib/active_support/number_helper/number_converter.rb

@@ -30,7 +30,7 @@ module ActiveSupport
           # If set to true, precision will mean the number of significant digits instead
           # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
           significant: false,
-          # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
+          # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
           strip_insignificant_zeros: false
         },
 
@@ -136,7 +136,6 @@ module ActiveSupport
       end
 
       private
-
         def options
           @options ||= format_options.merge(opts)
         end
@@ -162,12 +161,12 @@ module ActiveSupport
           options
         end
 
-        def translate_number_value_with_default(key, i18n_options = {})
-          I18n.translate(key, { default: default_value(key), scope: :number }.merge!(i18n_options))
+        def translate_number_value_with_default(key, **i18n_options)
+          I18n.translate(key, **{ default: default_value(key), scope: :number }.merge!(i18n_options))
         end
 
-        def translate_in_locale(key, i18n_options = {})
-          translate_number_value_with_default(key, { locale: options[:locale] }.merge(i18n_options))
+        def translate_in_locale(key, **i18n_options)
+          translate_number_value_with_default(key, **{ locale: options[:locale] }.merge(i18n_options))
         end
 
         def default_value(key)

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/numeric/inquiry"
+require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
@@ -11,21 +11,16 @@ module ActiveSupport
         number = self.number.to_s.strip
         format = options[:format]
 
-        if number.to_f.negative?
+        if number.sub!(/^-/, "") &&
+           (options[:precision] != 0 || number.to_f > 0.5)
           format = options[:negative_format]
-          number = absolute_value(number)
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
+        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
       end
 
       private
-
-        def absolute_value(number)
-          number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "")
-        end
-
         def options
           @options ||= begin
             defaults = default_format_options.merge(i18n_opts)

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToDelimitedConverter < NumberConverter #:nodoc:
@@ -12,9 +14,8 @@ module ActiveSupport
       end
 
       private
-
         def parts
-          left, right = number.to_s.split(".".freeze)
+          left, right = number.to_s.split(".")
           left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end

data/lib/active_support/number_helper/number_to_human_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanConverter < NumberConverter # :nodoc:
@@ -14,7 +16,7 @@ module ActiveSupport
         @number = RoundingHelper.new(options).round(number)
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end
@@ -25,11 +27,10 @@ module ActiveSupport
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
         unit = determine_unit(units, exponent)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, unit).strip
+        format.gsub("%n", rounded_number).gsub("%u", unit).strip
       end
 
       private
-
         def format
           options[:format] || translate_in_locale("human.decimal_units.format")
         end

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanSizeConverter < NumberConverter #:nodoc:
@@ -11,7 +13,7 @@ module ActiveSupport
       def convert
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end
@@ -22,11 +24,10 @@ module ActiveSupport
           human_size = number / (base**exponent)
           number_to_format = NumberToRoundedConverter.convert(human_size, options)
         end
-        conversion_format.gsub("%n".freeze, number_to_format).gsub("%u".freeze, unit)
+        conversion_format.gsub("%n", number_to_format).gsub("%u", unit)
       end
 
       private
-
         def conversion_format
           translate_number_value_with_default("human.storage_units.format", locale: options[:locale], raise: true)
         end

data/lib/active_support/number_helper/number_to_percentage_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPercentageConverter < NumberConverter # :nodoc:
@@ -7,7 +9,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub("%n".freeze, rounded_number)
+        options[:format].gsub("%n", rounded_number)
       end
     end
   end

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPhoneConverter < NumberConverter #:nodoc:
@@ -10,7 +12,6 @@ module ActiveSupport
       end
 
       private
-
         def convert_to_phone_number(number)
           if opts[:area_code]
             convert_with_area_code(number)

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToRoundedConverter < NumberConverter # :nodoc:
@@ -18,14 +20,18 @@ module ActiveSupport
           end
 
           formatted_string =
-            if BigDecimal === rounded_number && rounded_number.finite?
+            if rounded_number.finite?
               s = rounded_number.to_s("F")
-              s << "0".freeze * precision
-              a, b = s.split(".".freeze, 2)
-              a << ".".freeze
-              a << b[0, precision]
+              a, b = s.split(".", 2)
+              if precision != 0
+                b << "0" * precision
+                a << "."
+                a << b[0, precision]
+              end
+              a
             else
-              "%00.#{precision}f" % rounded_number
+              # Infinity/NaN
+              "%f" % rounded_number
             end
         else
           formatted_string = rounded_number
@@ -36,7 +42,6 @@ module ActiveSupport
       end
 
       private
-
         def strip_insignificant_zeros
           options[:strip_insignificant_zeros]
         end

data/lib/active_support/number_helper/rounding_helper.rb

@@ -10,57 +10,41 @@ module ActiveSupport
       end
 
       def round(number)
+        precision = absolute_precision(number)
         return number unless precision
-        number = convert_to_decimal(number)
-        if significant && precision > 0
-          round_significant(number)
-        else
-          round_without_significant(number)
-        end
+
+        rounded_number = convert_to_decimal(number).round(precision, options.fetch(:round_mode, :default).to_sym)
+        rounded_number.zero? ? rounded_number.abs : rounded_number # prevent showing negative zeros
       end
 
       def digit_count(number)
         return 1 if number.zero?
-        (Math.log10(absolute_number(number)) + 1).floor
+        (Math.log10(number.abs) + 1).floor
       end
 
       private
-        def round_without_significant(number)
-          number = number.round(precision)
-          number = number.to_i if precision == 0 && number.finite?
-          number = number.abs if number.zero? # prevent showing negative zeros
-          number
-        end
-
-        def round_significant(number)
-          return 0 if number.zero?
-          digits = digit_count(number)
-          multiplier = 10**(digits - precision)
-          (number / BigDecimal(multiplier.to_f.to_s)).round * multiplier
-        end
-
         def convert_to_decimal(number)
           case number
           when Float, String
             BigDecimal(number.to_s)
           when Rational
-            BigDecimal(number, digit_count(number.to_i) + precision)
+            BigDecimal(number, digit_count(number.to_i) + options[:precision])
           else
             number.to_d
           end
         end
 
-        def precision
-          options[:precision]
+        def absolute_precision(number)
+          if significant && options[:precision] > 0
+            options[:precision] - digit_count(convert_to_decimal(number))
+          else
+            options[:precision]
+          end
         end
 
         def significant
           options[:significant]
         end
-
-        def absolute_number(number)
-          number.respond_to?(:abs) ? number.abs : number.to_d.abs
-        end
     end
   end
 end