rack-mini-profiler 0.1.1 → 0.1.8

data/lib/mini_profiler/sql_timer_struct.rb

@@ -5,7 +5,7 @@ module Rack
 
     # Timing system for a SQL query
     class SqlTimerStruct < TimerStruct
-      def initialize(query, duration_ms, page, skip_backtrace = false)
+      def initialize(query, duration_ms, page, parent, skip_backtrace = false, full_backtrace = false)
 
         stack_trace = nil 
         unless skip_backtrace 
@@ -13,24 +13,35 @@ module Rack
           stack_trace = ""
            # Clean up the stack trace if there are options to do so
           Kernel.caller.each do |ln|
-            ln.gsub!(Rack::MiniProfiler.configuration[:backtrace_remove], '') if Rack::MiniProfiler.configuration[:backtrace_remove]
-            if Rack::MiniProfiler.configuration[:backtrace_filter].nil? or ln =~ Rack::MiniProfiler.configuration[:backtrace_filter]
+            ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove and !full_backtrace
+            if full_backtrace or Rack::MiniProfiler.config.backtrace_filter.nil? or ln =~ Rack::MiniProfiler.config.backtrace_filter
               stack_trace << ln << "\n" 
             end
           end
         end
 
+        @parent = parent
+        @page = page
+
         super("ExecuteType" => 3, # TODO
               "FormattedCommandString" => query,
               "StackTraceSnippet" => stack_trace, 
-              "StartMilliseconds" => (Time.now.to_f * 1000).to_i - page['Started'],
+              "StartMilliseconds" => ((Time.now.to_f * 1000).to_i - page['Started']) - duration_ms,
               "DurationMilliseconds" => duration_ms,
-              "FirstFetchDurationMilliseconds" => 0,
+              "FirstFetchDurationMilliseconds" => duration_ms,
               "Parameters" => nil,
               "ParentTimingId" => nil,
               "IsDuplicate" => false)
       end
 
+      def report_reader_duration(elapsed_ms)
+        return if @reported
+        @reported = true
+        self["DurationMilliseconds"] += elapsed_ms
+        @parent["SqlTimingsDurationMilliseconds"] += elapsed_ms
+        @page["DurationMillisecondsInSql"] += elapsed_ms
+      end
+
     end
 
   end

data/lib/mini_profiler/storage/file_store.rb

@@ -39,9 +39,14 @@ module Rack
 
         me = self
         Thread.new do
-          while true do
-            me.cleanup_cache if MiniProfiler.instance
-            sleep(3600)
+          begin 
+            while true do
+              # TODO: a sane retry count before bailing
+              me.cleanup_cache
+              sleep(3600)
+            end
+          rescue
+            # don't crash the thread, we can clean up next time 
           end
         end
       end
@@ -83,10 +88,6 @@ module Rack
         }
       end
       
-
-      private 
-
-
       def cleanup_cache
         files = Dir.entries(@path)
         @timer_struct_lock.synchronize {

data/lib/mini_profiler/storage/memory_store.rb

@@ -52,10 +52,6 @@ module Rack
         }
       end
       
-
-      private 
-
-
       def cleanup_cache
         expire_older_than = ((Time.now.to_f - MiniProfiler::MemoryStore::EXPIRE_TIMER_CACHE) * 1000).to_i
         @timer_struct_lock.synchronize {

data/lib/mini_profiler_rails/railtie.rb

@@ -1,33 +1,84 @@
+require 'fileutils'
+
 module MiniProfilerRails
+
   class Railtie < ::Rails::Railtie
 
     initializer "rack_mini_profiler.configure_rails_initialization" do |app|
+      c = Rack::MiniProfiler.config
 
-      # By default, only show the MiniProfiler in development mode
-      Rack::MiniProfiler.configuration[:authorize_cb] = lambda { |env|
-        Rails.env.development? && !(env['PATH_INFO'] =~ /^\/assets\//)
+      # By default, only show the MiniProfiler in development mode, in production allow profiling if post_authorize_cb is set
+      c.pre_authorize_cb = lambda { |env|
+        Rails.env.development? || Rails.env.production?  
       }
 
+      if Rails.env.development?
+        c.skip_paths ||= []
+        c.skip_paths << "/assets/"
+        c.skip_schema_queries = true
+      end
+
+      if Rails.env.production? 
+        c.authorization_mode = :whitelist
+      end
+
       # The file store is just so much less flaky
       tmp = Rails.root.to_s + "/tmp/miniprofiler"
-      Dir::mkdir(tmp) unless File.exists?(tmp)
-      
-      Rack::MiniProfiler.configuration[:storage_options] = {:path => tmp}
-      Rack::MiniProfiler.configuration[:storage] = Rack::MiniProfiler::FileStore
+      FileUtils.mkdir_p(tmp) unless File.exists?(tmp)
+
+      c.storage_options = {:path => tmp}
+      c.storage = Rack::MiniProfiler::FileStore
 
       # Quiet the SQL stack traces
-      Rack::MiniProfiler.configuration[:backtrace_remove] = Rails.root.to_s + "/"
-      Rack::MiniProfiler.configuration[:backtrace_filter] =  /^\/?(app|config|lib|test)/
+      c.backtrace_remove = Rails.root.to_s + "/"
+      c.backtrace_filter =  /^\/?(app|config|lib|test)/
+      c.skip_schema_queries =  Rails.env != 'production'
 
       # Install the Middleware
-      app.middleware.insert_before 'Rack::Lock', 'Rack::MiniProfiler'
+      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}"}
 
-
     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/lib/patches/sql_patches.rb

@@ -1,17 +1,136 @@
-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
+
+# 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
 
-if SqlPatches.class_exists? "Sequel::Database" then
+
+# 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
+
+    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 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 +139,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)
+        def log_with_miniprofiler(*args, &block)
+          current = ::Rack::MiniProfiler.current
+          return log_without_miniprofiler(*args, &block) unless current
 
-        # Get our MP Instance
-        instance = ::Rack::MiniProfiler.instance
-        return rval unless instance
+          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/
 
-        # Don't log schema queries if the option is set
-        return rval if instance.options[: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__) )
+  require 'mini_profiler_rails/railtie'
 end

data/rack-mini-profiler.gemspec

@@ -1,9 +1,8 @@
 Gem::Specification.new do |s|
 	s.name = "rack-mini-profiler"
-	s.version = "0.1.1"
+	s.version = "0.1.8"
 	s.summary = "Profiles loading speed for rack applications."
 	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.email = "sam.saffron@gmail.com"
 	s.homepage = "http://miniprofiler.com"
@@ -12,11 +11,11 @@ Gem::Specification.new do |s|
 	].concat( Dir.glob('lib/**/*').reject {|f| File.directory?(f) || f =~ /~$/ } )
 	s.extra_rdoc_files = [
 		"README.md",
-    "CHANGELOG.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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.8
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-02 00:00:00.000000000 Z
+date: 2012-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -84,14 +84,16 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
-- CHANGELOG.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/context.rb
+- lib/mini_profiler/config.rb
+- lib/mini_profiler/profiling_methods.rb
 - lib/mini_profiler/client_timer_struct.rb
 - lib/mini_profiler/profiler.rb
 - lib/mini_profiler/storage/memory_store.rb
@@ -104,7 +106,6 @@ files:
 - 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
@@ -114,7 +115,7 @@ files:
 - lib/mini_profiler_rails/railtie.rb
 - lib/patches/sql_patches.rb
 - README.md
-- CHANGELOG.md
+- CHANGELOG
 homepage: http://miniprofiler.com
 licenses: []
 post_install_message: 
@@ -129,7 +130,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -779964803
+      hash: -902573215
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -138,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -779964803
+      hash: -902573215
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/CHANGELOG.md

@@ -1,7 +0,0 @@
-28-June-2012 - Sam  
- 
-  * Started change log
-  * Corrected profiler so it properly captures POST requests (was supressing non 200s)
-  * Amended Rack.MiniProfiler.config[:user_provider] to use ip addres for identity 
-  * Fixed bug where unviewed missing ids never got cleared
-  * Supress all '/assets/' in the rails tie (makes debugging easier)