miniprofiler 0.1.7.1

data/.gitignore

@@ -0,0 +1,4 @@
+lib/html
+pkg/
+tmp/
+*.gem

data/CHANGELOG

@@ -0,0 +1,32 @@
+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)
+  * record_sql was mega buggy
+
+9-July-2012 - Sam 
+
+  * Cleaned up mechanism for profiling in production, all you need to do now
+	is call Rack::MiniProfiler.authorize_request to get profiling working in
+	production 
+	* Added option to display full backtraces pp=full-backtrace
+	* Cleaned up railties, got rid of the post authorize callback
+	* Version 0.1.3
+
+12-July-2012 - Sam 
+
+  * Fixed incorrect profiling steps (was not indenting or measuring start time right
+	* Implemented native PG and MySql2 interceptors, this gives way more accurate times
+	* Refactored context so its a proper class and not a hash 
+	* Added some more client probing built in to rails
+	* More tests
+
+18-July-2012 - Sam 
+  
+  * Added First Paint time for chrome
+  * Bug fix to ensure non Rails installs have mini profiler
+  * Version 0.1.7
+

data/Gemfile

@@ -0,0 +1,15 @@
+source 'http://rubygems.org'
+
+gemspec
+
+gem 'therubyracer', :require => 'v8'
+gem 'less'
+
+group :test do
+  gem 'rake'
+  gem 'rack'
+  gem 'rspec'
+  gem 'ZenTest'
+  gem 'autotest'
+  gem 'redis'
+end

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    miniprofiler (0.1.7.1)
+      rack (>= 1.1.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.8.1)
+    activemodel (3.2.6)
+      activesupport (= 3.2.6)
+      builder (~> 3.0.0)
+    activerecord (3.2.6)
+      activemodel (= 3.2.6)
+      activesupport (= 3.2.6)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.6)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    autotest (4.4.6)
+      ZenTest (>= 4.4.1)
+    builder (3.0.0)
+    commonjs (0.2.6)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    less (2.2.1)
+      commonjs (~> 0.2.6)
+    libv8 (3.3.10.4)
+    multi_json (1.3.6)
+    rack (1.4.1)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rake (0.9.2.2)
+    redis (3.0.1)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.0)
+    rspec-expectations (2.11.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+    therubyracer (0.10.1)
+      libv8 (~> 3.3.10)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ZenTest
+  activerecord (~> 3.0)
+  autotest
+  less
+  miniprofiler!
+  rack
+  rack-test
+  rake
+  redis
+  rspec
+  therubyracer

data/README.md

@@ -0,0 +1,110 @@
+# NOTE FOR THIS GEM FORK
+
+This is a fork the Ruby folder of https://github.com/SamSaffron/MiniProfiler which includes some quick fixes to make the original rack-mini-profiler gem a little more usable. I will consolidate any useful changes here into pull requests for the original repo.
+
+* Add `gem 'miniprofiler'` to your Gemfile (install of 'rack-mini-profiler')
+* `miniprofiler`'s version uses `x.y.z.t` syntax in order to more easily sync with `rack-mini-profiler`'s `x.y.z` SemVer versioning. I will increase `t` whenever I make a patch
+* This gem fork will work in staging, not just development and production
+* Gem release date will be correct (as of now 'rack-mini-profiler' hardcodes the release date to be 04/02/2012, which is very confusing: https://rubygems.org/gems/rack-mini-profiler -- I will report to them)
+* Allow turning off loading jquery if the app already uses jquery
+* More to come
+
+# Original README below:
+
+# rack-mini-profiler
+
+Middleware that displays speed badge for every html page. Designed to work both in production and in development.
+
+## Using rack-mini-profiler in your app
+
+Install/add to Gemfile
+
+```ruby
+gem 'rack-mini-profiler'
+```
+Using Rails:
+
+All you have to do is include the Gem and you're good to go in development.
+
+rack-mini-profiler is designed with production profiling in mind. To enable that just run `Rack::MiniProfiler.authorize_request` once you know a request is allowed to profile.
+
+For example:
+
+```ruby
+# A hook in your ApplicationController
+def authorize
+  if current_user.is_admin?
+    Rack::MiniProfiler.authorize_request
+  end
+end
+````
+
+
+Using Builder:
+
+```ruby
+require 'rack-mini-profiler'
+builder = Rack::Builder.new do
+  use Rack::MiniProfiler
+
+  map('/')    { run get }
+end
+```
+
+Using Sinatra:
+
+```ruby
+require 'rack-mini-profiler'
+class MyApp < Sinatra::Base
+  use Rack::MiniProfiler
+end
+```
+
+## Storage
+
+By default, rack-mini-profiler stores its results in a memory store:
+
+```ruby
+# our default
+Rack::MiniProfiler.config.storage = Rack::MiniProfiler::MemoryStore
+```
+
+There are 2 other available storage engines, `RedisStore` and `FileStore`.
+
+MemoryStore is stores results in a processes heap - something that does not work well in a multi process environment.
+FileStore stores results in the file system - something that may not work well in a multi machine environment.
+
+Additionally you may implement an AbstractStore for your own provider.
+
+Rails hooks up a FileStore for all environments.
+
+## Running the Specs
+
+```
+$ rake build
+$ rake spec
+```
+
+Additionally you can also run `autotest` if you like.
+
+## Configuration Options
+
+You can set configuration options using the configuration accessor on Rack::MiniProfiler:
+
+```
+# Have Mini Profiler show up on the 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
+
+* 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.
+* 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 'false', 'true' in rails development.
+
+## Special query strings
+
+If you include the query string `pp=help` at the end of your request you will see the various option you have. You can use these options to extend or contract the amount of diagnostics rack-mini-profiler gathers.
+

data/Rakefile

@@ -0,0 +1,40 @@
+# Rakefile
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+require "bundler/gem_tasks"
+
+task :default => [:spec]
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "builds a gem"
+task :build => :compile_less do
+	`gem build rack-mini-profiler.gemspec 1>&2`
+end
+
+desc "compile less"
+task :compile_less => :copy_files do
+  `lessc lib/html/includes.less > lib/html/includes.css`
+end
+
+
+desc "copy files from other parts of the tree"
+task :copy_files do
+	`rm -R -f lib/html && mkdir lib/html 1>&2`
+  path = File.expand_path('../StackExchange.Profiling/UI')
+  `ln -s #{path}/includes.less lib/html/includes.less`
+  `ln -s #{path}/includes.js lib/html/includes.js`
+  `ln -s #{path}/includes.tmpl lib/html/includes.tmpl`
+  `ln -s #{path}/jquery.1.7.1.js lib/html/jquery.1.7.1.js`
+  `ln -s #{path}/jquery.tmpl.js lib/html/jquery.tmpl.js`
+  `ln -s #{path}/list.css lib/html/list.css`
+  `ln -s #{path}/list.js lib/html/list.js`
+  `ln -s #{path}/list.tmpl lib/html/list.tmpl`
+  `ln -s #{path}/include.partial.html lib/html/profile_handler.js`
+end
+

data/autotest/discover.rb

@@ -0,0 +1,2 @@
+Autotest.add_discovery { "rspec2" }
+

data/lib/mini_profiler/body_add_proxy.rb

@@ -0,0 +1,45 @@
+module Rack
+  class MiniProfiler
+
+    # This class acts as a proxy to the Body so that we can
+    # safely append to the end without knowing about the internals
+    # of the body class.    
+    class BodyAddProxy
+      def initialize(body, additional_text)
+        @body = body
+        @additional_text = additional_text
+      end
+
+      def respond_to?(*args)
+        super or @body.respond_to?(*args)
+      end
+
+      def method_missing(*args, &block)
+        @body.__send__(*args, &block)
+      end
+
+      # In the case of to_str we don't want to use method_missing as it might avoid
+      # a call to each (such as in Rack::Test)
+      def to_str
+        result = ""
+        each {|token| result << token}
+        result
+      end
+
+      def each(&block)
+
+        # In ruby 1.9 we don't support String#each
+        if @body.is_a?(String)
+          yield @body
+        else
+          @body.each(&block)
+        end
+
+        yield @additional_text
+        self
+      end
+
+    end
+
+  end
+end

data/lib/mini_profiler/client_timer_struct.rb

@@ -0,0 +1,76 @@
+require 'mini_profiler/timer_struct'
+
+module Rack
+  class MiniProfiler
+
+    # This class holds the client timings
+    class ClientTimerStruct < TimerStruct
+
+      def self.init_instrumentation
+        "<script type=\"text/javascript\">mPt=function(){var t=[];return{t:t,probe:function(n){t.push({d:new Date(),n:n})}}}()</script>"
+      end
+      
+      def self.instrument(name,orig)
+        probe = "<script>mPt.probe('#{name}')</script>"
+        wrapped = probe
+        wrapped << orig 
+        wrapped << probe 
+        wrapped
+      end
+
+
+      def initialize(env={})
+        super
+      end
+
+      def init_from_form_data(env, page_struct)
+        timings = []
+        clientTimes, clientPerf, baseTime = nil 
+        form = env['rack.request.form_hash']
+
+        clientPerf = form['clientPerformance'] if form 
+        clientTimes = clientPerf['timing'] if clientPerf 
+
+        baseTime = clientTimes['navigationStart'].to_i if clientTimes
+        return unless clientTimes && baseTime 
+
+        probes = form['clientProbes']
+        translated = {}
+        if probes && probes != "null"
+          probes.each do |id, val|
+            name = val["n"]
+            translated[name] ||= {} 
+            if translated[name][:start]
+              translated[name][:finish] = val["d"]
+            else 
+              translated[name][:start] = val["d"]
+            end
+          end
+        end
+
+        translated.each do |name, data|
+          h = {"Name" => name, "Start" => data[:start].to_i - baseTime}
+          h["Duration"] = data[:finish].to_i - data[:start].to_i if data[:finish]
+          timings.push(h)
+        end
+
+        clientTimes.keys.find_all{|k| k =~ /Start$/ }.each do |k|
+          start = clientTimes[k].to_i - baseTime 
+          finish = clientTimes[k.sub(/Start$/, "End")].to_i - baseTime
+          duration = 0 
+          duration = finish - start if finish > start 
+          name = k.sub(/Start$/, "").split(/(?=[A-Z])/).map{|s| s.capitalize}.join(' ')
+          timings.push({"Name" => name, "Start" => start, "Duration" => duration}) if start >= 0
+        end
+
+        clientTimes.keys.find_all{|k| !(k =~ /(End|Start)$/)}.each do |k|
+          timings.push("Name" => k, "Start" => clientTimes[k].to_i - baseTime, "Duration" => -1)
+        end
+
+        self['RedirectCount'] = env['rack.request.form_hash']['clientPerformance']['navigation']['redirectCount']
+        self['Timings'] = timings
+      end
+    end
+
+  end
+end

data/lib/mini_profiler/config.rb

@@ -0,0 +1,52 @@
+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, :position,
+        :backtrace_remove, :backtrace_filter, :skip_schema_queries, 
+        :storage, :user_provider, :storage_instance, :storage_options, :skip_paths, :authorization_mode, :use_existing_jquery
+      
+      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
+          @position = 'left'  # Where it is displayed
+          @skip_schema_queries = false
+          @storage = MiniProfiler::MemoryStore
+          @user_provider = Proc.new{|env| Rack::Request.new(env).ip}
+          @authorization_mode = :allow_all
+          @use_existing_jquery = false
+          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/context.rb

@@ -0,0 +1,10 @@
+class Rack::MiniProfiler::Context
+  attr_accessor :inject_js,:current_timer,:page_struct,:skip_backtrace,:full_backtrace,:discard, :mpt_init
+  
+  def initialize(opts = {})
+    opts.each do |k,v|
+      self.instance_variable_set('@' + k, v)
+    end
+  end
+
+end

data/lib/mini_profiler/page_timer_struct.rb

@@ -0,0 +1,53 @@
+require 'mini_profiler/timer_struct'
+
+module Rack
+  class MiniProfiler
+
+    # PageTimerStruct
+    #   Root: RequestTimer
+    #     :has_many RequestTimer children
+    #     :has_many SqlTimer children
+    class PageTimerStruct < TimerStruct
+      def initialize(env)
+        super("Id" => MiniProfiler.generate_id,
+              "Name" => env['PATH_INFO'],
+              "Started" => (Time.now.to_f * 1000).to_i,
+              "MachineName" => env['SERVER_NAME'],
+              "Level" => 0,
+              "User" => "unknown user",
+              "HasUserViewed" => false,
+              "ClientTimings" => ClientTimerStruct.new,
+              "DurationMilliseconds" => 0,
+              "HasTrivialTimings" => true,
+              "HasAllTrivialTimigs" => false,
+              "TrivialDurationThresholdMilliseconds" => 2,
+              "Head" => nil,
+              "DurationMillisecondsInSql" => 0,
+              "HasSqlTimings" => true,
+              "HasDuplicateSqlTimings" => false,
+              "ExecutedReaders" => 0,
+              "ExecutedScalars" => 0,
+              "ExecutedNonQueries" => 0)
+        name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+        self['Root'] = RequestTimerStruct.createRoot(name, self)
+      end
+
+      def duration_ms
+        @attributes['Root']['DurationMilliseconds']
+      end
+
+      def root
+        @attributes['Root']
+      end
+      
+      def to_json(*a)
+        attribs = @attributes.merge(
+          "Started" => '/Date(%d)/' % @attributes['Started'], 
+          "DurationMilliseconds" => @attributes['Root']['DurationMilliseconds']
+        )        
+        ::JSON.generate(attribs, :max_nesting => 100)
+      end
+    end
+    
+  end
+end