rack-mini-profiler 0.1.31 → 0.9.3

data/lib/mini_profiler/timer_struct/custom.rb

@@ -0,0 +1,22 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+      # Timing system for a custom timers such as cache, redis, RPC, external API
+      # calls, etc.
+      class Custom < TimerStruct::Base
+        def initialize(type, duration_ms, page, parent)
+          @parent      = parent
+          @page        = page
+          @type        = type
+          start_millis = ((Time.now.to_f * 1000).to_i - page[:started]) - duration_ms
+          super(
+            :type                  => type,
+            :start_milliseconds    => start_millis,
+            :duration_milliseconds => duration_ms,
+            :parent_timing_id      => nil
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mini_profiler/timer_struct/page.rb

@@ -0,0 +1,62 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+
+      # TimerStruct::Page
+      #   Root: TimerStruct::Request
+      #     :has_many TimerStruct::Request children
+      #     :has_many TimerStruct::Sql children
+      #     :has_many TimerStruct::Custom children
+      class Page < TimerStruct::Base
+        def initialize(env)
+          timer_id     = MiniProfiler.generate_id
+          page_name    = env['PATH_INFO']
+          started_at   = (Time.now.to_f * 1000).to_i
+          machine_name = env['SERVER_NAME']
+          super(
+            :id                                      => timer_id,
+            :name                                    => page_name,
+            :started                                 => started_at,
+            :machine_name                            => machine_name,
+            :level                                   => 0,
+            :user                                    => "unknown user",
+            :has_user_viewed                         => false,
+            :client_timings                          => nil,
+            :duration_milliseconds                   => 0,
+            :has_trivial_timings                     => true,
+            :has_all_trivial_timings                 => false,
+            :trivial_duration_threshold_milliseconds => 2,
+            :head                                    => nil,
+            :duration_milliseconds_in_sql            => 0,
+            :has_sql_timings                         => true,
+            :has_duplicate_sql_timings               => false,
+            :executed_readers                        => 0,
+            :executed_scalars                        => 0,
+            :executed_non_queries                    => 0,
+            :custom_timing_names                     => [],
+            :custom_timing_stats                     => {}
+          )
+          name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+          self[:root] = TimerStruct::Request.createRoot(name, self)
+        end
+
+        def duration_ms
+          @attributes[:root][:duration_milliseconds]
+        end
+
+        def root
+          @attributes[:root]
+        end
+
+        def to_json(*a)
+          attribs = @attributes.merge(
+            :started               => '/Date(%d)/' % @attributes[:started],
+            :duration_milliseconds => @attributes[:root][:duration_milliseconds],
+            :custom_timing_names   => @attributes[:custom_timing_stats].keys.sort
+          )
+          ::JSON.generate(attribs, :max_nesting => 100)
+        end
+      end
+    end
+  end
+end

data/lib/mini_profiler/timer_struct/request.rb

@@ -0,0 +1,126 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+      class Request < TimerStruct::Base
+
+        def self.createRoot(name, page)
+          TimerStruct::Request.new(name, page, nil).tap do |timer|
+            timer[:is_root] = true
+          end
+        end
+
+        attr_accessor :children_duration
+
+        def initialize(name, page, parent)
+          start_millis = (Time.now.to_f * 1000).to_i - page[:started]
+          depth        = parent ? parent.depth + 1 : 0
+          super(
+            :id                                      => MiniProfiler.generate_id,
+            :name                                    => name,
+            :duration_milliseconds                   => 0,
+            :duration_without_children_milliseconds  => 0,
+            :start_milliseconds                      => start_millis,
+            :parent_timing_id                        => nil,
+            :children                                => [],
+            :has_children                            => false,
+            :key_values                              => nil,
+            :has_sql_timings                         => false,
+            :has_duplicate_sql_timings               => false,
+            :trivial_duration_threshold_milliseconds => 2,
+            :sql_timings                             => [],
+            :sql_timings_duration_milliseconds       => 0,
+            :is_trivial                              => false,
+            :is_root                                 => false,
+            :depth                                   => depth,
+            :executed_readers                        => 0,
+            :executed_scalars                        => 0,
+            :executed_non_queries                    => 0,
+            :custom_timing_stats                     => {},
+            :custom_timings                          => {}
+          )
+          @children_duration = 0
+          @start             = Time.now
+          @parent            = parent
+          @page              = page
+        end
+
+        def duration_ms
+          self[:duration_milliseconds]
+        end
+
+        def start_ms
+          self[:start_milliseconds]
+        end
+
+        def start
+          @start
+        end
+
+        def depth
+          self[:depth]
+        end
+
+        def children
+          self[:children]
+        end
+
+        def custom_timings
+          self[:custom_timings]
+        end
+
+        def sql_timings
+          self[:sql_timings]
+        end
+
+        def add_child(name)
+          TimerStruct::Request.new(name, @page, self).tap do |timer|
+            self[:children].push(timer)
+            self[:has_children]      = true
+            timer[:parent_timing_id] = self[:id]
+            timer[:depth]            = self[:depth] + 1
+          end
+        end
+
+        def add_sql(query, elapsed_ms, page, skip_backtrace = false, full_backtrace = false)
+          TimerStruct::Sql.new(query, elapsed_ms, page, self , skip_backtrace, full_backtrace).tap do |timer|
+            self[:sql_timings].push(timer)
+            timer[:parent_timing_id] = self[:id]
+            self[:has_sql_timings]   = true
+            self[:sql_timings_duration_milliseconds] += elapsed_ms
+            page[:duration_milliseconds_in_sql]      += elapsed_ms
+          end
+        end
+
+        def add_custom(type, elapsed_ms, page)
+          TimerStruct::Custom.new(type, elapsed_ms, page, self).tap do |timer|
+            timer[:parent_timing_id] = self[:id]
+
+            self[:custom_timings][type] ||= []
+            self[:custom_timings][type].push(timer)
+
+            self[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            self[:custom_timing_stats][type][:count]    += 1
+            self[:custom_timing_stats][type][:duration] += elapsed_ms
+
+            page[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            page[:custom_timing_stats][type][:count]    += 1
+            page[:custom_timing_stats][type][:duration] += elapsed_ms
+          end
+        end
+
+        def record_time(milliseconds = nil)
+          milliseconds ||= (Time.now - @start) * 1000
+          self[:duration_milliseconds]                  = milliseconds
+          self[:is_trivial]                             = true if milliseconds < self[:trivial_duration_threshold_milliseconds]
+          self[:duration_without_children_milliseconds] = milliseconds - @children_duration
+
+          if @parent
+            @parent.children_duration += milliseconds
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Rack
+  class MiniProfiler
+    VERSION = '0.9.3'
+  end
+end

data/{Ruby/lib → lib}/mini_profiler_rails/railtie.rb

@@ -4,9 +4,15 @@ module Rack::MiniProfilerRails
 
   # 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
+      
     c = Rack::MiniProfiler.config
 
     # By default, only show the MiniProfiler in development mode, in production allow profiling if post_authorize_cb is set
+    #
+    # 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?
     }
@@ -14,16 +20,21 @@ module Rack::MiniProfilerRails
     c.skip_paths ||= []
 
     if Rails.env.development?
-      c.skip_paths << "/assets/"
+      c.skip_paths << app.config.assets.prefix if app.respond_to? :assets
       c.skip_schema_queries = true
     end
 
-    if Rails.env.production?
+    unless Rails.env.development? || Rails.env.test?
       c.authorization_mode = :whitelist
     end
 
+    if Rails.logger
+      c.logger = Rails.logger
+    end
+
     # The file store is just so much less flaky
-    tmp = Rails.root.to_s + "/tmp/miniprofiler"
+    base_path = Rails.application.config.paths['tmp'].first rescue "#{Rails.root}/tmp"
+    tmp       = base_path + '/miniprofiler'
     FileUtils.mkdir_p(tmp) unless File.exists?(tmp)
 
     c.storage_options = {:path => tmp}
@@ -32,14 +43,20 @@ module Rack::MiniProfilerRails
     # 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 != 'production'
+    c.skip_schema_queries = (Rails.env.development? || Rails.env.test?)
 
     # Install the Middleware
     app.middleware.insert(0, Rack::MiniProfiler)
 
     # Attach to various Rails methods
-    ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) {|action| "Executing action: #{action}"}
-    ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) {|x,y| "Rendering: #{@virtual_path}"}
+    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
+    
+    @already_initialized = true
   end
 
   class Railtie < ::Rails::Railtie

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