rack-mini-profiler 0.1.1 → 0.1.2

data/CHANGELOG.md

@@ -5,3 +5,4 @@
   * 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)
+  * record_sql was mega buggy

data/README.md

@@ -1,13 +1,6 @@
 # rack-mini-profiler
 
-Middleware that displays speed badge for every html page.
-
-## What does it do
-
-MiniProfiler keeps you aware of your site's performance as you are developing it.
-It does this by....
-
-`env['profiler.mini']` is the profiler 
+Middleware that displays speed badge for every html page. Designed to work both in production and in development.
 
 ## Using mini-profiler in your app
 
@@ -16,12 +9,9 @@ Install/add to Gemfile
 ```ruby
 gem 'rack-mini-profiler'
 ```
-
-Add it to your middleware stack:
-
 Using Rails:
 
-All you have to do is include the Gem and you're good to go.
+All you have to do is include the Gem and you're good to go in development.
 
 Using Builder:
 
@@ -58,15 +48,17 @@ You can set configuration options using the configuration accessor on Rack::Mini
 
 ```
 # Have Mini Profiler show up on the right
-Rack::MiniProfiler.configuration[:position] = 'right'
+Rack::MiniProfiler.config.position = 'right'
 ```
 
 In a Rails app, this can be done conveniently in an initializer such as config/initializers/mini_profiler.rb.
 
 ## Available Options
 
-* authorize_cb - A lambda callback you can set to determine whether or not mini_profiler should be visible on a given request. Default in a Rails environment is only on in development mode. If in a Rack app, the default is always on.
+* pre_authorize_cb - A lambda callback you can set to determine whether or not mini_profiler should be visible on a given request. Default in a Rails environment is only on in development mode. If in a Rack app, the default is always on.
+* post_authorize_cb - A lambda that is called after your request executed to ensure you really have access to the results. 
 * position - Can either be 'right' or 'left'. Default is 'left'.
-* skip_schema_queries - Whether or not you want to log the queries about the schema of your tables. Default is 'true'
+* skip_schema_queries - Whether or not you want to log the queries about the schema of your tables. Default is 'false', 'true' in rails development.
+
 
 

data/lib/html/includes.js

@@ -475,6 +475,18 @@ var MiniProfiler = (function ($) {
             })();
         }
 
+        // also fetch results after ExtJS requests, in case it is being used
+        if (typeof (Ext) != 'undefined' && typeof (Ext.Ajax) != 'undefined' && typeof (Ext.Ajax.on) != 'undefined') {
+            // Ext.Ajax is a singleton, so we just have to attach to its 'requestcomplete' event
+            Ext.Ajax.on('requestcomplete', function(e, xhr, settings) {
+                var stringIds = xhr.getResponseHeader('X-MiniProfiler-Ids');
+                if (stringIds) {
+                    var ids = typeof JSON != 'undefined' ? JSON.parse(stringIds) : eval(stringIds);
+                    fetchResults(ids);
+                }
+            });
+        }
+
         // some elements want to be hidden on certain doc events
         bindDocumentEvents();
     };

data/lib/mini_profiler/config.rb

@@ -0,0 +1,51 @@
+module Rack
+  class MiniProfiler
+    class Config
+
+    def self.attr_accessor(*vars)
+      @attributes ||= []
+      @attributes.concat vars
+      super(*vars)
+    end
+    
+    def self.attributes
+      @attributes
+    end
+
+    attr_accessor :auto_inject, :base_url_path, :pre_authorize_cb, :post_authorize_cb, :position,
+        :backtrace_remove, :backtrace_filter, :skip_schema_queries, 
+        :storage, :user_provider, :storage_instance, :storage_options, :skip_paths
+      
+      def self.default
+        new.instance_eval {
+          @auto_inject = true # automatically inject on every html page
+          @base_url_path = "/mini-profiler-resources/"
+          
+          # called prior to rack chain, to ensure we are allowed to profile
+          @pre_authorize_cb = lambda {|env| true} 
+                                                  
+          # called after rack chain, to ensure we are REALLY allowed to profile
+          @post_authorize_cb = nil
+          @position = 'left'  # Where it is displayed
+          @skip_schema_queries = false
+          @storage = MiniProfiler::MemoryStore
+          @user_provider = Proc.new{|env| Rack::Request.new(env).ip}
+          self
+        }
+      end
+
+      def merge!(config)
+        return unless config
+        if Hash === config 
+          config.each{|k,v| instance_variable_set "@#{k}",v}
+        else 
+          self.class.attributes.each{ |k|  
+            v = config.send k
+            instance_variable_set "@#{k}", v if v
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/mini_profiler/profiler.rb

@@ -11,6 +11,7 @@ require 'mini_profiler/storage/abstract_store'
 require 'mini_profiler/storage/memory_store'
 require 'mini_profiler/storage/redis_store'
 require 'mini_profiler/storage/file_store'
+require 'mini_profiler/config'
 
 module Rack
 
@@ -27,28 +28,13 @@ module Rack
 			rand(36**20).to_s(36)
 		end
 
-    # Defaults for MiniProfiler's configuration
-    def self.configuration_defaults
-      {
-        :auto_inject => true, # automatically inject on every html page
-        :base_url_path => "/mini-profiler-resources/",
-        :authorize_cb => lambda {|env| true}, # callback returns true if this request is authorized to profile
-        :position => 'left',  # Where it is displayed
-        :backtrace_remove => nil,
-        :backtrace_filter => nil,
-        :skip_schema_queries => true,
-        :storage => MiniProfiler::MemoryStore,
-        :user_provider => Proc.new{|env| Rack::Request.new(env).ip }
-      }
-    end
-
-    def self.reset_configuration
-      @configuration = configuration_defaults
+    def self.reset_config
+      @config = Config.default
     end
 
     # So we can change the configuration if we want
-    def self.configuration
-      @configuration ||= configuration_defaults.dup
+    def self.config
+      @config ||= Config.default
     end
 
     def self.share_template
@@ -59,19 +45,19 @@ module Rack
 		#
 		# options:
 		# :auto_inject - should script be automatically injected on every html page (not xhr)
-		def initialize(app, opts={})
+		def initialize(app, config = nil)
 			@@instance = self
-      MiniProfiler.configuration.merge!(opts)
-      @options = MiniProfiler.configuration 
+      MiniProfiler.config.merge!(config)
+      @config = MiniProfiler.config 
 			@app = app
-			@options[:base_url_path] << "/" unless @options[:base_url_path].end_with? "/"
-      unless @options[:storage_instance]
-        @storage = @options[:storage_instance] = @options[:storage].new(@options[:storage_options])
+			@config.base_url_path << "/" unless @config.base_url_path.end_with? "/"
+      unless @config.storage_instance
+        @storage = @config.storage_instance = @config.storage.new(@config.storage_options)
       end
 		end
     
     def user(env)
-      options[:user_provider].call(env)
+      @config.user_provider.call(env)
     end
 
 		def serve_results(env)
@@ -97,7 +83,7 @@ module Rack
 
         # Otherwise give the HTML back
         html = MiniProfiler.share_template.dup  
-        html.gsub!(/\{path\}/, @options[:base_url_path])      
+        html.gsub!(/\{path\}/, @config.base_url_path)      
         html.gsub!(/\{version\}/, MiniProfiler::VERSION)      
         html.gsub!(/\{json\}/, result_json)
         html.gsub!(/\{includes\}/, get_profile_script(env))
@@ -110,7 +96,7 @@ module Rack
 		end
 
 		def serve_html(env)
-			file_name = env['PATH_INFO'][(@options[:base_url_path].length)..1000]
+			file_name = env['PATH_INFO'][(@config.base_url_path.length)..1000]
 			return serve_results(env) if file_name.eql?('results')
 			full_path = ::File.expand_path("../html/#{file_name}", ::File.dirname(__FILE__))
 			return [404, {}, ["Not found"]] unless ::File.exists? full_path
@@ -128,7 +114,23 @@ module Rack
       # we use TLS cause we need access to this from sql blocks and code blocks that have no access to env
  			Thread.current['profiler.mini.private'] = c
     end
-   
+
+    def self.discard_results
+      current[:discard] = true if current
+    end
+ 
+    def self.has_profiling_cookie?(env)
+      env['HTTP_COOKIE'] && env['HTTP_COOKIE'].include?("__profilin=stylin")
+    end
+
+    def self.remove_profiling_cookie(headers)
+      Rack::Utils.delete_cookie_header!(headers, '__profilin')
+    end
+
+    def self.set_profiling_cookie(headers)
+      Rack::Utils.set_cookie_header!(headers, '__profilin', 'stylin')
+    end
+
     def current
       MiniProfiler.current
     end
@@ -137,34 +139,45 @@ module Rack
       MiniProfiler.current=c
     end
 
-    def options
-      @options
+    def config
+      @config
     end
 
     def self.create_current(env={}, options={})
       # profiling the request
       self.current = {}
-      self.current['inject_js'] = options[:auto_inject] && (!env['HTTP_X_REQUESTED_WITH'].eql? 'XMLHttpRequest')
+      self.current['inject_js'] = config.auto_inject && (!env['HTTP_X_REQUESTED_WITH'].eql? 'XMLHttpRequest')
       self.current['page_struct'] = PageTimerStruct.new(env)
       self.current['current_timer'] = current['page_struct']['Root']
     end
 
+
 		def call(env)
 			status = headers = body = nil
 
+      path = env['PATH_INFO']
 			# only profile if authorized
-			return @app.call(env) unless @options[:authorize_cb].call(env)
+			if  !@config.pre_authorize_cb.call(env) ||
+          (@config.skip_paths && @config.skip_paths.any?{ |p| path[0,p.length] == p}) ||
+          env["QUERY_STRING"] =~ /pp=skip/
+
+        status,headers,body = @app.call(env)
+        if @config.post_authorize_cb 
+          if @config.post_authorize_cb.call(env) 
+            self.class.set_profiling_cookie(headers)
+          end
+        end
+        return [status,headers,body]
+      end
 
-			# handle all /mini-profiler requests here
-			return serve_html(env) if env['PATH_INFO'].start_with? @options[:base_url_path]
+      # handle all /mini-profiler requests here
+			return serve_html(env) if env['PATH_INFO'].start_with? @config.base_url_path
 
-      MiniProfiler.create_current(env, @options)
-      if env["QUERY_STRING"] =~ /pp=skip-backtrace/
+      MiniProfiler.create_current(env, @config)
+      if env["QUERY_STRING"] =~ /pp=no-backtrace/
         current['skip-backtrace'] = true
       end
-
-      start = Time.now 
-
+      
       done_sampling = false
       quit_sampler = false
       backtraces = nil
@@ -172,10 +185,16 @@ module Rack
         backtraces = []
         t = Thread.current
         Thread.new {
+          require 'stacktrace'
+          if !t.respond_to? :stacktrace
+            quit_sampler = true 
+            return
+          end
           i = 10000 # for sanity never grab more than 10k samples 
-          unless done_sampling || i < 0
+          while i > 0
+            break if done_sampling
             i -= 1
-            backtraces << t.backtrace
+            backtraces << t.stacktrace
             sleep 0.001
           end
           quit_sampler = true
@@ -183,8 +202,9 @@ module Rack
       end
 
 			status, headers, body = nil
+      start = Time.now 
       begin 
-        status,headers, body = @app.call(env)
+        status,headers,body = @app.call(env)
       ensure
         if backtraces 
           done_sampling = true
@@ -192,9 +212,34 @@ module Rack
         end
       end
 
+      skip_it = current['discard']
+      if @config.post_authorize_cb && !@config.post_authorize_cb.call(env)
+        self.class.remove_profiling_cookie(headers)
+        skip_it = true
+      end
+
+      return [status,headers,body] if skip_it
+      
+      # we must do this here, otherwise current['discard'] is not being properly treated
+      if env["QUERY_STRING"] =~ /pp=env/
+        body.close if body.respond_to? :close
+        return dump_env env
+      end
+
+      if env["QUERY_STRING"] =~ /pp=help/
+        body.close if body.respond_to? :close
+        return help
+      end
+      
       page_struct = current['page_struct']
 			page_struct['Root'].record_time((Time.now - start) * 1000)
 
+      if backtraces
+        body.close if body.respond_to? :close
+        return analyze(backtraces, page_struct)
+      end
+      
+
       # no matter what it is, it should be unviewed, otherwise we will miss POST
       @storage.set_unviewed(user(env), page_struct['Id']) 
 			@storage.save(page_struct)
@@ -226,6 +271,41 @@ module Rack
       current = nil
 		end
 
+    def dump_env(env)
+      headers = {'Content-Type' => 'text/plain'}
+      body = "" 
+      env.each do |k,v|
+        body << "#{k}: #{v}\n"
+      end
+      [200, headers, [body]]
+    end
+
+    def help
+      headers = {'Content-Type' => 'text/plain'}
+      body = "Append the following to your query string:
+
+  pp=help : display this screen
+  pp=env : display the rack environment
+  pp=skip : skip mini profiler for this request
+  pp=no-backtrace : don't collect stack traces from all the SQL calls
+  pp=sample : sample stack traces and return a report isolating heavy usage (requires the stacktrace gem)
+"
+      #headers['Content-Length'] = body.length
+      [200, headers, [body]]
+    end
+
+    def analyze(traces, page_struct)
+      headers = {'Content-Type' => 'text/plain'}
+      body = "Collected: #{traces.count} stack traces. Duration(ms): #{page_struct.duration_ms}"
+      traces.each do |trace| 
+        body << "\n\n"
+        trace.each do |frame|
+          body << "#{frame.klass} #{frame.method}\n"
+        end
+      end
+      [200, headers, [body]]
+    end
+
     def ids_json(env)
       ids = [current['page_struct']["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])
       ::JSON.generate(ids.uniq)
@@ -239,9 +319,9 @@ module Rack
 		# * you do not want script to be automatically appended for the current page. You can also call cancel_auto_inject
 		def get_profile_script(env)
 			ids = ids_json(env)
-			path = @options[:base_url_path]
+			path = @config.base_url_path
 			version = MiniProfiler::VERSION
-			position = @options[:position]
+			position = @config.position
 			showTrivial = false
 			showChildren = false
 			maxTracesToShow = 10

data/lib/mini_profiler/sql_timer_struct.rb

@@ -13,8 +13,8 @@ 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
+            if Rack::MiniProfiler.config.backtrace_filter.nil? or ln =~ Rack::MiniProfiler.config.backtrace_filter
               stack_trace << ln << "\n" 
             end
           end
@@ -23,7 +23,7 @@ module Rack
         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,
               "Parameters" => nil,

data/lib/mini_profiler_rails/railtie.rb

@@ -2,22 +2,31 @@ 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? ||  
+        (Rack::MiniProfiler.config.post_authorize_cb && Rack::MiniProfiler.has_profiling_cookie?(env))
       }
 
+      if Rails.env.development?
+        c.skip_paths ||= []
+        c.skip_paths << "/assets/"
+        c.skip_schema_queries = true
+      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
+
+      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'

data/lib/patches/sql_patches.rb

@@ -43,7 +43,7 @@ module Rack
         return rval unless instance
 
         # Don't log schema queries if the option is set
-        return rval if instance.options[:skip_schema_queries] and name =~ /SCHEMA/
+        return rval if instance.config.skip_schema_queries and name =~ /SCHEMA/
 
         elapsed_time = ((Time.now - t0).to_f * 1000).round(1)
         instance.record_sql(sql, elapsed_time)
@@ -59,14 +59,7 @@ module Rack
   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
-      insert_instrumentation
-    end
+    insert_instrumentation
   end
 end
 

data/rack-mini-profiler.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
 	s.name = "rack-mini-profiler"
-	s.version = "0.1.1"
+	s.version = "0.1.2"
 	s.summary = "Profiles loading speed for rack applications."
 	s.authors = ["Aleks Totic","Sam Saffron", "Robin Ward"]
 	s.date = "2012-04-02"

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.2
   prerelease: 
 platform: ruby
 authors:
@@ -91,6 +91,7 @@ files:
 - lib/mini_profiler/request_timer_struct.rb
 - lib/mini_profiler/timer_struct.rb
 - lib/mini_profiler/page_timer_struct.rb
+- lib/mini_profiler/config.rb
 - lib/mini_profiler/body_add_proxy.rb
 - lib/mini_profiler/client_timer_struct.rb
 - lib/mini_profiler/profiler.rb
@@ -129,7 +130,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -779964803
+      hash: 876564877
 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: 876564877
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24