rack-mini-profiler 0.9.4 → 0.9.9

data/lib/mini_profiler/profiling_methods.rb

@@ -3,9 +3,9 @@ module Rack
     module ProfilingMethods
 
       def record_sql(query, elapsed_ms)
-        return unless current
+        return unless current && current.current_timer
         c = current
-        c.current_timer.add_sql(query, elapsed_ms, c.page_struct, c.skip_backtrace, c.full_backtrace) if (c && c.current_timer)
+        c.current_timer.add_sql(query, elapsed_ms, c.page_struct, c.skip_backtrace, c.full_backtrace)
       end
 
       def start_step(name)
@@ -26,10 +26,9 @@ module Rack
       def step(name, opts = nil)
         if current
           parent_timer          = current.current_timer
-          result                = nil
           current.current_timer = current_timer = current.current_timer.add_child(name)
           begin
-            result = yield if block_given?
+            yield if block_given?
           ensure
             current_timer.record_time
             current.current_timer = parent_timer
@@ -87,34 +86,37 @@ module Rack
               end
           end
 
-          result = nil
           parent_timer = Rack::MiniProfiler.current.current_timer
 
           if type == :counter
             start = Time.now
             begin
-              result = self.send without_profiling, *args, &orig
+              self.send without_profiling, *args, &orig
             ensure
               duration_ms = (Time.now - start).to_f * 1000
               parent_timer.add_custom(name, duration_ms, Rack::MiniProfiler.current.page_struct )
             end
           else
-            page_struct = Rack::MiniProfiler.current.page_struct
-
             Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name)
             begin
-              result = self.send without_profiling, *args, &orig
+              self.send without_profiling, *args, &orig
             ensure
               current_timer.record_time
               Rack::MiniProfiler.current.current_timer = parent_timer
             end
           end
-
-          result
         end
         klass.send :alias_method, method, with_profiling
       end
 
+      def profile_singleton_method(klass, method, type = :profile, &blk)
+        profile_method(singleton_class(klass), method, type, &blk)
+      end
+
+      def unprofile_singleton_method(klass, method)
+        unprofile_method(singleton_class(klass), method)
+      end
+
       # Add a custom timing. These are displayed similar to SQL/query time in
       # columns expanding to the right.
       #
@@ -140,6 +142,10 @@ module Rack
 
       private
 
+      def singleton_class(klass)
+        class << klass; self; end
+      end
+
       def clean_method_name(method)
         method.to_s.gsub(/[\?\!]/, "")
       end

data/lib/mini_profiler/storage/file_store.rb

@@ -26,8 +26,14 @@ module Rack
         end
 
         private
-        def path(key)
-          @path + "/" + @prefix  + "_" + key
+        if RUBY_PLATFORM =~ /mswin(?!ce)|mingw|cygwin|bccwin/
+          def path(key)
+            @path + "/" + @prefix  + "_" + key.gsub(/:/, '_')
+          end
+        else
+          def path(key)
+            @path + "/" + @prefix  + "_" + key
+          end
         end
       end
 
@@ -38,6 +44,8 @@ module Rack
         @path = args[:path]
         @expires_in_seconds = args[:expires_in] || EXPIRES_IN_SECONDS
         raise ArgumentError.new :path unless @path
+        FileUtils.mkdir_p(@path) unless ::File.exists?(@path)
+
         @timer_struct_cache = FileCache.new(@path, "mp_timers")
         @timer_struct_lock  = Mutex.new
         @user_view_cache    = FileCache.new(@path, "mp_views")

data/lib/mini_profiler/timer_struct/page.rb

@@ -40,10 +40,18 @@ module Rack
           self[:root] = TimerStruct::Request.createRoot(name, self)
         end
 
+        def name
+          @attributes[:name]
+        end
+
         def duration_ms
           @attributes[:root][:duration_milliseconds]
         end
 
+        def duration_ms_in_sql
+          @attributes[:duration_milliseconds_in_sql]
+        end
+
         def root
           @attributes[:root]
         end

data/lib/mini_profiler/timer_struct/request.rb

@@ -44,10 +44,18 @@ module Rack
           @page              = page
         end
 
+        def name
+          @attributes[:name]
+        end
+
         def duration_ms
           self[:duration_milliseconds]
         end
 
+        def duration_ms_in_sql
+          @attributes[:duration_milliseconds_in_sql]
+        end
+
         def start_ms
           self[:start_milliseconds]
         end

data/lib/mini_profiler/timer_struct/sql.rb

@@ -17,11 +17,11 @@ module Rack
                     (
                       (
                         Rack::MiniProfiler.config.backtrace_includes.nil? or
-                        Rack::MiniProfiler.config.backtrace_includes.all?{|regex| ln =~ regex}
+                        Rack::MiniProfiler.config.backtrace_includes.any?{|regex| ln =~ regex}
                       ) and
                       (
                         Rack::MiniProfiler.config.backtrace_ignores.nil? or
-                        Rack::MiniProfiler.config.backtrace_ignores.all?{|regex| !(ln =~ regex)}
+                        Rack::MiniProfiler.config.backtrace_ignores.none?{|regex| ln =~ regex}
                       )
                     )
                 stack_trace << ln << "\n"

data/lib/mini_profiler/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class MiniProfiler
-    VERSION = '0.9.4'
+    VERSION = '0.9.9'
   end
 end

data/lib/mini_profiler_rails/railtie.rb

@@ -4,9 +4,9 @@ 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.
@@ -24,8 +24,11 @@ module Rack::MiniProfilerRails
 
     c.skip_paths ||= []
 
+    if serves_static_assets?(app)
+      c.skip_paths << app.config.assets.prefix
+    end
+
     if Rails.env.development?
-      c.skip_paths << app.config.assets.prefix if app.respond_to? :assets
       c.skip_schema_queries = true
     end
 
@@ -40,7 +43,6 @@ module Rack::MiniProfilerRails
     # The file store is just so much less flaky
     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}
     c.storage = Rack::MiniProfiler::FileStore
@@ -60,10 +62,26 @@ module Rack::MiniProfilerRails
     ActiveSupport.on_load(:action_view) do
       ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) {|x,y| "Rendering: #{@virtual_path}"}
     end
-    
+
     @already_initialized = true
   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|

data/lib/patches/db/activerecord.rb

@@ -21,6 +21,8 @@ module Rack
         rval             = log_without_miniprofiler(*args, &block)
 
         # Don't log schema queries if the option is set
+#        return rval unless sql =~ /\"vms\"/
+#        return rval unless sql =~ /\"(vms|ext_management_systems)\"/
         return rval if Rack::MiniProfiler.config.skip_schema_queries and name =~ /SCHEMA/
 
         elapsed_time = SqlPatches.elapsed_time(start)

data/lib/patches/db/mongo.rb

@@ -0,0 +1,16 @@
+# 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
+    return 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/lib/patches/db/neo4j.rb

@@ -0,0 +1,14 @@
+class Neo4j::Core::Query
+  alias_method :response_without_miniprofiler, :response
+
+  def response
+    return @response if @response
+    start = Time.now
+    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/lib/patches/db/nobrainer.rb

@@ -0,0 +1,29 @@
+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 = ""
+
+      # 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.gsub(/\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/lib/patches/db/oracle_enhanced.rb

@@ -0,0 +1,70 @@
+class ActiveRecord::Result
+  alias_method :each_without_profiling, :each
+  def each(&blk)
+    return each_without_profiling(&blk) unless @miniprofiler_sql_id
+
+    start        = Time.now
+    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        = Time.now
+    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
+
+SqlPatches.patched = true

data/lib/patches/db/riak.rb

@@ -0,0 +1,103 @@
+# riak-client 2.2.2 patches
+class Riak::Multiget
+  class <<self
+    alias_method :get_all_without_profiling, :get_all
+    def get_all(client, fetch_list)
+      return get_all_without_profiling(client, fetch_list) unless SqlPatches.should_measure?
+
+      start        = Time.now
+      result       = get_all_without_profiling(client, fetch_list)
+      elapsed_time = SqlPatches.elapsed_time(start)
+      record       = ::Rack::MiniProfiler.record_sql("get_all size=#{fetch_list.size}", elapsed_time)
+
+      result
+    end
+  end
+end
+
+class Riak::Client
+
+  alias_method :buckets_without_profiling, :buckets
+  def buckets(options={}, &blk)
+    profile("buckets #{options}") { buckets_without_profiling(options, &blk) }
+  end
+
+  alias_method :client_id_without_profiling, :client_id
+  def client_id
+    profile("client_id") { client_id_without_profiling }
+  end
+
+  alias_method :delete_object_without_profiling, :delete_object
+  def delete_object(bucket, key, options={})
+    profile("delete_object bucket=#{bucket.name} key=#{key} options=#{options}") { delete_object_without_profiling(bucket, key, options) }
+  end
+
+  alias_method :get_bucket_props_without_profiling, :get_bucket_props
+  def get_bucket_props(bucket, options={})
+    profile("get_bucket_props bucket=#{bucket.name} options=#{options}") { get_bucket_props_without_profiling(bucket, options) }
+  end
+
+  alias_method :get_index_without_profiling, :get_index
+  def get_index(bucket, index, query, options={})
+    profile("get_index bucket=#{bucket.name} index=#{index} query=#{query} options=#{options}") { get_index_without_profiling(bucket, index, query, options) }
+  end
+
+  alias_method :get_preflist_without_profiling, :get_preflist
+  def get_preflist(bucket, key, type=nil, options={})
+    profile("get_preflist bucket=#{bucket.name} key=#{key} type=#{type} options=#{options}") { get_preflist_without_profiling(bucket, key, type, options) }
+  end
+
+  alias_method :get_object_without_profiling, :get_object
+  def get_object(bucket, key, options={})
+    profile("get_object bucket=#{bucket.name} key=#{key} options=#{options}") { get_object_without_profiling(bucket, key, options) }
+  end
+
+  alias_method :list_keys_without_profiling, :list_keys
+  def list_keys(bucket, options={}, &block)
+    profile("list_keys bucket=#{bucket.name} options=#{options}") { list_keys_without_profiling(bucket, options, &block) }
+  end
+
+  alias_method :mapred_without_profiling, :mapred
+  def mapred(mr, &block)
+    profile("mapred") { mapred_without_profiling(mr, &block) }
+  end
+
+  alias_method :ping_without_profiling, :ping
+  def ping
+    profile("ping") { ping_without_profiling }
+  end
+
+  alias_method :reload_object_without_profiling, :reload_object
+  def reload_object(object, options={})
+    profile("reload_object bucket=#{object.bucket.name} key=#{object.key} vclock=#{object.vclock} options=#{options}") { reload_object_without_profiling(object, options) }
+  end
+
+  alias_method :set_bucket_props_without_profiling, :set_bucket_props
+  def set_bucket_props(bucket, properties, type=nil)
+    profile("set_bucket_props bucket=#{bucket.name} type=#{type}") { set_bucket_props_without_profiling(bucket, properties, type) }
+  end
+
+  alias_method :clear_bucket_props_without_profiling, :clear_bucket_props
+  def clear_bucket_props(bucket, options={})
+    profile("clear_bucket_props bucket=#{bucket.name} options=#{options}") { clear_bucket_props_without_profiling(bucket, options) }
+  end
+
+  alias_method :store_object_without_profiling, :store_object
+  def store_object(object, options={})
+    profile("store_object bucket=#{object.bucket.name} key=#{object.key} vclock=#{object.vclock} options=#{options}") { store_object_without_profiling(object, options) }
+  end
+
+  private
+
+  def profile(request, &blk)
+    return yield unless SqlPatches.should_measure?
+
+    start        = Time.now
+    result       = yield
+    elapsed_time = SqlPatches.elapsed_time(start)
+    record       = ::Rack::MiniProfiler.record_sql(request, elapsed_time)
+
+    result
+  end
+
+end