devver-rack-contrib 0.9.5 → 0.9.6

data/lib/rack/contrib/perftools_profiler.rb

@@ -1,14 +1,39 @@
+require 'rack'
 require 'perftools'
 require 'rbconfig'
 require 'pstore'
 
-# You'll need graphviz to generate call graphs using dot:
+# REQUIREMENTS
+
+# You'll need graphviz to generate call graphs using dot (for the GIF printer):
 #
 #    sudo port install graphviz     # osx
 #    sudo apt-get install graphviz  # debian/ubuntu
 
-# You'll need ps2pdf to generate PDFs (comes with ghostscript)
-# sudo port install ghostscript
+# You'll need ps2pdf to generate PDFs 
+# On OS X, ps2pdf comes is installed as part of Ghostscript
+# 
+#    sudo port install ghostscript # osx
+#    brew install ghostscript      # homebrew
+#    sudo apt-get install ps2pdf   # debian/ubuntu
+
+# USAGE
+
+# To configure your Rack app to use PerftoolsProfiler, call the 'use' method
+#
+#    use Rack::PerftoolsProfiler, options
+# 
+# For example:
+#    use Rack::PerftoolsProfiler, :default_printer => 'gif'
+
+# OPTIONS
+
+# :default_printer - can be set to 'text', 'gif', or 'pdf'. Default is :text
+# :mode            - can be set to 'cputime' or 'walltime'. Default is :cputime
+# :frequency       - in :cputime mode, the number of times per second the app will be sampled.
+#                    Default is 100 (times/sec)
+
+# MODES 
 
 # There are two modes for the profiler
 # 
@@ -34,208 +59,165 @@ require 'pstore'
 # In this mode, all responses are normal. You must visit __stop__ to complete profiling and
 # then you can view the profiling data by visiting __data__
 
+# PROFILING DATA OPTIONS
+#
+# In both simple and start/stop modes, you can add additional params to change how the data
+# is displayed. In simple mode, these params are just added to the URL being profiled. In
+# start/stop mode, they are added to the __data__ URL
 
-module Rack
+# printer - overrides the default_printer option (see above)
+# ignore  - a regular expression of the area of code to ignore 
+# focus   - a regular expression of the area of code to solely focus on.
 
-  class Action
+# (for ignore and focus, please see http://google-perftools.googlecode.com/svn/trunk/doc/cpuprofile.html#pprof
+# for more details)
 
-    DEFAULT_PRINTER = :text
+module Rack
+
+  class PerftoolsProfiler
+    include Rack::Utils
 
     PRINTER_CONTENT_TYPE = {
       :text => 'text/plain',
       :gif => 'image/gif',
       :pdf => 'application/pdf'
     }
-
-    def initialize(request, profiler)
-      @request = request
-      @profiler = profiler
+    
+    def self.clear_data
+      Profiler.clear_data
     end
 
-    def self.for_request(request, profiler)
-      return ProfileOnce.new(request, profiler) if ProfileOnce.has_special_param?(request)
-      case request.path
-      when '/__start__'
-        StartProfiling.new(request, profiler)
-      when '/__stop__'
-        StopProfiling.new(request, profiler)
-      when '/__data__'
-        ReturnData.new(request, profiler)
-      else
-        CallAppDirectly.new(request, profiler)
-      end
+    def self.with_profiling_off(app, options = {})
+      instance = self.new(app, options)
+      instance.force_stop
+      instance
     end
 
-  end
-
-  class StartProfiling < Action
-
-    def act
-      @profiler.start
+    def initialize(app, options = {})
+      @app = app
+      @profiler = Profiler.new(@app, options)
     end
-
-    def response
-      Response.new("Profiling is enabled\n", 200, {'Content-Type' => 'text/plain'}).finish
+    
+    def call(env)
+      action = Action.for_env(env.clone, @profiler, self)
+      action.act
+      action.response
     end
 
-  end
+    def call_app(env)
+      @app.call(env)
+    end
 
-  class StopProfiling < Action
-       
-    def act
+    def force_stop
       @profiler.stop
     end
 
-    def response
-      Response.new("Profiling is disabled\n", 200, {'Content-Type' => 'text/plain'}).finish
+    def profiler_data_response(profiling_data)
+      format, body = profiling_data
+      if format==:none
+        [404, {'Content-Type' => 'text/plain'}, ['No profiling data available.']] 
+      else
+        [200, headers(format, body), Array(body)]
+       end
     end
 
-  end
-
-  class ProfileOnce < Action
-
-    def self.has_special_param?(request)
-      request.params['profile'] != nil
-    end
+    private
 
-    def initialize(request, profiler)
-      super
-      @times = (request.params.fetch('times') {1}).to_i
-      @printer = parse_printer(profiler.printer)
-      @env = delete_custom_params(request.params)
-    end
-    
-    def act
-      @profiler.profile_call(@env, @times)
+    def headers(printer, body)
+      headers = { 
+        'Content-Type' => PRINTER_CONTENT_TYPE[printer],
+        'Content-Length' => content_length(body)
+      }
+      if printer==:pdf
+        filetype = printer
+        filename='profile_data'
+        headers['Content-Disposition'] = %(attachment; filename="#{filename}.#{filetype}")
+      end
+      headers
     end
 
-    def response
-      @profiler.return_profiling_data(@request.params, @printer)
+    def content_length(body)
+      body.inject(0) { |len, part| len + bytesize(part) }.to_s
     end
 
-    def delete_custom_params(env)
-      env.delete('profile')
-      env.delete('times')
-      env.delete('printer')
-      env
-    end
 
-    def parse_printer(printer)
-      if printer.nil?
-        DEFAULT_PRINTER
-      else
-        printer.to_sym
-      end
-    end
-    
   end
 
-  class CallAppDirectly < Action
-    
-    def act
-      @result = @profiler.call_without_profile
-    end
+  class Profiler
 
-    def reponse
+    def self.tmpdir
+      dir = nil
+      Dir.chdir Dir.tmpdir do dir = Dir.pwd end # HACK FOR OSX
+      dir
     end
 
-  end
-
-  # Pass the :printer option to pick a different result format.
-  class PerftoolsProfiler
-    MODES = %w(
-      process_time
-      #wall_time
-    )
-
-    PROFILING_DATA_FILE = '/tmp/rack_perftools_profiler.data'
+    PROFILING_DATA_FILE = ::File.join(self.tmpdir, 'rack_perftools_profiler.prof')
+    PROFILING_SETTINGS_FILE = ::File.join(self.tmpdir, 'rack_perftools_profiler.config')
     DEFAULT_PRINTER = :text
+    DEFAULT_MODE = :cputime
+    UNSET_FREQUENCY = -1
 
-    PRINTER_CONTENT_TYPE = {
-      :text => 'text/plain',
-      :gif => 'image/gif',
-      :pdf => 'application/pdf'
-    }
-
-    def self.clear_data
-      ::File.delete(PROFILING_DATA_FILE) if ::File.exists?(PROFILING_DATA_FILE)
+    def initialize(app, options)
+      @printer   = (options.delete(:default_printer) { DEFAULT_PRINTER }).to_sym
+      @frequency = (options.delete(:frequency) { UNSET_FREQUENCY }).to_s
+      @mode      = (options.delete(:mode) { DEFAULT_MODE }).to_sym
+      raise ArgumentError, "Invalid option(s): #{options.keys.join(' ')}" unless options.empty?
     end
-
-    def self.with_profiling_off(app, options = {})
-      instance = self.new(app, options)
-      instance.send(:profiling=, false)
-      instance
-    end
-
-    def initialize(app, options = {})
-      @app = app
-      @printer = parse_printer(options[:printer])
-      @times = (options[:times] || 1).to_i
-    end
-
-    def printer
-      @printer
+    
+    def profile
+      start
+      yield
+    ensure
+      stop
     end
 
-    def call(env)
-      @original_request = Request.new(env)
-      if enable_profiling_request?
-        action = Action.for_request(@original_request, self)
-        action.act
-        action.response
-      elsif disable_profiling_request?
-        action = Action.for_request(@original_request, self)
-        action.act
-        action.response
-      elsif profiling_data_request?
-        if in_profiling_mode?
-          [400, {'Content-Type' => 'text/plain'}, 'No profiling data available.']
-        else
-          return_profiling_data(env, @printer)
-        end
-      else
-        if mode = profiling?(env.clone)
-          action = Action.for_request(@original_request, self)
-          action.act
-          action.response
-        else
-          @app.call(env)
-        end
-      end
+    def self.clear_data
+      ::File.delete(PROFILING_DATA_FILE) if ::File.exists?(PROFILING_DATA_FILE)
     end
 
     def start
-      start_profiling
+      set_env_vars
+      PerfTools::CpuProfiler.start(PROFILING_DATA_FILE)
+      self.profiling = true
     end
 
     def stop
-      stop_profiling
+      PerfTools::CpuProfiler.stop
+      self.profiling = false
+      unset_env_vars
     end
 
-    def profile_call(env, times)
-      PerfTools::CpuProfiler.start(PROFILING_DATA_FILE) do 
-        times.times { result = @app.call(env) }
+    def profiling?
+      pstore_transaction(true) do |store|
+        store[:profiling?]
       end
     end
 
-    def return_profiling_data(env, printer)
+    def data(options = {})
+      printer = (options.fetch('printer') {@printer}).to_sym
+      ignore = options.fetch('ignore') { nil }
+      focus = options.fetch('focus') { nil }
       if ::File.exists?(PROFILING_DATA_FILE)
-        [200, headers(printer, env), print(printer)]
+        args = "--#{printer}"
+        args += " --ignore=#{ignore}" if ignore
+        args += " --focus=#{focus}" if focus
+        cmd = "pprof.rb #{args} #{PROFILING_DATA_FILE}"
+        [printer, `#{cmd}`]
       else
-        [404, {'Content-Type' => 'text/plain'}, 'No profiling data available.']
+        [:none, nil]
       end
     end
 
-    private
+    private 
 
-    def start_profiling
-      PerfTools::CpuProfiler.start(PROFILING_DATA_FILE)
-      self.profiling = true
+    def set_env_vars
+      ENV['CPUPROFILE_REALTIME'] = '1' if @mode == :walltime
+      ENV['CPUPROFILE_FREQUENCY'] = @frequency if @frequency != UNSET_FREQUENCY
     end
 
-    def stop_profiling
-      PerfTools::CpuProfiler.stop
-      self.profiling = false
+    def unset_env_vars
+      ENV.delete('CPUPROFILE_REALTIME')
+      ENV.delete('CPUPROFILE_FREQUENCY')
     end
     
     def profiling=(value)
@@ -245,86 +227,149 @@ module Rack
     end
 
     def pstore_transaction(read_only)
-      pstore = PStore.new('/tmp/rack_perftools_profiler.config')
+      pstore = PStore.new(PROFILING_SETTINGS_FILE)
       pstore.transaction(read_only) do
         yield pstore if block_given?
       end
     end
 
-    def in_profiling_mode?
-      pstore_transaction(true) do |store|
-        store[:profiling?]
-      end
+  end
+
+  class Action
+
+    def initialize(env, profiler, middleware)
+      @env = env
+      @request = Request.new(env)
+      @data_params = @request.params.clone
+      @profiler = profiler
+      @middleware = middleware
     end
     
-    def enable_profiling_request?
-      @original_request.path == '/__start__'
+    def act
+      # do nothing
+    end
+
+    def self.for_env(env, profiler, middleware)
+      request = Request.new(env)
+      klass = 
+        case request.path
+        when '/__start__'
+          StartProfiling
+        when '/__stop__'
+          StopProfiling
+        when '/__data__'
+          ReturnData
+        else
+          if ProfileOnce.has_special_param?(request)
+            ProfileOnce
+          else
+            CallAppDirectly
+          end
+        end
+      klass.new(env, profiler, middleware)
     end
 
-    def disable_profiling_request?
-      @original_request.path == '/__stop__'
+  end
+
+  class StartProfiling < Action
+
+    def act
+      @profiler.start
     end
 
-    def profiling_data_request?
-      @original_request.path == '/__data__'
+    def response
+      [200, {'Content-Type' => 'text/plain'}, 
+       [<<-EOS
+Profiling is now enabled.
+Visit the URLS that should be profiled.
+When you are finished, visit /__stop__, then visit /__data__ to view the results.
+EOS
+       ]]
     end
 
-    def simple_profiling_mode?(env)
-      request = Rack::Request.new(env)
-      request.params.delete('profile') != nil
+  end
+
+  class StopProfiling < Action
+    
+    def act
+      @profiler.stop
     end
 
-    def profiling?(env)
-      unless PerfTools::CpuProfiler.running?
-        request = Rack::Request.new(env)
-        @profiling = request.params.delete('profile')
-        if @profiling #|| get_profiling
-          true
-          #if RubyProf.const_defined?(mode.upcase)
-          #  mode
-          #else
-          #env['rack.errors'].write "Invalid RubyProf measure_mode: " +
-          #  "#{mode}. Use one of #{MODES.to_a.join(', ')}"
-          #  false
-          #end
-        end
-      end
+    def response
+      [200, {'Content-Type' => 'text/html'}, 
+       [<<-EOS
+Profiling is now disabled.
+Visit /__data__ to view the results.
+EOS
+       ]]
     end
 
-    def profile(env, mode)
-      result = nil
-      PerfTools::CpuProfiler.start(PROFILING_DATA_FILE) do 
-        @times.times { result = @app.call(env) }
-      end
-      if @profiling
-        return_profiling_data(env, @printer)
+  end
+
+  class ReturnData < Action
+
+    def response
+      if @profiler.profiling?
+        [400, {'Content-Type' => 'text/plain'}, ['No profiling data available.']]
       else
-        result
+        @middleware.profiler_data_response(@profiler.data(@data_params))
       end
     end
 
-    def print(printer)
-      cmd = "pprof.rb --#{printer} #{PROFILING_DATA_FILE}"
-      `#{cmd}`
+  end
+
+  class ProfileOnce < Action
+    include Rack::Utils
+
+    def self.has_special_param?(request)
+      request.params['profile'] != nil
     end
 
-    def headers(printer, env)
-      headers = { 'Content-Type' => PRINTER_CONTENT_TYPE[printer] }
-      if printer==:pdf
-        filetype = printer
-        filename='profile_data'
-        headers['Content-Disposition'] = %(attachment; filename="#{filename}.#{filetype}")
+    def initialize(*args)
+      super
+      @times = (Request.new(@env).params.fetch('times') {1}).to_i
+      @new_env = delete_custom_params(@env)
+    end
+    
+    def act
+      @profiler.profile do
+        @times.times { @middleware.call_app(@new_env) }
       end
-      headers
     end
 
-    def parse_printer(printer)
-      if printer.nil?
-        DEFAULT_PRINTER
-      else
-        printer.to_sym
-      end
+    def response
+      @middleware.profiler_data_response(@profiler.data(@data_params))
+    end
+
+    def delete_custom_params(env)
+      new_env = env.clone
+      
+      params = Request.new(new_env).params
+      params.delete('profile')
+      params.delete('times')
+      params.delete('printer')
+      params.delete('ignore')
+      params.delete('focus')
+
+      new_env.delete('rack.request.query_string')
+      new_env.delete('rack.request.query_hash')
+
+      new_env['QUERY_STRING'] = build_query(params)
+      new_env
     end
 
   end
+
+  class CallAppDirectly < Action
+    
+    def act
+      @result = @middleware.call_app(@env)
+    end
+
+    def response
+      @result
+    end
+
+  end
+
 end

data/rack-contrib.gemspec

@@ -3,7 +3,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'devver-rack-contrib'
-  s.version = '0.9.5'
+  s.version = '0.9.6'
   s.date = '2010-01-10'
 
   s.description = "The Devver fork of rack-contrib"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 5
-  version: 0.9.5
+  - 6
+  version: 0.9.6
 platform: ruby
 authors: 
 - rack-devel