rack-mini-profiler 1.0.2 → 3.1.0

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

data/lib/patches/db/mongo.rb

@@ -8,7 +8,7 @@ class Mongo::Server::Connection
     result, _record = SqlPatches.record_sql(args[0][0].payload.inspect) do
       dispatch_without_timing(*args, &blk)
     end
-    return result
+    result
   end
 
   # TODO: change to Module#prepend as soon as Ruby 1.9.3 support is dropped

data/lib/patches/db/moped.rb

@@ -9,6 +9,6 @@ class Moped::Node
     result, _record = SqlPatches.record_sql(args[0].log_inspect) do
       process_without_profiling(*args, &blk)
     end
-    return result
+    result
   end
 end

data/lib/patches/db/mysql2/alias_method.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# The best kind of instrumentation is in the actual db provider, however we don't want to double instrument
+
+class Mysql2::Result
+  alias_method :each_without_profiling, :each
+  def each(*args, &blk)
+    return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
+
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = each_without_profiling(*args, &blk)
+    elapsed_time = SqlPatches.elapsed_time(start)
+
+    @miniprofiler_sql_id.report_reader_duration(elapsed_time)
+    result
+  end
+end
+
+class Mysql2::Client
+  alias_method :query_without_profiling, :query
+  def query(*args, &blk)
+    return query_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    result, record = SqlPatches.record_sql(args[0]) do
+      query_without_profiling(*args, &blk)
+    end
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+    result
+  end
+end

data/lib/patches/db/mysql2/prepend.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Mysql2::Result
+  module MiniProfiler
+    def each(*args, &blk)
+      return super unless defined?(@miniprofiler_sql_id)
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = super
+      elapsed_time = SqlPatches.elapsed_time(start)
+
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
+      result
+    end
+  end
+
+  prepend MiniProfiler
+end
+
+class Mysql2::Client
+  module MiniProfiler
+    def query(*args, &blk)
+      return super unless SqlPatches.should_measure?
+
+      result, record = SqlPatches.record_sql(args[0]) do
+        super
+      end
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+      result
+    end
+  end
+
+  prepend MiniProfiler
+end

data/lib/patches/db/mysql2.rb

@@ -1,30 +1,7 @@
 # frozen_string_literal: true
 
-# The best kind of instrumentation is in the actual db provider, however we don't want to double instrument
-
-class Mysql2::Result
-  alias_method :each_without_profiling, :each
-  def each(*args, &blk)
-    return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
-
-    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    result       = each_without_profiling(*args, &blk)
-    elapsed_time = SqlPatches.elapsed_time(start)
-
-    @miniprofiler_sql_id.report_reader_duration(elapsed_time)
-    result
-  end
-end
-
-class Mysql2::Client
-  alias_method :query_without_profiling, :query
-  def query(*args, &blk)
-    return query_without_profiling(*args, &blk) unless SqlPatches.should_measure?
-
-    result, record = SqlPatches.record_sql(args[0]) do
-      query_without_profiling(*args, &blk)
-    end
-    result.instance_variable_set("@miniprofiler_sql_id", record) if result
-    result
-  end
+if defined?(Rack::MINI_PROFILER_PREPEND_MYSQL2_PATCH)
+  require "patches/db/mysql2/prepend"
+else
+  require "patches/db/mysql2/alias_method"
 end

data/lib/patches/db/plucky.rb

@@ -9,19 +9,19 @@ class Plucky::Query
   alias_method :remove_without_profiling, :remove
 
   def find_each(*args, &blk)
-    return profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
+    profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
   end
 
   def find_one(*args, &blk)
-    return profile_database_operation(__callee__, filtered_inspect(args[0]), *args, &blk)
+    profile_database_operation(__callee__, filtered_inspect(args[0]), *args, &blk)
   end
 
   def count(*args, &blk)
-    return profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
+    profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
   end
 
   def remove(*args, &blk)
-    return profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
+    profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
   end
 
   private

data/lib/patches/db/riak.rb

@@ -2,7 +2,7 @@
 
 # riak-client 2.2.2 patches
 class Riak::Multiget
-  class <<self
+  class << self
     alias_method :get_all_without_profiling, :get_all
     def get_all(client, fetch_list)
       return get_all_without_profiling(client, fetch_list) unless SqlPatches.should_measure?

data/lib/patches/net_patches.rb

@@ -1,16 +1,27 @@
 # 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]
-      Rack::MiniProfiler.step("Net::HTTP #{request.method} #{request.path}") do
-        request_without_mini_profiler(*args, &block)
+if ENV['RACK_MINI_PROFILER_PATCH_NET_HTTP'] != 'false'
+  if (defined?(Net) && defined?(Net::HTTP))
+    if defined?(Rack::MINI_PROFILER_PREPEND_NET_HTTP_PATCH)
+      module NetHTTPWithMiniProfiler
+        def request(request, *args, &block)
+          Rack::MiniProfiler.step("Net::HTTP #{request.method} #{request.path}") do
+            super
+          end
+        end
+      end
+      Net::HTTP.prepend(NetHTTPWithMiniProfiler)
+    else
+      Net::HTTP.class_eval do
+        def request_with_mini_profiler(*args, &block)
+          request = args[0]
+          Rack::MiniProfiler.step("Net::HTTP #{request.method} #{request.path}") do
+            request_without_mini_profiler(*args, &block)
+          end
+        end
+        alias request_without_mini_profiler request
+        alias request request_with_mini_profiler
       end
     end
-    alias request_without_mini_profiler request
-    alias request request_with_mini_profiler
   end
-
 end

data/lib/patches/sql_patches.rb

@@ -11,7 +11,7 @@ class SqlPatches
     start  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     result = yield
     record = ::Rack::MiniProfiler.record_sql(statement, elapsed_time(start), parameters)
-    return result, record
+    [result, record]
   end
 
   def self.should_measure?
@@ -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/prepend_mysql2_patch.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rack
+  MINI_PROFILER_PREPEND_MYSQL2_PATCH = true
+end

data/lib/prepend_net_http_patch.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rack
+  MINI_PROFILER_PREPEND_NET_HTTP_PATCH = true
+end

data/lib/rack-mini-profiler.rb

@@ -1,32 +1,9 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'timeout'
-require 'thread'
-require 'securerandom'
-
 require 'mini_profiler/version'
 require 'mini_profiler/asset_version'
 
-require 'mini_profiler/timer_struct/base'
-require 'mini_profiler/timer_struct/page'
-require 'mini_profiler/timer_struct/sql'
-require 'mini_profiler/timer_struct/custom'
-require 'mini_profiler/timer_struct/client'
-require 'mini_profiler/timer_struct/request'
-
-require 'mini_profiler/storage/abstract_store'
-require 'mini_profiler/storage/memcache_store'
-require 'mini_profiler/storage/memory_store'
-require 'mini_profiler/storage/redis_store'
-require 'mini_profiler/storage/file_store'
-
-require 'mini_profiler/config'
-require 'mini_profiler/profiling_methods'
-require 'mini_profiler/context'
-require 'mini_profiler/client_settings'
-require 'mini_profiler/gc_profiler'
-require 'mini_profiler/profiler'
+require 'mini_profiler'
 
 require 'patches/sql_patches'
 require 'patches/net_patches'

data/rack-mini-profiler.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'mini_profiler/version'
@@ -9,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',
@@ -19,22 +21,29 @@ Gem::Specification.new do |s|
     "CHANGELOG.md"
   ]
   s.add_runtime_dependency 'rack', '>= 1.2.0'
-  s.required_ruby_version = '>= 2.3.0'
+  s.required_ruby_version = '>= 2.6.0'
 
   s.metadata = {
-    'source_code_uri' => 'https://github.com/MiniProfiler/rack-mini-profiler',
+    'source_code_uri' => Rack::MiniProfiler::SOURCE_CODE_URI,
     'changelog_uri' => 'https://github.com/MiniProfiler/rack-mini-profiler/blob/master/CHANGELOG.md'
   }
 
-  s.add_development_dependency 'rake', '< 11'
+  s.add_development_dependency 'rake'
   s.add_development_dependency 'rack-test'
-  s.add_development_dependency 'activerecord', '~> 3.0'
   s.add_development_dependency 'dalli'
-  s.add_development_dependency 'rspec', '~> 3.6.0'
+  s.add_development_dependency 'rspec', '~> 3.12.0'
   s.add_development_dependency 'redis'
-  s.add_development_dependency 'sass'
-  s.add_development_dependency 'flamegraph'
+  s.add_development_dependency 'sassc'
+  s.add_development_dependency 'stackprof'
   s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'mini_racer'
+  s.add_development_dependency 'nokogiri'
+  s.add_development_dependency 'rubocop-discourse'
+  s.add_development_dependency 'listen'
+  s.add_development_dependency 'webpacker'
+  s.add_development_dependency 'rails', '~> 6.0'
+  s.add_development_dependency 'webmock', '3.9.1'
+  s.add_development_dependency 'rubyzip'
 
   s.require_paths = ["lib"]
 end