mini-sharp-hub 0.0.1

data/rack-mini-profiler-4.0.1/lib/mini_profiler_rails/railtie.rb

@@ -0,0 +1,234 @@
+# 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 defined?(@already_initialized) && @already_initialized
+
+    c = Rack::MiniProfiler.config
+
+    # By default, only show the MiniProfiler in development mode.
+    # To use the MiniProfiler in production, call Rack::MiniProfiler.authorize_request
+    # from a hook in your ApplicationController
+    #
+    # Example:
+    #   before_action { Rack::MiniProfiler.authorize_request if current_user.is_admin? }
+    #
+    # NOTE: this must be set here with = and not ||=
+    #  The out of the box default is "true"
+    c.pre_authorize_cb = lambda { |env|
+      !Rails.env.test?
+    }
+
+    c.skip_paths ||= []
+
+    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 = :allow_authorized
+    end
+
+    if Rails.logger
+      c.logger = Rails.logger
+    end
+
+    # The file store is just so much less flaky
+    # If the user has not changed from the default memory store then switch to the file store, otherwise keep what the user set
+    if c.storage == Rack::MiniProfiler::MemoryStore && c.storage_options.nil?
+      base_path = Rails.application.config.paths['tmp'].first rescue "#{Rails.root}/tmp"
+      tmp       = base_path + '/miniprofiler'
+
+      c.storage_options = { path: tmp }
+      c.storage = Rack::MiniProfiler::FileStore
+    end
+
+    # Quiet the SQL stack traces
+    c.backtrace_remove = Rails.root.to_s + "/"
+    c.backtrace_includes =  [/^\/?(app|config|lib|test)/]
+    c.skip_schema_queries = (Rails.env.development? || Rails.env.test?)
+
+    # 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
+        controller_name = payload[:controller].sub(/Controller\z/, '').downcase
+        description = "Executing: #{controller_name}##{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]),
+            payload[:cached]
+          )
+        end
+
+        subscribe("instantiation.active_record") do |name, start, finish, id, payload|
+          next if !should_measure?
+
+          Rack::MiniProfiler.report_reader_duration(
+            (finish - start) * 1000,
+            payload[:record_count],
+            payload[:class_name]
+          )
+        end
+      end
+    end
+    @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
+
+  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)
+    config = app.config
+
+    if !config.respond_to?(:assets) || !config.assets.respond_to?(:prefix)
+      return false
+    end
+
+    if ::Rails.version >= "5.0.0"
+      ::Rails.configuration.public_file_server.enabled
+    elsif ::Rails.version >= "4.2.0"
+      ::Rails.configuration.serve_static_files
+    else
+      ::Rails.configuration.serve_static_assets
+    end
+  end
+
+  class Railtie < ::Rails::Railtie
+
+    initializer "rack_mini_profiler.configure_rails_initialization" do |app|
+      Rack::MiniProfilerRails.initialize!(app)
+    end
+
+    # Suppress compression when Rack::Deflater is lower in the middleware
+    # stack than Rack::MiniProfiler
+    config.after_initialize do |app|
+      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
+    end
+
+    # TODO: Implement something better here
+    # config.after_initialize do
+    #
+    #   class ::ActionView::Helpers::AssetTagHelper::JavascriptIncludeTag
+    #     alias_method :asset_tag_orig, :asset_tag
+    #     def asset_tag(source,options)
+    #       current = Rack::MiniProfiler.current
+    #       return asset_tag_orig(source,options) unless current
+    #       wrapped = ""
+    #       unless current.mpt_init
+    #         current.mpt_init = true
+    #         wrapped << Rack::MiniProfiler::ClientTimerStruct.init_instrumentation
+    #       end
+    #       name = source.split('/')[-1]
+    #       wrapped << Rack::MiniProfiler::ClientTimerStruct.instrument(name, asset_tag_orig(source,options)).html_safe
+    #       wrapped
+    #     end
+    #   end
+
+    #   class ::ActionView::Helpers::AssetTagHelper::StylesheetIncludeTag
+    #     alias_method :asset_tag_orig, :asset_tag
+    #     def asset_tag(source,options)
+    #       current = Rack::MiniProfiler.current
+    #       return asset_tag_orig(source,options) unless current
+    #       wrapped = ""
+    #       unless current.mpt_init
+    #         current.mpt_init = true
+    #         wrapped << Rack::MiniProfiler::ClientTimerStruct.init_instrumentation
+    #       end
+    #       name = source.split('/')[-1]
+    #       wrapped << Rack::MiniProfiler::ClientTimerStruct.instrument(name, asset_tag_orig(source,options)).html_safe
+    #       wrapped
+    #     end
+    #   end
+
+    # end
+
+  end
+end

data/rack-mini-profiler-4.0.1/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.try(:config)&.config_path&.exist?
+      Webpacker.config.public_output_path.to_s.gsub(Webpacker.config.public_path.to_s, "")
+    end
+  end
+
+  extend self
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/activerecord.rb

@@ -0,0 +1,44 @@
+# 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
+  class MiniProfiler
+    module ActiveRecordInstrumentation
+      def self.included(instrumented_class)
+        instrumented_class.class_eval do
+          unless instrumented_class.method_defined?(:log_without_miniprofiler)
+            alias_method :log_without_miniprofiler, :log
+            alias_method :log, :log_with_miniprofiler
+            protected :log
+          end
+        end
+      end
+
+      def log_with_miniprofiler(*args, **kwargs, &block)
+        return log_without_miniprofiler(*args, **kwargs, &block) unless SqlPatches.should_measure?
+
+        sql, name, binds = args
+        start            = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        rval             = log_without_miniprofiler(*args, **kwargs, &block)
+
+        # Don't log schema queries if the option is set
+        return rval if Rack::MiniProfiler.config.skip_schema_queries && name =~ (/SCHEMA/)
+
+        elapsed_time = SqlPatches.elapsed_time(start)
+        Rack::MiniProfiler.record_sql(sql, elapsed_time, Rack::MiniProfiler.binds_to_params(binds))
+        rval
+      end
+    end
+  end
+
+  def self.insert_instrumentation
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+    end
+  end
+
+  if defined?(::Rails)
+    insert_instrumentation
+  end
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/mongo.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Mongo/Mongoid 5 patches
+class Mongo::Server::Connection
+  def dispatch_with_timing(*args, &blk)
+    return dispatch_without_timing(*args, &blk) unless SqlPatches.should_measure?
+
+    result, _record = SqlPatches.record_sql(args[0][0].payload.inspect) do
+      dispatch_without_timing(*args, &blk)
+    end
+    result
+  end
+
+  # TODO: change to Module#prepend as soon as Ruby 1.9.3 support is dropped
+  alias_method :dispatch_without_timing, :dispatch
+  alias_method :dispatch, :dispatch_with_timing
+
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/moped.rb

@@ -0,0 +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?
+
+    result, _record = SqlPatches.record_sql(args[0].log_inspect) do
+      process_without_profiling(*args, &blk)
+    end
+    result
+  end
+end

data/rack-mini-profiler-4.0.1/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/rack-mini-profiler-4.0.1/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/rack-mini-profiler-4.0.1/lib/patches/db/mysql2.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(Rack::MINI_PROFILER_PREPEND_MYSQL2_PATCH)
+  require "patches/db/mysql2/prepend"
+else
+  require "patches/db/mysql2/alias_method"
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/neo4j.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Neo4j::Core::Query
+  alias_method :response_without_miniprofiler, :response
+
+  def response
+    return @response if @response
+    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)
+    rval
+  end
+
+  alias_method :response_with_miniprofiler, :response
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/nobrainer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Rack::MiniProfiler::NoBrainerProfiler
+
+  def on_query(env)
+    if SqlPatches.should_measure?
+      not_indexed = env[:criteria] && env[:criteria].where_present? &&
+                        !env[:criteria].where_indexed? &&
+                        !env[:criteria].model.try(:perf_warnings_disabled)
+
+      query = "".dup
+
+      # per-model/query database overrides
+      query << "[#{env[:options][:db]}] " if env[:options][:db]
+
+      # "read", "write" prefix
+      # query << "(#{NoBrainer::RQL.type_of(env[:query]).to_s}) "
+
+      query << "NOT USING INDEX: " if not_indexed
+      query << env[:query].inspect.delete("\n").gsub(/ +/, ' ') + " "
+
+      if env[:exception]
+        query << "exception: #{env[:exception].class} #{env[:exception].message.split("\n").first} "
+      end
+
+      ::Rack::MiniProfiler.record_sql query.strip, env[:duration] * 1000.0
+    end
+  end
+
+  NoBrainer::Profiler.register self.new
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/oracle_enhanced.rb

@@ -0,0 +1,70 @@
+# 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        = 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)
+
+    result
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
+  SCHEMA_QUERY_TYPES = ["Sequence", "Primary Key", "Primary Key Trigger", nil].freeze
+
+  alias_method :execute_without_profiling, :execute
+  def execute(sql, name = nil)
+    mp_profile_sql(sql, name) { execute_without_profiling(sql, name) }
+  end
+
+  alias_method :exec_query_without_profiling, :exec_query
+  def exec_query(sql, name = 'SQL', binds = [])
+    mp_profile_sql(sql, name) { exec_query_without_profiling(sql, name, binds) }
+  end
+
+  alias_method :exec_insert_without_profiling, :exec_insert
+  def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+    mp_profile_sql(sql, name) { exec_insert_without_profiling(sql, name, binds, pk, sequence_name) }
+  end
+
+  alias_method :exec_update_without_profiling, :exec_update
+  def exec_update(sql, name, binds)
+    mp_profile_sql(sql, name) { exec_update_without_profiling(sql, name, binds) }
+  end
+
+  # See oracle-enhanced/lib/active_record/connection_adapters/oracle_enhanced_database_statements.rb:183
+  # where the exec delete method is aliased in the same way. We just have to do it again here to make sure
+  # the new exec_delete alias is linked to our profiling-enabled version.
+  alias :exec_delete :exec_update
+
+  private
+
+  def mp_profile_sql(sql, name, &blk)
+    return yield unless mp_should_measure?(name)
+
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = yield
+    elapsed_time = SqlPatches.elapsed_time(start)
+    record       = ::Rack::MiniProfiler.record_sql(sql, elapsed_time)
+
+    # Some queries return the row count as a Fixnum and will be frozen, don't save a record
+    # for those.
+    result.instance_variable_set("@miniprofiler_sql_id", record) if (result && !result.frozen?)
+
+    result
+  end
+
+  # Only measure when profiling is enabled
+  # When skip_schema_queries is set to true, it will ignore any query of the types
+  # in the schema_query_types array
+  def mp_should_measure?(name)
+    return false unless SqlPatches.should_measure?
+
+    !(Rack::MiniProfiler.config.skip_schema_queries && SCHEMA_QUERY_TYPES.include?(name))
+  end
+end

data/rack-mini-profiler-4.0.1/lib/patches/db/pg/alias_method.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+class PG::Result
+  alias_method :each_without_profiling, :each
+  alias_method :values_without_profiling, :values
+
+  def values(*args, &blk)
+    return values_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
+    mp_report_sql do
+      values_without_profiling(*args , &blk)
+    end
+  end
+
+  def each(*args, &blk)
+    return each_without_profiling(*args, &blk) unless defined?(@miniprofiler_sql_id)
+    mp_report_sql do
+      each_without_profiling(*args, &blk)
+    end
+  end
+
+  def mp_report_sql(&block)
+    start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result       = yield
+    elapsed_time = SqlPatches.elapsed_time(start)
+    @miniprofiler_sql_id.report_reader_duration(elapsed_time)
+    result
+  end
+end
+
+class PG::Connection
+  alias_method :exec_without_profiling, :exec
+  alias_method :async_exec_without_profiling, :async_exec
+  alias_method :exec_prepared_without_profiling, :exec_prepared
+  alias_method :send_query_prepared_without_profiling, :send_query_prepared
+  alias_method :prepare_without_profiling, :prepare
+
+  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
+
+    @prepare_map ||= {}
+    @prepare_map[args[0]] = args[1]
+    # 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)
+  end
+
+  def exec(*args, &blk)
+    return exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    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
+
+    result
+  end
+
+  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        = 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
+    record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+    result
+  end
+
+  def send_query_prepared(*args, &blk)
+    return send_query_prepared_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    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
+    record       = ::Rack::MiniProfiler.record_sql(mapped, elapsed_time)
+    result.instance_variable_set("@miniprofiler_sql_id", record) if result
+
+    result
+  end
+
+  def async_exec(*args, &blk)
+    return async_exec_without_profiling(*args, &blk) unless SqlPatches.should_measure?
+
+    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
+
+    result
+  end
+
+  alias_method :query, :exec
+end