devver-rack-contrib 0.9.4 → 0.9.5

data/lib/rack/contrib/perftools_profiler.rb

@@ -1,5 +1,6 @@
 require 'perftools'
 require 'rbconfig'
+require 'pstore'
 
 # You'll need graphviz to generate call graphs using dot:
 #
@@ -9,8 +10,137 @@ require 'rbconfig'
 # You'll need ps2pdf to generate PDFs (comes with ghostscript)
 # sudo port install ghostscript
 
+# There are two modes for the profiler
+# 
+# First, you can run in 'simple' mode. Just visit the url you want to profile, but
+# add the 'profile' and (optionally) the 'times' GET params
+# 
+# example: 
+# curl http://localhost:8080/foobar?profile=true&times=3
+#
+# Note that this will change the status, body, and headers of the response (you'll get
+# back the profiling data, NOT the original response.
+#
+#
+# The other mode is start/stop mode.
+# 
+# example:
+# curl http://localhost:8080/__start__
+# curl http://localhost:8080/foobar
+# curl http://localhost:8080/foobaz
+# curl http://localhost:8080/__stop__
+# curl http://localhost:8080/__data__
+#
+# 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__
+
+
 module Rack
 
+  class Action
+
+    DEFAULT_PRINTER = :text
+
+    PRINTER_CONTENT_TYPE = {
+      :text => 'text/plain',
+      :gif => 'image/gif',
+      :pdf => 'application/pdf'
+    }
+
+    def initialize(request, profiler)
+      @request = request
+      @profiler = profiler
+    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
+    end
+
+  end
+
+  class StartProfiling < Action
+
+    def act
+      @profiler.start
+    end
+
+    def response
+      Response.new("Profiling is enabled\n", 200, {'Content-Type' => 'text/plain'}).finish
+    end
+
+  end
+
+  class StopProfiling < Action
+       
+    def act
+      @profiler.stop
+    end
+
+    def response
+      Response.new("Profiling is disabled\n", 200, {'Content-Type' => 'text/plain'}).finish
+    end
+
+  end
+
+  class ProfileOnce < Action
+
+    def self.has_special_param?(request)
+      request.params['profile'] != nil
+    end
+
+    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)
+    end
+
+    def response
+      @profiler.return_profiling_data(@request.params, @printer)
+    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
+
+    def reponse
+    end
+
+  end
+
   # Pass the :printer option to pick a different result format.
   class PerftoolsProfiler
     MODES = %w(
@@ -18,8 +148,8 @@ module Rack
       #wall_time
     )
 
+    PROFILING_DATA_FILE = '/tmp/rack_perftools_profiler.data'
     DEFAULT_PRINTER = :text
-    #DEFAULT_CONTENT_TYPE = 'application/octet-stream'
 
     PRINTER_CONTENT_TYPE = {
       :text => 'text/plain',
@@ -27,93 +157,174 @@ module Rack
       :pdf => 'application/pdf'
     }
 
-    # Accepts a :printer => [:call_tree|:graph_html|:graph|:flat] option
-    # defaulting to :call_tree.
+    def self.clear_data
+      ::File.delete(PROFILING_DATA_FILE) if ::File.exists?(PROFILING_DATA_FILE)
+    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
+    end
+
     def call(env)
-      if mode = profiling?(env)
-        profile(env, mode)
+      @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
-        @app.call(env)
+        if mode = profiling?(env.clone)
+          action = Action.for_request(@original_request, self)
+          action.act
+          action.response
+        else
+          @app.call(env)
+        end
       end
     end
 
-    private
-      def profiling?(env)
-        unless PerfTools::CpuProfiler.running?
-          request = Rack::Request.new(env)
-          if mode = request.params.delete('profile')
-            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 start
+      start_profiling
+    end
+
+    def stop
+      stop_profiling
+    end
+
+    def profile_call(env, times)
+      PerfTools::CpuProfiler.start(PROFILING_DATA_FILE) do 
+        times.times { result = @app.call(env) }
       end
+    end
 
-      def profile(env, mode)
-        #RubyProf.measure_mode = RubyProf.const_get(mode.upcase)
+    def return_profiling_data(env, printer)
+      if ::File.exists?(PROFILING_DATA_FILE)
+        [200, headers(printer, env), print(printer)]
+      else
+        [404, {'Content-Type' => 'text/plain'}, 'No profiling data available.']
+      end
+    end
 
-        #GC.enable_stats if GC.respond_to?(:enable_stats)
-        #result = RubyProf.profile do
-        temp_file = "/tmp/perftools_file"
-        PerfTools::CpuProfiler.start(temp_file) do 
-          @times.times { @app.call(env) }
-        end
-        #end
-        #GC.disable_stats if GC.respond_to?(:disable_stats)
+    private
+
+    def start_profiling
+      PerfTools::CpuProfiler.start(PROFILING_DATA_FILE)
+      self.profiling = true
+    end
 
-        [200, headers(@printer, env, mode), print(@printer, temp_file)]
+    def stop_profiling
+      PerfTools::CpuProfiler.stop
+      self.profiling = false
+    end
+    
+    def profiling=(value)
+      pstore_transaction(false) do |store|
+        store[:profiling?] = value
       end
+    end
 
-      def print(printer, temp_file)
-        cmd = "pprof.rb --#{printer} #{temp_file}"
-        `#{cmd}`
-        #body = StringIO.new
-        #printer.new(result).print(body, :min_percent => 0.01)
-        #body.rewind
-        #body
+    def pstore_transaction(read_only)
+      pstore = PStore.new('/tmp/rack_perftools_profiler.config')
+      pstore.transaction(read_only) do
+        yield pstore if block_given?
       end
+    end
 
-      def headers(printer, env, mode)
-        headers = { 'Content-Type' => PRINTER_CONTENT_TYPE[printer] || DEFAULT_CONTENT_TYPE }
-        if printer==:pdf
-          filetype = printer
-          filename='profile'
-          headers['Content-Disposition'] = %(attachment; filename="#{filename}.#{mode}.#{filetype}")
-        end
-        headers
+    def in_profiling_mode?
+      pstore_transaction(true) do |store|
+        store[:profiling?]
       end
+    end
+    
+    def enable_profiling_request?
+      @original_request.path == '/__start__'
+    end
 
-      def parse_printer(printer)
-        if printer.nil?
-          DEFAULT_PRINTER
-        else
-          printer.to_sym
+    def disable_profiling_request?
+      @original_request.path == '/__stop__'
+    end
+
+    def profiling_data_request?
+      @original_request.path == '/__data__'
+    end
+
+    def simple_profiling_mode?(env)
+      request = Rack::Request.new(env)
+      request.params.delete('profile') != nil
+    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
-        #elsif printer.is_a?(Class)
-        #  printer
-        #else
-        #  name = "#{camel_case(printer)}Printer"
-        #  if RubyProf.const_defined?(name)
-        #    RubyProf.const_get(name)
-        #  else
-        #    DEFAULT_PRINTER
-        #  end
-        #end
       end
+    end
 
-      def camel_case(word)
-        word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+    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)
+      else
+        result
+      end
+    end
+
+    def print(printer)
+      cmd = "pprof.rb --#{printer} #{PROFILING_DATA_FILE}"
+      `#{cmd}`
+    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}")
+      end
+      headers
+    end
+
+    def parse_printer(printer)
+      if printer.nil?
+        DEFAULT_PRINTER
+      else
+        printer.to_sym
+      end
+    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.4'
+  s.version = '0.9.5'
   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
-  - 4
-  version: 0.9.4
+  - 5
+  version: 0.9.5
 platform: ruby
 authors: 
 - rack-devel