rack-mini-profiler 0.1 → 0.1.21

data/lib/patches/sql_patches.rb

@@ -1,17 +1,182 @@
-module SqlPatches
+class SqlPatches
+
+  def self.patched?
+    @patched
+  end
+
+  def self.patched=(val)
+    @patched = val
+  end
+
 	def self.class_exists?(name)
 		eval(name + ".class").to_s.eql?('Class')
 	rescue NameError
 		false
 	end
+	
+  def self.module_exists?(name)
+		eval(name + ".class").to_s.eql?('Module')
+	rescue NameError
+		false
+	end
 end
 
-if SqlPatches.class_exists? "Sequel::Database" then
+# 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
+  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
+
+      start = Time.now
+      result = query_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(args[0], elapsed_time))
+
+      result
+
+    end
+  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
+
+      prepare_without_profiling(*args,&blk) 
+    end
+
+    def exec(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return exec_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = exec_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(args[0], elapsed_time))
+
+      result
+    end
+
+    def exec_prepared(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return exec_prepared_without_profiling(*args,&blk) unless current
+
+      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
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(mapped, elapsed_time))
+
+      result
+    end
+    
+    def send_query_prepared(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return send_query_prepared_without_profiling(*args,&blk) unless current
+
+      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
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(mapped, elapsed_time))
+
+      result
+    end
+    
+    def async_exec(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return exec_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = exec_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(args[0], elapsed_time))
+
+      result
+    end
+    
+    alias_method :query, :exec
+  end
+    
+  SqlPatches.patched = true
+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)
-				::Rack::MiniProfiler.instance.record_sql(message, duration) if ::Rack::MiniProfiler.instance
+				::Rack::MiniProfiler.record_sql(message, duration)
 				log_duration_original(duration, message)
 			end
 		end
@@ -20,53 +185,47 @@ end
 
 
 ## based off https://github.com/newrelic/rpm/blob/master/lib/new_relic/agent/instrumentation/active_record.rb
-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
+## fallback for alls sorts of weird dbs
+if SqlPatches.module_exists?('ActiveRecord')
+  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
-      end
-
-      def log_with_miniprofiler(*args, &block)
-        sql, name, binds = args
-        t0 = Time.now
-        rval = log_without_miniprofiler(*args, &block)
 
-        # Get our MP Instance
-        instance = ::Rack::MiniProfiler.instance
-        return rval unless instance
+        def log_with_miniprofiler(*args, &block)
+          current = ::Rack::MiniProfiler.current
+          return log_without_miniprofiler(*args, &block) unless current
 
-        # Don't log schema queries if the option is set
-        return rval if instance.options[:skip_schema_queries] and name =~ /SCHEMA/
+          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)
-        instance.record_sql(sql, elapsed_time)
-        rval
+          elapsed_time = ((Time.now - t0).to_f * 1000).round(1)
+          Rack::MiniProfiler.record_sql(sql, elapsed_time)
+          rval
+        end
       end
     end
-  end
 
-  def self.insert_instrumentation 
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-      include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+    def self.insert_instrumentation 
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+        include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+      end
     end
-  end
 
-  if defined?(::Rails)
-    if ::Rails::VERSION::MAJOR.to_i == 3
-    # in theory this is the right thing to do for rails 3 ... but it seems to work anyway
-    #Rails.configuration.after_initialize do
-        insert_instrumentation
-    #end
-    else
+    if defined?(::Rails) && !SqlPatches.patched?
       insert_instrumentation
     end
   end
 end
-

data/lib/rack-mini-profiler.rb

@@ -1,6 +1,6 @@
-require File.expand_path('mini_profiler/profiler', File.dirname(__FILE__) )
-require File.expand_path('patches/sql_patches', File.dirname(__FILE__) )
+require 'mini_profiler/profiler'
+require 'patches/sql_patches'
 
-if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
-  require File.expand_path('mini_profiler_rails/railtie', File.dirname(__FILE__) )
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= 3
+  require 'mini_profiler_rails/railtie'
 end

data/rack-mini-profiler.gemspec

@@ -1,21 +1,21 @@
 Gem::Specification.new do |s|
 	s.name = "rack-mini-profiler"
-	s.version = "0.1"
-	s.summary = "Profiles loading speed for html pages."
-	s.authors = ["Aleks Totic","Sam Saffron", "Robin Ward"]
-	s.date = "2012-04-02"
-	s.description = "Page loading speed displayed on every page. Optimize while you develop, performance is a feature."
+	s.version = "0.1.21"
+	s.summary = "Profiles loading speed for rack applications."
+	s.authors = ["Sam Saffron", "Robin Ward","Aleks Totic"]
+	s.description = "Profiling toolkit for Rack applications with Rails integration. Client Side profiling, DB profiling and Server profiling."
 	s.email = "sam.saffron@gmail.com"
 	s.homepage = "http://miniprofiler.com"
 	s.files = [
 		'rack-mini-profiler.gemspec',
 	].concat( Dir.glob('lib/**/*').reject {|f| File.directory?(f) || f =~ /~$/ } )
 	s.extra_rdoc_files = [
-		"README.md"
+		"README.md",
+    "CHANGELOG"
 	]
-	s.add_runtime_dependency 'rack', '>= 1.1.3' 
+	s.add_runtime_dependency 'rack', '>= 1.1.3'
   if RUBY_VERSION < "1.9"
-    s.add_runtime_dependency 'json', '>= 1.6' 
+    s.add_runtime_dependency 'json', '>= 1.6'
   end
 
   s.add_development_dependency 'rake'

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.1.21
   prerelease: 
 platform: ruby
 authors:
-- Aleks Totic
 - Sam Saffron
 - Robin Ward
+- Aleks Totic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-02 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -77,33 +77,38 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Page loading speed displayed on every page. Optimize while you develop,
-  performance is a feature.
+description: Profiling toolkit for Rack applications with Rails integration. Client
+  Side profiling, DB profiling and Server profiling.
 email: sam.saffron@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
+- CHANGELOG
 files:
 - rack-mini-profiler.gemspec
 - lib/mini_profiler/sql_timer_struct.rb
 - lib/mini_profiler/request_timer_struct.rb
 - lib/mini_profiler/timer_struct.rb
 - lib/mini_profiler/page_timer_struct.rb
-- lib/mini_profiler/body_add_proxy.rb
+- lib/mini_profiler/client_settings.rb
+- lib/mini_profiler/context.rb
+- lib/mini_profiler/config.rb
+- lib/mini_profiler/profiling_methods.rb
+- lib/mini_profiler/gc_profiler.rb
 - lib/mini_profiler/client_timer_struct.rb
 - lib/mini_profiler/profiler.rb
 - lib/mini_profiler/storage/memory_store.rb
 - lib/mini_profiler/storage/file_store.rb
 - lib/mini_profiler/storage/redis_store.rb
 - lib/mini_profiler/storage/abstract_store.rb
+- lib/mini_profiler/storage/memcache_store.rb
 - lib/rack-mini-profiler.rb
 - lib/html/jquery.1.7.1.js
 - lib/html/includes.tmpl
 - lib/html/share.html
 - lib/html/includes.less
 - lib/html/list.css
-- lib/html/MiniProfilerHandler.cs
 - lib/html/includes.js
 - lib/html/jquery.tmpl.js
 - lib/html/list.tmpl
@@ -113,6 +118,7 @@ files:
 - lib/mini_profiler_rails/railtie.rb
 - lib/patches/sql_patches.rb
 - README.md
+- CHANGELOG
 homepage: http://miniprofiler.com
 licenses: []
 post_install_message: 
@@ -127,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1062659085
+      hash: -668836557
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -136,11 +142,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1062659085
+      hash: -668836557
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Profiles loading speed for html pages.
+summary: Profiles loading speed for rack applications.
 test_files: []