rack-mini-profiler 0.10.6 → 2.3.0

data/lib/mini_profiler/timer_struct/sql.rb

@@ -1,28 +1,31 @@
 # frozen_string_literal: true
+
 module Rack
   class MiniProfiler
 
     # 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
           unless skip_backtrace || duration_ms < Rack::MiniProfiler.config.backtrace_threshold_ms
             # Allow us to filter the stack trace
-            stack_trace = String.new
-             # Clean up the stack trace if there are options to do so
+            stack_trace = "".dup
+            # Clean up the stack trace if there are options to do so
             Kernel.caller.each do |ln|
-              ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove and !full_backtrace
-              if    full_backtrace or
+              ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove && !full_backtrace
+              if    full_backtrace ||
                     (
                       (
-                        Rack::MiniProfiler.config.backtrace_includes.nil? or
-                        Rack::MiniProfiler.config.backtrace_includes.any?{|regex| ln =~ regex}
-                      ) and
+                        Rack::MiniProfiler.config.backtrace_includes.nil? ||
+                        Rack::MiniProfiler.config.backtrace_includes.any? { |regex| ln =~ regex }
+                      ) &&
                       (
-                        Rack::MiniProfiler.config.backtrace_ignores.nil? or
-                        Rack::MiniProfiler.config.backtrace_ignores.none?{|regex| ln =~ regex}
+                        Rack::MiniProfiler.config.backtrace_ignores.nil? ||
+                        Rack::MiniProfiler.config.backtrace_ignores.none? { |regex| ln =~ regex }
                       )
                     )
                 stack_trace << ln << "\n"
@@ -32,17 +35,17 @@ module Rack
 
           @parent      = parent
           @page        = page
-          start_millis = ((Time.now.to_f * 1000).to_i - page[:started]) - duration_ms
+          start_millis = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]) - duration_ms
           super(
-            :execute_type                      => 3, # TODO
-            :formatted_command_string          => query,
-            :stack_trace_snippet               => stack_trace,
-            :start_milliseconds                => start_millis,
-            :duration_milliseconds             => duration_ms,
-            :first_fetch_duration_milliseconds => duration_ms,
-            :parameters                        => trim_binds(params),
-            :parent_timing_id                  => nil,
-            :is_duplicate                      => false
+            execute_type: 3, # TODO
+            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: query ? trim_binds(params) : nil,
+            parent_timing_id: nil,
+            is_duplicate: false
           )
         end
 
@@ -57,18 +60,18 @@ module Rack
         def trim_binds(binds)
           max_len = Rack::MiniProfiler.config.max_sql_param_length
           return if binds.nil? || max_len == 0
-          return binds.map{|(name, val)| [name, val]} if max_len.nil?
+          return binds.map { |(name, val)| [name, val] } if max_len.nil?
           binds.map do |(name, val)|
             val ||= name
             if val.nil? || val == true || val == false || val.kind_of?(Numeric)
               # keep these parameters as is
             elsif val.kind_of?(String)
-              val = val[0...max_len]+(max_len < val.length ? '...' : '') if max_len
+              val = val[0...max_len] + (max_len < val.length ? '...' : '') if max_len
             else
               val = val.class.name
             end
             if name.kind_of?(String)
-              name = name[0...max_len]+(max_len < name.length ? '...' : '') if max_len
+              name = name[0...max_len] + (max_len < name.length ? '...' : '') if max_len
             end
             [name, val]
           end

data/lib/mini_profiler/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
-    VERSION = '0.10.6'
+    VERSION = '2.3.0'
   end
 end

data/lib/mini_profiler_rails/railtie.rb

@@ -1,11 +1,15 @@
+# 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)
 
-    raise "MiniProfilerRails initialized twice. Set `require: false' for rack-mini-profiler in your Gemfile" if @already_initialized
+    raise "MiniProfilerRails initialized twice. Set `require: false' for rack-mini-profiler in your Gemfile" if defined?(@already_initialized) && @already_initialized
 
     c = Rack::MiniProfiler.config
 
@@ -26,6 +30,8 @@ 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?
@@ -42,7 +48,7 @@ module Rack::MiniProfilerRails
       base_path = Rails.application.config.paths['tmp'].first rescue "#{Rails.root}/tmp"
       tmp       = base_path + '/miniprofiler'
 
-      c.storage_options = {:path => tmp}
+      c.storage_options = { path: tmp }
       c.storage = Rack::MiniProfiler::FileStore
     end
 
@@ -53,16 +59,92 @@ 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
 
-    # Attach to various Rails methods
-    ActiveSupport.on_load(:action_controller) do
-      ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) {|action| "Executing action: #{action}"}
+      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)
@@ -93,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ## based off https://github.com/newrelic/rpm/blob/master/lib/new_relic/agent/instrumentation/active_record.rb
 ## fallback for alls sorts of weird dbs
 module Rack
@@ -13,29 +15,18 @@ 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?
 
         sql, name, binds = args
-        start            = Time.now
+        start            = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         rval             = log_without_miniprofiler(*args, &block)
 
         # Don't log schema queries if the option is set
-        return rval if Rack::MiniProfiler.config.skip_schema_queries and name =~ /SCHEMA/
+        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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Mongo/Mongoid 5 patches
 class Mongo::Server::Connection
   def dispatch_with_timing(*args, &blk)
@@ -6,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

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 # Mongoid 3 patches
 class Moped::Node
   alias_method :process_without_profiling, :process
-  def process(*args,&blk)
-    return process_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def process(*args, &blk)
+    return process_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
     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.rb

@@ -1,3 +1,5 @@
+# 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
@@ -5,8 +7,8 @@ class Mysql2::Result
   def each(*args, &blk)
     return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
 
-    start        = Time.now
-    result       = each_without_profiling(*args,&blk)
+    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)
@@ -16,11 +18,11 @@ end
 
 class Mysql2::Client
   alias_method :query_without_profiling, :query
-  def query(*args,&blk)
-    return query_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  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)
+    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

data/lib/patches/db/neo4j.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Neo4j::Core::Query
   alias_method :response_without_miniprofiler, :response
 
   def response
     return @response if @response
-    start = Time.now
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     rval = response_without_miniprofiler
     elapsed_time = SqlPatches.elapsed_time(start)
     Rack::MiniProfiler.record_sql(to_cypher, elapsed_time)

data/lib/patches/db/nobrainer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Rack::MiniProfiler::NoBrainerProfiler
 
   def on_query(env)
@@ -6,7 +8,7 @@ class Rack::MiniProfiler::NoBrainerProfiler
                         !env[:criteria].where_indexed? &&
                         !env[:criteria].model.try(:perf_warnings_disabled)
 
-      query = ""
+      query = "".dup
 
       # per-model/query database overrides
       query << "[#{env[:options][:db]}] " if env[:options][:db]
@@ -15,7 +17,7 @@ class Rack::MiniProfiler::NoBrainerProfiler
       # query << "(#{NoBrainer::RQL.type_of(env[:query]).to_s}) "
 
       query << "NOT USING INDEX: " if not_indexed
-      query << env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ') + " "
+      query << env[:query].inspect.delete("\n").gsub(/ +/, ' ') + " "
 
       if env[:exception]
         query << "exception: #{env[:exception].class} #{env[:exception].message.split("\n").first} "

data/lib/patches/db/oracle_enhanced.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class ActiveRecord::Result
   alias_method :each_without_profiling, :each
   def each(&blk)
     return each_without_profiling(&blk) unless defined?(@miniprofiler_sql_id)
 
-    start        = Time.now
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     result       = each_without_profiling(&blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     @miniprofiler_sql_id.report_reader_duration(elapsed_time)
@@ -45,7 +47,7 @@ class ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
   def mp_profile_sql(sql, name, &blk)
     return yield unless mp_should_measure?(name)
 
-    start        = Time.now
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     result       = yield
     elapsed_time = SqlPatches.elapsed_time(start)
     record       = ::Rack::MiniProfiler.record_sql(sql, elapsed_time)

data/lib/patches/db/pg.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # PG patches, keep in mind exec and async_exec have a exec{|r| } semantics that is yet to be implemented
 class PG::Result
   alias_method :each_without_profiling, :each
@@ -6,7 +8,7 @@ class PG::Result
   def values(*args, &blk)
     return values_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
     mp_report_sql do
-      values_without_profiling(*args ,&blk)
+      values_without_profiling(*args , &blk)
     end
   end
 
@@ -18,7 +20,7 @@ class PG::Result
   end
 
   def mp_report_sql(&block)
-    start        = Time.now
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     result       = yield
     elapsed_time = SqlPatches.elapsed_time(start)
     @miniprofiler_sql_id.report_reader_duration(elapsed_time)
@@ -33,7 +35,11 @@ class PG::Connection
   alias_method :send_query_prepared_without_profiling, :send_query_prepared
   alias_method :prepare_without_profiling, :prepare
 
-  def prepare(*args,&blk)
+  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+    alias_method :exec_params_without_profiling, :exec_params
+  end
+
+  def prepare(*args, &blk)
     # we have no choice but to do this here,
     # if we do the check for profiling first, our cache may miss critical stuff
 
@@ -42,15 +48,15 @@ class PG::Connection
     # dont leak more than 10k ever
     @prepare_map = {} if @prepare_map.length > 1000
 
-    return prepare_without_profiling(*args,&blk) unless SqlPatches.should_measure?
-    prepare_without_profiling(*args,&blk)
+    return prepare_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+    prepare_without_profiling(*args, &blk)
   end
 
-  def exec(*args,&blk)
-    return exec_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def exec(*args, &blk)
+    return exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
-    start        = Time.now
-    result       = exec_without_profiling(*args,&blk)
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = exec_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
     result.instance_variable_set("@miniprofiler_sql_id", record) if result
@@ -58,11 +64,25 @@ class PG::Connection
     result
   end
 
-  def exec_prepared(*args,&blk)
-    return exec_prepared_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  if Gem::Version.new(PG::VERSION) >= Gem::Version.new("1.1.0")
+    def exec_params(*args, &blk)
+      return exec_params_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+      start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result       = exec_params_without_profiling(*args, &blk)
+      elapsed_time = SqlPatches.elapsed_time(start)
+      record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
+      result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+      result
+    end
+  end
+
+  def exec_prepared(*args, &blk)
+    return exec_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
-    start        = Time.now
-    result       = exec_prepared_without_profiling(*args,&blk)
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = exec_prepared_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     mapped       = args[0]
     mapped       = @prepare_map[mapped] || args[0] if @prepare_map
@@ -72,11 +92,11 @@ class PG::Connection
     result
   end
 
-  def send_query_prepared(*args,&blk)
-    return send_query_prepared_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def send_query_prepared(*args, &blk)
+    return send_query_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
-    start        = Time.now
-    result       = send_query_prepared_without_profiling(*args,&blk)
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = send_query_prepared_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     mapped       = args[0]
     mapped       = @prepare_map[mapped] || args[0] if @prepare_map
@@ -86,11 +106,11 @@ class PG::Connection
     result
   end
 
-  def async_exec(*args,&blk)
-    return async_exec_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+  def async_exec(*args, &blk)
+    return async_exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
 
-    start        = Time.now
-    result       = exec_without_profiling(*args,&blk)
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = exec_without_profiling(*args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)
     record       = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
     result.instance_variable_set("@miniprofiler_sql_id", record) if result

data/lib/patches/db/plucky.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # mongo_mapper patches
 # TODO: Include overrides for distinct, update, cursor, and create
 class Plucky::Query
@@ -7,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
@@ -27,7 +29,7 @@ class Plucky::Query
   def profile_database_operation(method, message, *args, &blk)
     return self.send("#{method.id2name}_without_profiling", *args, &blk) unless SqlPatches.should_measure?
 
-    start        = Time.now
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     result       = self.send("#{method.id2name}_without_profiling", *args, &blk)
     elapsed_time = SqlPatches.elapsed_time(start)