rack-mini-profiler 1.0.1 → 2.3.2

data/lib/mini_profiler/timer_struct/custom.rb

@@ -6,6 +6,7 @@ module Rack
       # Timing system for a custom timers such as cache, redis, RPC, external API
       # calls, etc.
       class Custom < TimerStruct::Base
+        attr_accessor :parent
         def initialize(type, duration_ms, page, parent)
           @parent      = parent
           @page        = page

data/lib/mini_profiler/timer_struct/page.rb

@@ -10,6 +10,53 @@ module Rack
       #     :has_many TimerStruct::Sql children
       #     :has_many TimerStruct::Custom children
       class Page < TimerStruct::Base
+        class << self
+          def from_hash(hash)
+            hash = symbolize_hash(hash)
+            if hash.key?(:custom_timing_names)
+              hash[:custom_timing_names] = []
+            end
+            hash.delete(:started_formatted)
+            if hash.key?(:duration_milliseconds)
+              hash[:duration_milliseconds] = 0
+            end
+            page = self.allocate
+            page.instance_variable_set(:@attributes, hash)
+            page
+          end
+
+          private
+
+          def symbolize_hash(hash)
+            new_hash = {}
+            hash.each do |k, v|
+              sym_k = String === k ? k.to_sym : k
+              if Hash === v
+                new_hash[sym_k] = symbolize_hash(v)
+              elsif Array === v
+                new_hash[sym_k] = symbolize_array(v)
+              else
+                new_hash[sym_k] = v
+              end
+            end
+            new_hash
+          end
+
+          def symbolize_array(array)
+            array.map do |item|
+              if Array === item
+                symbolize_array(item)
+              elsif Hash === item
+                symbolize_hash(item)
+              else
+                item
+              end
+            end
+          end
+        end
+
+        attr_reader :attributes
+
         def initialize(env)
           timer_id     = MiniProfiler.generate_id
           page_name    = env['PATH_INFO']
@@ -39,8 +86,13 @@ module Rack
             executed_scalars: 0,
             executed_non_queries: 0,
             custom_timing_names: [],
-            custom_timing_stats: {}
+            custom_timing_stats: {},
+            custom_fields: {},
+            has_flamegraph: false,
+            flamegraph: nil
           )
+          self[:request_method] = env['REQUEST_METHOD']
+          self[:request_path] = env['PATH_INFO']
           name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
           self[:root] = TimerStruct::Request.createRoot(name, self)
         end
@@ -61,17 +113,21 @@ module Rack
           @attributes[:root]
         end
 
+        def attributes_to_serialize
+          @attributes.keys - [:flamegraph]
+        end
+
         def to_json(*a)
-          ::JSON.generate(@attributes.merge(self.extra_json))
+          ::JSON.generate(@attributes.slice(*attributes_to_serialize).merge(extra_json))
         end
 
         def as_json(options = nil)
-          super(options).merge!(extra_json)
+          super(options).slice(*attributes_to_serialize.map(&:to_s)).merge!(extra_json)
         end
 
         def extra_json
           {
-            started: '/Date(%d)/' % @attributes[:started_at],
+            started_formatted: '/Date(%d)/' % @attributes[:started_at],
             duration_milliseconds: @attributes[:root][:duration_milliseconds],
             custom_timing_names: @attributes[:custom_timing_stats].keys.sort
           }

data/lib/mini_profiler/timer_struct/request.rb

@@ -11,7 +11,7 @@ module Rack
           end
         end
 
-        attr_accessor :children_duration
+        attr_accessor :children_duration, :start, :parent
 
         def initialize(name, page, parent)
           start_millis = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]
@@ -62,10 +62,6 @@ module Rack
           self[:start_milliseconds]
         end
 
-        def start
-          @start
-        end
-
         def depth
           self[:depth]
         end
@@ -91,6 +87,20 @@ module Rack
           end
         end
 
+        def move_child(child, destination)
+          if index = self[:children].index(child)
+            self[:children].slice!(index)
+            self[:has_children] = self[:children].size > 0
+
+            destination[:children].push(child)
+            destination[:has_children] = true
+
+            child[:parent_timing_id] = destination[:id]
+            child.parent = destination
+            child.adjust_depth
+          end
+        end
+
         def add_sql(query, elapsed_ms, page, params = nil, skip_backtrace = false, full_backtrace = false)
           TimerStruct::Sql.new(query, elapsed_ms, page, self, params, skip_backtrace, full_backtrace).tap do |timer|
             self[:sql_timings].push(timer)
@@ -102,6 +112,19 @@ module Rack
           end
         end
 
+        def move_sql(sql, destination)
+          if index = self[:sql_timings].index(sql)
+            self[:sql_timings].slice!(index)
+            self[:has_sql_timings] = self[:sql_timings].size > 0
+            self[:sql_timings_duration_milliseconds] -= sql[:duration_milliseconds]
+            destination[:sql_timings].push(sql)
+            destination[:has_sql_timings] = true
+            destination[:sql_timings_duration_milliseconds] += sql[:duration_milliseconds]
+            sql[:parent_timing_id] = destination[:id]
+            sql.parent = destination
+          end
+        end
+
         def add_custom(type, elapsed_ms, page)
           TimerStruct::Custom.new(type, elapsed_ms, page, self).tap do |timer|
             timer[:parent_timing_id] = self[:id]
@@ -119,18 +142,37 @@ module Rack
           end
         end
 
+        def move_custom(type, custom, destination)
+          if index = self[:custom_timings][type]&.index(custom)
+            custom[:parent_timing_id] = destination[:id]
+            custom.parent = destination
+            self[:custom_timings][type].slice!(index)
+            if self[:custom_timings][type].size == 0
+              self[:custom_timings].delete(type)
+              self[:custom_timing_stats].delete(type)
+            else
+              self[:custom_timing_stats][type][:count] -= 1
+              self[:custom_timing_stats][type][:duration] -= custom[:duration_milliseconds]
+            end
+            destination[:custom_timings][type] ||= []
+            destination[:custom_timings][type].push(custom)
+            destination[:custom_timing_stats][type] ||= { count: 0, duration: 0.0 }
+            destination[:custom_timing_stats][type][:count] += 1
+            destination[:custom_timing_stats][type][:duration] += custom[:duration_milliseconds]
+          end
+        end
+
         def record_time(milliseconds = nil)
           milliseconds ||= (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start) * 1000
           self[:duration_milliseconds]                  = milliseconds
           self[:is_trivial]                             = true if milliseconds < self[:trivial_duration_threshold_milliseconds]
-          self[:duration_without_children_milliseconds] = milliseconds - @children_duration
-
-          if @parent
-            @parent.children_duration += milliseconds
-          end
-
+          self[:duration_without_children_milliseconds] = milliseconds - self[:children].sum(&:duration_ms)
         end
 
+        def adjust_depth
+          self[:depth] = self.parent ? self.parent[:depth] + 1 : 0
+          self[:children].each(&:adjust_depth)
+        end
       end
     end
   end

data/lib/mini_profiler/timer_struct/sql.rb

@@ -6,6 +6,8 @@ module Rack
     # Timing system for a SQL query
     module TimerStruct
       class Sql < TimerStruct::Base
+        attr_accessor :parent
+
         def initialize(query, duration_ms, page, parent, params = nil, skip_backtrace = false, full_backtrace = false)
 
           stack_trace = nil
@@ -36,12 +38,12 @@ module Rack
           start_millis = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]) - duration_ms
           super(
             execute_type: 3, # TODO
-            formatted_command_string: query,
+            formatted_command_string: query ? ERB::Util.html_escape(query) : nil,
             stack_trace_snippet: stack_trace,
             start_milliseconds: start_millis,
             duration_milliseconds: duration_ms,
             first_fetch_duration_milliseconds: duration_ms,
-            parameters: trim_binds(params),
+            parameters: query ? trim_binds(params) : nil,
             parent_timing_id: nil,
             is_duplicate: false
           )

data/lib/mini_profiler/version.rb

@@ -2,6 +2,6 @@
 
 module Rack
   class MiniProfiler
-    VERSION = '1.0.1'
+    VERSION = '2.3.2'
   end
 end

data/lib/mini_profiler_rails/railtie.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require_relative './railtie_methods'
 
 module Rack::MiniProfilerRails
+  extend Rack::MiniProfilerRailsMethods
 
   # call direct if needed to do a defer init
   def self.initialize!(app)
@@ -28,10 +30,12 @@ module Rack::MiniProfilerRails
 
     if serves_static_assets?(app)
       c.skip_paths << app.config.assets.prefix
+      wp_assets_path = get_webpacker_assets_path()
+      c.skip_paths << wp_assets_path if wp_assets_path
     end
 
     unless Rails.env.development? || Rails.env.test?
-      c.authorization_mode = :whitelist
+      c.authorization_mode = :allow_authorized
     end
 
     if Rails.logger
@@ -55,16 +59,92 @@ module Rack::MiniProfilerRails
 
     # Install the Middleware
     app.middleware.insert(0, Rack::MiniProfiler)
+    c.enable_advanced_debugging_tools = Rails.env.development?
 
-    # Attach to various Rails methods
-    ActiveSupport.on_load(:action_controller) do
-      ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) { |action| "Executing action: #{action}" }
+    if ::Rack::MiniProfiler.patch_rails?
+      # Attach to various Rails methods
+      ActiveSupport.on_load(:action_controller) do
+        ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) { |action| "Executing action: #{action}" }
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) { |x, y| "Rendering: #{@virtual_path}" }
+      end
+    else
+      subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
+        next if !should_measure?
+
+        current = Rack::MiniProfiler.current
+        description = "Executing action: #{payload[:action]}"
+        Thread.current[get_key(payload)] = current.current_timer
+        Rack::MiniProfiler.current.current_timer = current.current_timer.add_child(description)
+      end
+
+      subscribe("process_action.action_controller") do |name, start, finish, id, payload|
+        next if !should_measure?
+
+        key = get_key(payload)
+        parent_timer = Thread.current[key]
+        next if !parent_timer
+
+        Thread.current[key] = nil
+        Rack::MiniProfiler.current.current_timer.record_time
+        Rack::MiniProfiler.current.current_timer = parent_timer
+      end
+
+      subscribe("render_partial.action_view") do |name, start, finish, id, payload|
+        render_notification_handler(shorten_identifier(payload[:identifier]), finish, start)
+      end
+
+      subscribe("render_template.action_view") do |name, start, finish, id, payload|
+        render_notification_handler(shorten_identifier(payload[:identifier]), finish, start)
+      end
+
+      if Rack::MiniProfiler.subscribe_sql_active_record
+        # we don't want to subscribe if we've already patched a DB driver
+        # otherwise we would end up with 2 records for every query
+        subscribe("sql.active_record") do |name, start, finish, id, payload|
+          next if !should_measure?
+          next if payload[:name] =~ /SCHEMA/ && Rack::MiniProfiler.config.skip_schema_queries
+
+          Rack::MiniProfiler.record_sql(
+            payload[:sql],
+            (finish - start) * 1000,
+            Rack::MiniProfiler.binds_to_params(payload[:binds])
+          )
+        end
+      end
     end
-    ActiveSupport.on_load(:action_view) do
-      ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) { |x, y| "Rendering: #{@virtual_path}" }
+    @already_initialized = true
+  end
+
+  def self.create_engine
+    return if defined?(Rack::MiniProfilerRails::Engine)
+    klass = Class.new(::Rails::Engine) do
+      engine_name 'rack-mini-profiler'
+      config.assets.paths << File.expand_path('../../html', __FILE__)
+      config.assets.precompile << 'rack-mini-profiler.js'
+      config.assets.precompile << 'rack-mini-profiler.css'
     end
+    Rack::MiniProfilerRails.const_set("Engine", klass)
+  end
 
-    @already_initialized = true
+  def self.subscribe(event, &blk)
+    if ActiveSupport::Notifications.respond_to?(:monotonic_subscribe)
+      ActiveSupport::Notifications.monotonic_subscribe(event) { |*args| blk.call(*args) }
+    else
+      ActiveSupport::Notifications.subscribe(event) do |name, start, finish, id, payload|
+        blk.call(name, start.to_f, finish.to_f, id, payload)
+      end
+    end
+  end
+
+  def self.get_key(payload)
+    "mini_profiler_parent_timer_#{payload[:controller]}_#{payload[:action]}".to_sym
+  end
+
+  def self.shorten_identifier(identifier)
+    identifier.split('/').last(2).join('/')
   end
 
   def self.serves_static_assets?(app)
@@ -95,6 +175,7 @@ module Rack::MiniProfilerRails
       middlewares = app.middleware.middlewares
       if Rack::MiniProfiler.config.suppress_encoding.nil? &&
           middlewares.include?(Rack::Deflater) &&
+          middlewares.include?(Rack::MiniProfiler) &&
           middlewares.index(Rack::Deflater) > middlewares.index(Rack::MiniProfiler)
         Rack::MiniProfiler.config.suppress_encoding = true
       end

data/lib/mini_profiler_rails/railtie_methods.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Rack::MiniProfilerRailsMethods
+  def render_notification_handler(name, finish, start, name_as_description: false)
+    return if !should_measure?
+
+    description = name_as_description ? name : "Rendering: #{name}"
+    current = Rack::MiniProfiler.current.current_timer
+    node = current.add_child(description)
+    duration = finish - start
+    duration_ms = duration * 1000
+    node.start -= duration
+    node[:start_milliseconds] -= duration_ms
+    node.record_time(duration_ms)
+
+    children_duration = 0
+    to_be_moved = { requests: [], sql: [], custom: {} }
+    current.children.each do |child|
+      next if child == node
+      if should_move?(child, node)
+        to_be_moved[:requests] << child
+        children_duration += child[:duration_milliseconds]
+      end
+    end
+    node[:duration_without_children_milliseconds] = duration_ms - children_duration
+    to_be_moved[:requests].each { |req| current.move_child(req, node) }
+
+    current.sql_timings.each do |sql|
+      to_be_moved[:sql] << sql if should_move?(sql, node)
+    end
+    to_be_moved[:sql].each { |sql| current.move_sql(sql, node) }
+
+    current.custom_timings.each do |type, timings|
+      to_be_moved[:custom] = []
+      timings.each do |custom|
+        to_be_moved[:custom] << custom if should_move?(custom, node)
+      end
+      to_be_moved[:custom].each { |custom| current.move_custom(type, custom, node) }
+    end
+  end
+
+  def should_measure?
+    current = Rack::MiniProfiler.current
+    current && current.measure
+  end
+
+  def should_move?(child, node)
+    start = :start_milliseconds
+    duration = :duration_milliseconds
+    child[start] >= node[start] &&
+    child[start] + child[duration] <= node[start] + node[duration]
+  end
+
+  def get_webpacker_assets_path
+    if defined?(Webpacker) && Webpacker.config.config_path.exist?
+      Webpacker.config.public_output_path.to_s.gsub(Webpacker.config.public_path.to_s, "")
+    end
+  end
+
+  extend self
+end

data/lib/patches/db/activerecord.rb

@@ -15,17 +15,6 @@ module Rack
         end
       end
 
-      def binds_to_params(binds)
-        return if binds.nil? || Rack::MiniProfiler.config.max_sql_param_length == 0
-        # map ActiveRecord::Relation::QueryAttribute to [name, value]
-        params = binds.map { |c| c.kind_of?(Array) ? [c.first, c.last] : [c.name, c.value] }
-        if (skip = Rack::MiniProfiler.config.skip_sql_param_names)
-          params.map { |(n, v)| n =~ skip ? [n, nil] : [n, v] }
-        else
-          params
-        end
-      end
-
       def log_with_miniprofiler(*args, &block)
         return log_without_miniprofiler(*args, &block) unless SqlPatches.should_measure?
 
@@ -37,7 +26,7 @@ module Rack
         return rval if Rack::MiniProfiler.config.skip_schema_queries && name =~ (/SCHEMA/)
 
         elapsed_time = SqlPatches.elapsed_time(start)
-        Rack::MiniProfiler.record_sql(sql, elapsed_time, binds_to_params(binds))
+        Rack::MiniProfiler.record_sql(sql, elapsed_time, Rack::MiniProfiler.binds_to_params(binds))
         rval
       end
     end