rack-mini-profiler 0.9.2 → 0.9.3

data/lib/mini_profiler/timer_struct/sql.rb

@@ -0,0 +1,59 @@
+module Rack
+  class MiniProfiler
+
+    # Timing system for a SQL query
+    module TimerStruct
+      class Sql < TimerStruct::Base
+        def initialize(query, duration_ms, page, parent, 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 = ""
+             # 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
+                    (
+                      (
+                        Rack::MiniProfiler.config.backtrace_includes.nil? or
+                        Rack::MiniProfiler.config.backtrace_includes.all?{|regex| ln =~ regex}
+                      ) and
+                      (
+                        Rack::MiniProfiler.config.backtrace_ignores.nil? or
+                        Rack::MiniProfiler.config.backtrace_ignores.all?{|regex| !(ln =~ regex)}
+                      )
+                    )
+                stack_trace << ln << "\n"
+              end
+            end
+          end
+
+          @parent      = parent
+          @page        = page
+          start_millis = ((Time.now.to_f * 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                        => nil,
+            :parent_timing_id                  => nil,
+            :is_duplicate                      => false
+          )
+        end
+
+        def report_reader_duration(elapsed_ms)
+          return if @reported
+          @reported = true
+          self[:duration_milliseconds]                += elapsed_ms
+          @parent[:sql_timings_duration_milliseconds] += elapsed_ms
+          @page[:duration_milliseconds_in_sql]        += elapsed_ms
+        end
+
+      end
+    end
+  end
+end

data/lib/mini_profiler/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class MiniProfiler
-    VERSION = '898a13ca6797c6bc1fee313e17d388b0'.freeze
+    VERSION = '0.9.3'
   end
-end
+end

data/lib/patches/db/activerecord.rb

@@ -0,0 +1,42 @@
+## 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, &block)
+        return log_without_miniprofiler(*args, &block) unless SqlPatches.should_measure?
+
+        sql, name, _binds = args
+        start            = Time.now
+        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/
+
+        elapsed_time = SqlPatches.elapsed_time(start)
+        Rack::MiniProfiler.record_sql(sql, elapsed_time)
+        rval
+      end
+    end
+  end
+
+  def self.insert_instrumentation
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+    end
+  end
+
+  if defined?(::Rails) && !SqlPatches.patched?
+    insert_instrumentation
+  end
+end

data/lib/patches/db/moped.rb

@@ -0,0 +1,12 @@
+# 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
+    return result
+  end
+end

data/lib/patches/db/mysql2.rb

@@ -0,0 +1,30 @@
+# 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 @miniprofiler_sql_id
+
+    start        = Time.now
+    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
+
+SqlPatches.patched = true

data/lib/patches/db/pg.rb

@@ -0,0 +1,104 @@
+# 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
+  alias_method :values_without_profiling, :values
+
+  def values(*args, &blk)
+    return values_without_profiling(*args, &blk) unless @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 @miniprofiler_sql_id
+    mp_report_sql do
+      each_without_profiling(*args, &blk)
+    end
+  end
+
+  def mp_report_sql(&block)
+    start        = Time.now
+    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
+
+  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        = Time.now
+    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
+
+  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)
+    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        = Time.now
+    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 exec_without_profiling(*args,&blk) unless SqlPatches.should_measure?
+
+    start        = Time.now
+    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
+
+SqlPatches.patched = true

data/lib/patches/db/plucky.rb

@@ -0,0 +1,47 @@
+# mongo_mapper patches
+# TODO: Include overrides for distinct, update, cursor, and create
+class Plucky::Query
+  alias_method :find_each_without_profiling, :find_each
+  alias_method :find_one_without_profiling, :find_one
+  alias_method :count_without_profiling, :count
+  alias_method :remove_without_profiling, :remove
+
+  def find_each(*args, &blk)
+    return 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)
+  end
+
+  def count(*args, &blk)
+    return profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
+  end
+
+  def remove(*args, &blk)
+    return profile_database_operation(__callee__, filtered_inspect(), *args, &blk)
+  end
+
+  private
+
+  def profile_database_operation(method, message, *args, &blk)
+    return self.send("#{method.id2name}_without_profiling", *args, &blk) unless SqlPatches.should_measure?
+
+    start        = Time.now
+    result       = self.send("#{method.id2name}_without_profiling", *args, &blk)
+    elapsed_time = SqlPatches.elapsed_time(start)
+
+    query_message = "#{@collection.name}.#{method.id2name} => #{message}"
+    ::Rack::MiniProfiler.record_sql(query_message, elapsed_time)
+
+    result
+  end
+
+  def filtered_inspect(hash = to_hash())
+    hash_string = hash.reject { |key| key == :transformer }.collect do |key, value|
+      "  #{key}: #{value.inspect}"
+    end.join(",\n")
+
+    "{\n#{hash_string}\n}"
+  end
+end

data/lib/patches/db/rsolr.rb

@@ -0,0 +1,24 @@
+class RSolr::Connection
+  alias_method :execute_without_profiling, :execute
+  def execute_with_profiling(client, request_context)
+    return execute_without_profiling(client, request_context) unless SqlPatches.should_measure?
+
+    start        = Time.now
+    result       = execute_without_profiling(client, request_context)
+    elapsed_time = SqlPatches.elapsed_time(start)
+
+    data = "#{request_context[:method].upcase} #{request_context[:uri]}"
+    if request_context[:method] == :post and request_context[:data]
+      if request_context[:headers].include?("Content-Type") and request_context[:headers]["Content-Type"] == "text/xml"
+        # it's xml, unescaping isn't needed
+        data << "\n#{request_context[:data]}"
+      else
+        data << "\n#{Rack::Utils.unescape(request_context[:data])}"
+      end
+    end
+    ::Rack::MiniProfiler.record_sql(data, elapsed_time)
+
+    result
+  end
+  alias_method :execute, :execute_with_profiling
+end

data/lib/patches/db/sequel.rb

@@ -0,0 +1,10 @@
+module Sequel
+  class Database
+    alias_method :log_duration_original, :log_duration
+    def log_duration(duration, message)
+      # `duration` will be in seconds, but we need it in milliseconds for internal consistency.
+      ::Rack::MiniProfiler.record_sql(message, duration * 1000)
+      log_duration_original(duration, message)
+    end
+  end
+end

data/lib/patches/sql_patches.rb

@@ -19,266 +19,28 @@ class SqlPatches
   rescue NameError
     false
   end
-end
-
-# The best kind of instrumentation is in the actual db provider, however we don't want to double instrument
-if SqlPatches.class_exists? "Mysql2::Client"
-
-  class Mysql2::Result
-    alias_method :each_without_profiling, :each
-    def each(*args, &blk)
-      return each_without_profiling(*args, &blk) unless @miniprofiler_sql_id
-
-      start = Time.now
-      result = each_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
 
-      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
-      result
-    end
+  def self.record_sql(statement, &block)
+    start  = Time.now
+    result = yield
+    record = ::Rack::MiniProfiler.record_sql( statement, elapsed_time(start) )
+    return result, record
   end
 
-  class Mysql2::Client
-    alias_method :query_without_profiling, :query
-    def query(*args,&blk)
-      current = ::Rack::MiniProfiler.current
-      return query_without_profiling(*args,&blk) unless current && current.measure
-
-      start = Time.now
-      result = query_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-      record = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
-      result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-      result
-
-    end
+  def self.should_measure?
+    current = ::Rack::MiniProfiler.current
+    (current && current.measure)
   end
 
-  SqlPatches.patched = true
-end
-
-
-# PG patches, keep in mind exec and async_exec have a exec{|r| } semantics that is yet to be implemented
-if SqlPatches.class_exists? "PG::Result"
-
-  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 @miniprofiler_sql_id
-
-      start = Time.now
-      result = values_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-
-      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
-      result
-    end
-
-    def each(*args, &blk)
-      return each_without_profiling(*args, &blk) unless @miniprofiler_sql_id
-
-      start = Time.now
-      result = each_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-
-      @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
-
-    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
-
-      current = ::Rack::MiniProfiler.current
-      return prepare_without_profiling(*args,&blk) unless current && current.measure
-
-      prepare_without_profiling(*args,&blk)
-    end
-
-    def exec(*args,&blk)
-      current = ::Rack::MiniProfiler.current
-      return exec_without_profiling(*args,&blk) unless current && current.measure
-
-      start = Time.now
-      result = exec_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-      record = ::Rack::MiniProfiler.record_sql(args[0], elapsed_time)
-      result.instance_variable_set("@miniprofiler_sql_id", record) if result
-
-      result
-    end
-
-    def exec_prepared(*args,&blk)
-      current = ::Rack::MiniProfiler.current
-      return exec_prepared_without_profiling(*args,&blk) unless current && current.measure
-
-      start = Time.now
-      result = exec_prepared_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-      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)
-      current = ::Rack::MiniProfiler.current
-      return send_query_prepared_without_profiling(*args,&blk) unless current && current.measure
-
-      start = Time.now
-      result = send_query_prepared_without_profiling(*args,&blk)
-
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-      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)
-      current = ::Rack::MiniProfiler.current
-      return exec_without_profiling(*args,&blk) unless current && current.measure
-
-      start = Time.now
-      result = exec_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-      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
-
-  SqlPatches.patched = true
-end
-
-
-# Mongoid 3 patches
-if SqlPatches.class_exists?("Moped::Node")
-  class Moped::Node
-    alias_method :process_without_profiling, :process
-    def process(*args,&blk)
-      current = ::Rack::MiniProfiler.current
-      return process_without_profiling(*args,&blk) unless current && current.measure
-
-      start = Time.now
-      result = process_without_profiling(*args,&blk)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-      ::Rack::MiniProfiler.record_sql(args[0].log_inspect, elapsed_time)
-
-      result
-    end
+  def self.elapsed_time(start_time)
+    ((Time.now - start_time).to_f * 1000).round(1)
   end
 end
 
-if SqlPatches.class_exists?("RSolr::Connection") && RSolr::VERSION[0] != "0" #  requires at least v1.0.0
-  class RSolr::Connection
-    alias_method :execute_without_profiling, :execute
-    def execute_with_profiling(client, request_context)
-      current = ::Rack::MiniProfiler.current
-      return execute_without_profiling(client, request_context) unless current && current.measure
-
-      start = Time.now
-      result = execute_without_profiling(client, request_context)
-      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
-
-      data = "#{request_context[:method].upcase} #{request_context[:uri]}"
-      if request_context[:method] == :post and request_context[:data]
-        if request_context[:headers].include?("Content-Type") and request_context[:headers]["Content-Type"] == "text/xml"
-          # it's xml, unescaping isn't needed
-          data << "\n#{request_context[:data]}"
-        else
-          data << "\n#{Rack::Utils.unescape(request_context[:data])}"
-        end
-      end
-      ::Rack::MiniProfiler.record_sql(data, elapsed_time)
-
-      result
-    end
-    alias_method :execute, :execute_with_profiling
-  end
-end
-
-
-# Fallback for sequel
-if SqlPatches.class_exists?("Sequel::Database") && !SqlPatches.patched?
-  module Sequel
-    class Database
-      alias_method :log_duration_original, :log_duration
-      def log_duration(duration, message)
-        # `duration` will be in seconds, but we need it in milliseconds for internal consistency.
-        ::Rack::MiniProfiler.record_sql(message, duration * 1000)
-        log_duration_original(duration, message)
-      end
-    end
-  end
-end
-
-
-## based off https://github.com/newrelic/rpm/blob/master/lib/new_relic/agent/instrumentation/active_record.rb
-## fallback for alls sorts of weird dbs
-if SqlPatches.module_exists?('ActiveRecord') && !SqlPatches.patched?
-  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, &block)
-          current = ::Rack::MiniProfiler.current
-          return log_without_miniprofiler(*args, &block) unless current && current.measure
-
-          sql, name, binds = args
-          t0 = Time.now
-          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/
-
-          elapsed_time = ((Time.now - t0).to_f * 1000).round(1)
-          Rack::MiniProfiler.record_sql(sql, elapsed_time)
-          rval
-        end
-      end
-    end
-
-    def self.insert_instrumentation
-      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-        include ::Rack::MiniProfiler::ActiveRecordInstrumentation
-      end
-    end
-
-    if defined?(::Rails) && !SqlPatches.patched?
-      insert_instrumentation
-    end
-  end
-end
+require 'patches/db/mysql2'         if SqlPatches.class_exists? "Mysql2::Client"
+require 'patches/db/pg'             if SqlPatches.class_exists? "PG::Result"
+require 'patches/db/moped'          if SqlPatches.class_exists?("Moped::Node")
+require 'patches/db/plucky'         if SqlPatches.class_exists?("Plucky::Query")
+require 'patches/db/rsolr'          if SqlPatches.class_exists?("RSolr::Connection") && RSolr::VERSION[0] != "0"
+require 'patches/db/sequel'         if !SqlPatches.patched? && SqlPatches.class_exists?("Sequel::Database")
+require 'patches/db/activerecord'   if !SqlPatches.patched? && SqlPatches.module_exists?("ActiveRecord")