rack-mini-profiler 1.1.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 343dec64a1a5e96e086a3cbceb07c418d08a891d5f89a9315472108e125a9282
-  data.tar.gz: d242ccef7bd8c5aeb2224f7912886a0e05ce21ef571a3f6c76f384686b5f1525
+  metadata.gz: 93c2989b331d19e51611a97941ea8259812285211b00ad25bb56e55a7fe17b37
+  data.tar.gz: '07594d8609bad0a73f86cf56cfe1bf1aaeb8e279edeba50e2a5c4a3bf86be0fb'
 SHA512:
-  metadata.gz: 394c8ce3d60dbb2638fd0ea58420e8372702cfa5043bf08bdd51e731abe3019f1299bb4e3c22b92fac70f477a2fe8783720a3f2c46d393dda7ace0509b02963b
-  data.tar.gz: cf3ba12543795194bab109ff9fddd97ff0d0c349b8f505cebae202cf30b6e6d8e5058a1385ad4a8cbc747d27108c6351a4c7ddb53ccda14b9f68b7f4f9978b48
+  metadata.gz: f651aeb06ef7bab9e853aacc4ed3ab22b8470b3b8723b7d7f727092c6e7e35db75003cdb8bbeba2ef94637c9ff85ea5bf269cbefa748f46aaeb72208d900b387
+  data.tar.gz: ffe60bc20d0132e5e5c34e55debb739da0f3a62fce0d9a391f515fe9ba52f9c6c8f2cd3f327e433a8f2a9222bb60b1bbede8f1f28a9b9f39cb442b4097b982e1

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 2.0.0 - 2020-03-11
+
+- [FEATURE] Prepend Net::HTTP patch instead of class_eval and aliasing (#429)
+- [FEATURE] Stop patching Rails and use `ActiveSupport::Notifications` by default (see README.md for details)
+
 ## 1.1.6 - 2020-01-30
 
 - [FIX] edge condition on page transition function could lead to exceptions

data/README.md

@@ -51,6 +51,20 @@ gem 'stackprof'
 
 All you have to do is to include the Gem and you're good to go in development. See notes below for use in production.
 
+#### Upgrading to version 2.0.0
+
+Prior to version 2.0.0, Mini Profiler patched various Rails methods to get the information it needed such as template rendering time. Starting from version 2.0.0, Mini Profiler doesn't patch any Rails methods by default and relies on `ActiveSupport::Notifications` to get the information it needs from Rails. If you want Mini Profiler to keep using its patches in version 2.0.0 and later, change the gem line in your `Gemfile` to the following:
+
+If you want to manually require Mini Profiler:
+```ruby
+gem 'rack-mini-profiler', require: ['enable_rails_patches']
+```
+
+If you don't want to manually require Mini Profiler:
+```ruby
+gem 'rack-mini-profiler', require: ['enable_rails_patches', 'rack-mini-profiler']
+```
+
 #### Rails and manual initialization
 
 In case you need to make sure rack_mini_profiler is initialized after all other gems, or you want to execute some code before rack_mini_profiler required:

data/lib/enable_rails_patches.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    ENABLE_RAILS_PATCHES = true
+  end
+end

data/lib/mini_profiler/profiler.rb

@@ -5,6 +5,11 @@ module Rack
     class << self
 
       include Rack::MiniProfiler::ProfilingMethods
+      attr_accessor :subscribe_sql_active_record
+
+      def patch_rails?
+        !!defined?(::Rack::MiniProfiler::ENABLE_RAILS_PATCHES)
+      end
 
       def generate_id
         rand(36**20).to_s(36)
@@ -67,6 +72,17 @@ module Rack
           This feature is disabled by default, to enable set the enable_advanced_debugging_tools option to true in Mini Profiler config.
         TEXT
       end
+
+      def binds_to_params(binds)
+        return if binds.nil? || 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 = config.skip_sql_param_names)
+          params.map { |(n, v)| n =~ skip ? [n, nil] : [n, v] }
+        else
+          params
+        end
+      end
     end
 
     #

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/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

data/lib/mini_profiler/version.rb

@@ -2,6 +2,6 @@
 
 module Rack
   class MiniProfiler
-    VERSION = '1.1.6'
+    VERSION = '2.0.0'
   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)
@@ -55,17 +57,81 @@ module Rack::MiniProfilerRails
 
     # Install the Middleware
     app.middleware.insert(0, Rack::MiniProfiler)
+    c.enable_advanced_debugging_tools = Rails.env.development?
+
+    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
 
-    # Attach to various Rails methods
-    ActiveSupport.on_load(:action_controller) do
-      ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) { |action| "Executing action: #{action}" }
+      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.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
 
-    c.enable_advanced_debugging_tools = Rails.env.development?
-    @already_initialized = true
+  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)

data/lib/mini_profiler_rails/railtie_methods.rb

@@ -0,0 +1,55 @@
+# 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
+
+  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

data/lib/patches/net_patches.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
 if (defined?(Net) && defined?(Net::HTTP))
-
-  Net::HTTP.class_eval do
-    def request_with_mini_profiler(*args, &block)
-      request = args[0]
+  module NetHTTPWithMiniProfiler
+    def request(request, *args, &block)
       Rack::MiniProfiler.step("Net::HTTP #{request.method} #{request.path}") do
-        request_without_mini_profiler(*args, &block)
+        super
       end
     end
-    alias request_without_mini_profiler request
-    alias request request_with_mini_profiler
   end
 
+  Net::HTTP.prepend(NetHTTPWithMiniProfiler)
 end

data/lib/patches/sql_patches.rb

@@ -23,18 +23,26 @@ class SqlPatches
     ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time).to_f * 1000).round(1)
   end
 
+  def self.patch_rails?
+    ::Rack::MiniProfiler.patch_rails?
+  end
+
   def self.sql_patches
     patches = []
 
     patches << 'mysql2' if defined?(Mysql2::Client) && Mysql2::Client.class == Class
     patches << 'pg' if defined?(PG::Result) && PG::Result.class == Class
     patches << 'oracle_enhanced' if defined?(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter) && ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class == Class &&
-                                    SqlPatches.correct_version?('~> 1.5.0', ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter)
+                                    SqlPatches.correct_version?('~> 1.5.0', ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter) &&
+                                    patch_rails?
     # if the adapters were directly patched, don't patch again
-    return patches unless patches.empty?
+    if !patches.empty?
+      Rack::MiniProfiler.subscribe_sql_active_record = false
+      return patches
+    end
     patches << 'sequel' if defined?(Sequel::Database) && Sequel::Database.class == Class
-    patches << 'activerecord' if defined?(ActiveRecord) && ActiveRecord.class == Module
-
+    patches << 'activerecord' if defined?(ActiveRecord) && ActiveRecord.class == Module && patch_rails?
+    Rack::MiniProfiler.subscribe_sql_active_record = patches.empty? && !patch_rails?
     patches
   end
 

data/lib/rack-mini-profiler.rb

@@ -27,7 +27,6 @@ require 'mini_profiler/context'
 require 'mini_profiler/client_settings'
 require 'mini_profiler/gc_profiler'
 require 'mini_profiler/profiler'
-
 require 'patches/sql_patches'
 require 'patches/net_patches'
 

data/rack-mini-profiler.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.authors = ["Sam Saffron", "Robin Ward", "Aleks Totic"]
   s.description = "Profiling toolkit for Rack applications with Rails integration. Client Side profiling, DB profiling and Server profiling."
   s.email = "sam.saffron@gmail.com"
-  s.homepage = "http://miniprofiler.com"
+  s.homepage = "https://miniprofiler.com"
   s.license = "MIT"
   s.files = [
     'rack-mini-profiler.gemspec',
@@ -39,6 +39,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rubocop'
   s.add_development_dependency 'mini_racer'
   s.add_development_dependency 'nokogiri'
+  s.add_development_dependency 'rubocop-discourse'
 
   s.require_paths = ["lib"]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 2.0.0
 platform: ruby
 authors:
 - Sam Saffron
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-30 00:00:00.000000000 Z
+date: 2020-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -180,6 +180,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-discourse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Profiling toolkit for Rack applications with Rails integration. Client
   Side profiling, DB profiling and Server profiling.
 email: sam.saffron@gmail.com
@@ -191,6 +205,7 @@ extra_rdoc_files:
 files:
 - CHANGELOG.md
 - README.md
+- lib/enable_rails_patches.rb
 - lib/generators/rack_profiler/USAGE
 - lib/generators/rack_profiler/install_generator.rb
 - lib/generators/rack_profiler/templates/rack_profiler.rb
@@ -223,6 +238,7 @@ files:
 - lib/mini_profiler/timer_struct/sql.rb
 - lib/mini_profiler/version.rb
 - lib/mini_profiler_rails/railtie.rb
+- lib/mini_profiler_rails/railtie_methods.rb
 - lib/patches/db/activerecord.rb
 - lib/patches/db/mongo.rb
 - lib/patches/db/moped.rb
@@ -239,7 +255,7 @@ files:
 - lib/patches/sql_patches.rb
 - lib/rack-mini-profiler.rb
 - rack-mini-profiler.gemspec
-homepage: http://miniprofiler.com
+homepage: https://miniprofiler.com
 licenses:
 - MIT
 metadata: