rack-perftools_profiler 0.3.0 → 0.4.0

data/README.rdoc

@@ -55,16 +55,16 @@ For Rack::Builder, call 'use' inside the Builder constructor block
 == Options
 
 * :default_printer - can be set to 'text', 'gif', or 'pdf'. Default is :text
-* :mode            - can be set to 'cputime', 'objects', 'walltime'. Default is :cputime. See the 'Profiling Modes' section below.
+* :mode            - can be set to 'cputime', 'methods', 'objects', 'walltime'. Default is :cputime. See the 'Profiling Modes' section below.
 * :frequency       - in :cputime mode, the number of times per second the app will be sampled. Default is 100 (times/sec)
 * :bundler         - run the profiler binary using 'bundle' if set to true. Default is false
 * :gemfile_dir     - directory with Gemfile. Default is the current directory.
 
 == Usage 
 
-There are two modes for the profiler
+There are two ways to profile your app: with a single request or with multiple requests.
 
-First, you can run in 'simple' mode. Just visit the url you want to profile, but
+To profile with a single request, visit the URL you want to profile, but
 add the 'profile' and (optionally) the 'times' GET params (which will rerun the action
 the specified number of times).
 
@@ -74,7 +74,9 @@ Example:
 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.
+You can also profile your application using multiple requests. When you profile using this method, 
+all responses are normal. You must visit \_\_stop\_\_  to complete profiling and then you can view 
+the profiling data by visiting \_\_data\_\_.
 
 Example:
   curl http://localhost:3000/__start__
@@ -83,14 +85,11 @@ Example:
   curl http://localhost:3000/__stop__
   curl http://localhost:3000/__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\_\_
-
 == 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
+Regardless of how you profile your application, you can add additional params to change how the 
+data is displayed. When using a single request, these params are just added to the URL being profiled. 
+When using multiple requests, they are added to the \_\_data\_\_ URL.
 
 * printer - overrides the default_printer option (see above)
 * ignore  - a regular expression of the area of code to ignore 
@@ -101,11 +100,12 @@ for more details)
 
 == Profiling Modes
 
-perftools.rb can be put into three different profiling modes.
+perftools.rb (and therefore, the Rack middleware) can be put into three different profiling modes.
 
 * CPU time mode            - Reports how many CPU cycles are spent in each section of code. This is the default and can be enabled by setting ':mode => :cputime'
-* Wall time mode           - Reports the amount of time (as in, wall clock time) spent in each section of code. Enable by setting ':mode => :walltime'
+* Method call mode         - Report how many method calls are made inside each method. Enable by setting ':mode => :methods'
 * Object allocation mode   - Reports the percentage of object allocations performed in each section of code. Enable by setting ':mode => :objects'
+* Wall time mode           - Reports the amount of time (as in, wall clock time) spent in each section of code. Enable by setting ':mode => :walltime'
 
 For example, consider the following Sinatra application:
 
@@ -125,6 +125,20 @@ In the default mode, there will be no profiling data for the 'slow' route, becau
 
 If you change the mode to ':walltime', you'll get profiling data, since the call to 'sleep' causes the code to spend several seconds of wall time in the block.
 
+== Overriding the Profiling mode
+
+You can also switch the profiling mode on a per-request basis, but ONLY if you are switching to 'methods' or 'objects' mode. Due to the implementation of perftools.rb, it is NOT possible to switch to 'walltime' or 'cputime' modes.
+
+To switch to another mode, provide the 'mode' option. When profiling with a single request, add the option to the URL profiled:
+
+  curl http://localhost:3000/foobar?profile=true&mode=objects
+
+When profiling using multiple requests, add the option when visiting \_\_start\_\_ :
+
+  curl http://localhost:3000/__start__?mode=objects
+
+If the 'mode' option is omitted, the middleware will default to the mode specified at configuration.
+
 == Changing behavior with environment variables
 
 The mode and frequency settings are enabled by setting environment variables. Some of these environment variables must be set before 'perftools' is required. If you only require 'rack/perftools_profiler', it will do the right thing (require 'perftools' after setting the environment variables).

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/rack/perftools_profiler.rb

@@ -2,6 +2,7 @@ require 'rack'
 require 'pstore'
 require 'open4'
 
+require 'rack/perftools_profiler/utils'
 require 'rack/perftools_profiler/profiler_middleware'
 require 'rack/perftools_profiler/action'
 require 'rack/perftools_profiler/profiler'
@@ -24,6 +25,7 @@ module Rack::PerftoolsProfiler
   end
 
   def self.with_profiling_off(app, options = {})
+    clear_data
     instance = ProfilerMiddleware.new(app, options)
     instance.force_stop
     instance

data/lib/rack/perftools_profiler/profile_once.rb

@@ -2,6 +2,7 @@ module Rack::PerftoolsProfiler
 
   class ProfileOnce < ProfileDataAction
     include Rack::Utils
+    include Rack::PerftoolsProfiler::Utils
 
     def self.has_special_param?(request)
       request.params['profile'] != nil
@@ -11,12 +12,19 @@ module Rack::PerftoolsProfiler
       super
       request = Rack::Request.new(@env)
       @times = (request.params.fetch('times') {1}).to_i
+      @mode = let(request.params['mode']) do |m|
+        if m.nil? || m.empty?
+          nil
+        else
+          m.to_sym
+        end
+      end
       check_printer_arg
       @new_env = delete_custom_params(@env)
     end
     
     def act
-      @profiler.profile do
+      @profiler.profile(@mode) do
         @times.times { @middleware.call_app(@new_env) }
       end
     end

data/lib/rack/perftools_profiler/profiler.rb

@@ -22,7 +22,9 @@ module Rack::PerftoolsProfiler
     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
+    MODES = [:cputime, :methods, :objects, :walltime]
     DEFAULT_MODE = :cputime
+    CHANGEABLE_MODES = [:methods, :objects]
     UNSET_FREQUENCY = "-1"
     DEFAULT_GEMFILE_DIR = '.'
 
@@ -32,15 +34,17 @@ module Rack::PerftoolsProfiler
       @mode        = (options.delete(:mode) { DEFAULT_MODE }).to_sym
       @bundler     = (options.delete(:bundler) { false })
       @gemfile_dir = (options.delete(:gemfile_dir) { DEFAULT_GEMFILE_DIR })
+      @mode_for_request = nil
       ProfileDataAction.check_printer(@printer)
+      ensure_mode_is_valid(@mode)
       # We need to set the enviroment variables before loading perftools
       set_env_vars
       require 'perftools'
       raise ProfilerArgumentError, "Invalid option(s): #{options.keys.join(' ')}" unless options.empty?
     end
     
-    def profile
-      start
+    def profile(mode = nil)
+      start(mode)
       yield
     ensure
       stop
@@ -50,10 +54,18 @@ module Rack::PerftoolsProfiler
       ::File.delete(PROFILING_DATA_FILE) if ::File.exists?(PROFILING_DATA_FILE)
     end
     
-    def start
+    def start(mode = nil)
+      ensure_mode_is_changeable(mode) if mode
       PerfTools::CpuProfiler.stop
+      if (mode)
+        @mode_for_request = mode
+      end  
+      unset_env_vars
+      set_env_vars
       PerfTools::CpuProfiler.start(PROFILING_DATA_FILE)
       self.profiling = true
+    ensure
+      @mode_for_request = nil
     end
 
     def stop
@@ -106,16 +118,22 @@ module Rack::PerftoolsProfiler
     end
 
     def set_env_vars
-      ENV['CPUPROFILE_REALTIME'] = '1' if @mode == :walltime
-      ENV['CPUPROFILE_OBJECTS'] = '1' if @mode == :objects
+      if @mode_for_request
+        mode_to_use = @mode_for_request
+      else
+        mode_to_use = @mode
+      end
+      ENV['CPUPROFILE_REALTIME'] = '1' if mode_to_use == :walltime
+      ENV['CPUPROFILE_OBJECTS'] = '1' if mode_to_use == :objects
+      ENV['CPUPROFILE_METHODS'] = '1' if mode_to_use == :methods
       ENV['CPUPROFILE_FREQUENCY'] = @frequency if @frequency != UNSET_FREQUENCY
     end
 
-    # Useful for testing
     def unset_env_vars
       ENV.delete('CPUPROFILE_REALTIME')
       ENV.delete('CPUPROFILE_FREQUENCY')
       ENV.delete('CPUPROFILE_OBJECTS')
+      ENV.delete('CPUPROFILE_METHODS')
     end
     
     def profiling=(value)
@@ -131,6 +149,24 @@ module Rack::PerftoolsProfiler
       end
     end
 
+    def ensure_mode_is_changeable(mode)
+      if !CHANGEABLE_MODES.include?(mode)
+        message = "Cannot change mode to '#{mode}'.\n"
+        mode_string = CHANGEABLE_MODES.map{|m| "'#{m}'"}.join(", ")
+        message += "Per-request mode changes are only available for the following modes: #{mode_string}.\n"
+        message += "See the README for more details."
+        raise ProfilerArgumentError, message
+      end
+    end
+
+    def ensure_mode_is_valid(mode)
+      if !MODES.include?(mode)
+        message = "Invalid mode: #{mode}.\n"
+        message += "Valid modes are: #{MODES.join(', ')}"
+        raise ProfilerArgumentError, message
+      end
+    end
+
   end
 
 end

data/lib/rack/perftools_profiler/return_data.rb

@@ -9,7 +9,7 @@ module Rack::PerftoolsProfiler
 
     def response
       if @profiler.profiling?
-        [400, {'Content-Type' => 'text/plain'}, ['No profiling data available.']]
+        [400, {'Content-Type' => 'text/plain'}, ["No profiling data available yet.\nVisit to /__stop__ to finish profiling."]]
       else
         @middleware.profiler_data_response(@profiler.data(@data_params))
       end

data/lib/rack/perftools_profiler/start_profiling.rb

@@ -1,9 +1,22 @@
 module Rack::PerftoolsProfiler
 
   class StartProfiling < Action
+    include Rack::PerftoolsProfiler::Utils
 
+    def initialize(*args)
+      super
+      request = Rack::Request.new(@env)
+      @mode = let(request.params['mode']) do |m|
+        if m.nil? || m.empty?
+          nil
+        else
+          m.to_sym
+        end
+      end
+    end
+    
     def act
-      @profiler.start
+      @profiler.start(@mode)
     end
 
     def response

data/lib/rack/perftools_profiler/utils.rb

@@ -0,0 +1,11 @@
+module Rack::PerftoolsProfiler
+
+  module Utils
+  
+    def let(x)
+      yield x
+    end
+
+  end
+
+end

data/rack-perftools_profiler.gemspec

@@ -0,0 +1,81 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rack-perftools_profiler}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben Brinckerhoff"]
+  s.date = %q{2011-01-16}
+  s.description = %q{Middleware for profiling Rack-compatible apps using perftools.rb}
+  s.email = %q{ben@bbrinck.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/rack/perftools_profiler.rb",
+    "lib/rack/perftools_profiler/action.rb",
+    "lib/rack/perftools_profiler/call_app_directly.rb",
+    "lib/rack/perftools_profiler/profile_data_action.rb",
+    "lib/rack/perftools_profiler/profile_once.rb",
+    "lib/rack/perftools_profiler/profiler.rb",
+    "lib/rack/perftools_profiler/profiler_middleware.rb",
+    "lib/rack/perftools_profiler/return_data.rb",
+    "lib/rack/perftools_profiler/start_profiling.rb",
+    "lib/rack/perftools_profiler/stop_profiling.rb",
+    "lib/rack/perftools_profiler/utils.rb",
+    "rack-perftools_profiler.gemspec",
+    "test/multiple_request_profiling_test.rb",
+    "test/rack-perftools-profiler_test.rb",
+    "test/single_request_profiling_test.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/bhb/rack-perftools_profiler}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Middleware for profiling Rack-compatible apps using perftools.rb}
+  s.test_files = [
+    "test/multiple_request_profiling_test.rb",
+    "test/rack-perftools-profiler_test.rb",
+    "test/single_request_profiling_test.rb",
+    "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<perftools.rb>, ["~> 0.5"])
+      s.add_runtime_dependency(%q<rack>, ["~> 1.0"])
+      s.add_runtime_dependency(%q<open4>, ["~> 1.0"])
+      s.add_development_dependency(%q<rack>, ["~> 1.1"])
+      s.add_development_dependency(%q<shoulda>, ["~> 2.10"])
+      s.add_development_dependency(%q<mocha>, ["~> 0.9"])
+    else
+      s.add_dependency(%q<perftools.rb>, ["~> 0.5"])
+      s.add_dependency(%q<rack>, ["~> 1.0"])
+      s.add_dependency(%q<open4>, ["~> 1.0"])
+      s.add_dependency(%q<rack>, ["~> 1.1"])
+      s.add_dependency(%q<shoulda>, ["~> 2.10"])
+      s.add_dependency(%q<mocha>, ["~> 0.9"])
+    end
+  else
+    s.add_dependency(%q<perftools.rb>, ["~> 0.5"])
+    s.add_dependency(%q<rack>, ["~> 1.0"])
+    s.add_dependency(%q<open4>, ["~> 1.0"])
+    s.add_dependency(%q<rack>, ["~> 1.1"])
+    s.add_dependency(%q<shoulda>, ["~> 2.10"])
+    s.add_dependency(%q<mocha>, ["~> 0.9"])
+  end
+end
+

data/test/multiple_request_profiling_test.rb

@@ -0,0 +1,352 @@
+require 'test_helper'
+
+class MultipleRequestProfilingTest < Test::Unit::TestCase
+  include Rack::PerftoolsProfiler
+
+  def setup
+    @app = lambda { |env| ITERATIONS.times {1+2+3+4+5}; [200, {'Content-Type' => 'text/plain'}, ['Oh hai der']] }
+    @start_env = Rack::MockRequest.env_for('/__start__')
+    @stop_env = Rack::MockRequest.env_for('/__stop__')
+    @data_env = Rack::MockRequest.env_for('/__data__')
+    @root_request_env = Rack::MockRequest.env_for("/")    
+  end
+
+  def profile(profiled_app, options = {})
+    start = options.fetch(:start) { @start_env }
+    stop = options.fetch(:stop) { @stop_env }
+    data = options.fetch(:data) { @data_env }
+    
+    profiled_app.call(start) if start != :none
+    if block_given?
+      yield profiled_app
+    else
+      profiled_app.call(@root_request_env)
+    end
+    last_response = profiled_app.call(stop) if stop != :none
+    if data!=nil && data!=:none
+      last_response = profiled_app.call(data) if data
+    end
+    last_response
+  end
+
+  def profile_requests(profiled_app, requests, options = {})
+    get_data = options.fetch(:get_data) { true }
+    if requests == :default
+      requests = [@root_request_env]
+    else
+      requests = Array(requests)
+    end
+    profiled_app.call(@start_env)
+    requests.each do |request|
+      profiled_app.call(request)
+    end
+    profiled_app.call(@stop_env)
+    profiled_app.call(@data_env) if get_data
+  end
+
+  context "(common behavior)" do
+
+    should 'default to text printer' do
+      # TODO - It's weird that this passes if you pass in :data => :none to #profile
+      _, headers, _ = profile(Rack::PerftoolsProfiler.new(@app))
+      assert_equal "text/plain", headers['Content-Type']
+    end
+
+    should "set CPUPROFILE_REALTIME to 1 if mode is 'walltime' " do
+      realtime = ENV['CPUPROFILE_REALTIME']
+      assert_nil realtime
+      app = lambda do |env|
+        realtime = ENV['CPUPROFILE_REALTIME']
+        [200, {}, ["hi"]]
+      end
+      profiled_app = Rack::PerftoolsProfiler.new(app, :mode => 'walltime')
+      profile(profiled_app, :data => :none)
+      assert_equal '1', realtime
+    end
+
+    should "set CPUPROFILE_OBJECTS to 1 if mode is 'objects'" do
+      objects = ENV['CPUPROFILE_OBJECTS']
+      assert_nil objects
+      app = lambda do |env|
+        objects = ENV['CPUPROFILE_OBJECTS']
+        [200, {}, ["hi"]]
+      end
+      profiled_app = Rack::PerftoolsProfiler.new(app, :mode => 'objects')
+      profile(profiled_app, :data => :none)
+      assert_equal '1', objects
+    end
+
+    should "set CPUPROFILE_METHODS to 1 if mode is 'methods'" do
+      methods = ENV['CPUPROFILE_METHODS']
+      assert_nil methods
+      app = lambda do |env|
+        methods = ENV['CPUPROFILE_METHODS']
+        [200, {}, ["hi"]]
+      end
+      profiled_app = Rack::PerftoolsProfiler.new(app, :mode => 'methods')
+      profile(profiled_app, :data => :none)
+      assert_equal '1', methods
+    end
+
+    should "not set CPUPROFILE_FREQUENCY by default" do
+      frequency = ENV['CPUPROFILE_FREQUENCY']
+      assert_nil frequency
+      frequency = '1'
+      app = lambda do |env|
+        frequency = ENV['CPUPROFILE_FREQUENCY']
+        [200, {}, ["hi"]]
+      end
+      profiled_app = Rack::PerftoolsProfiler.new(app)
+      profile(profiled_app, :data => :none)
+      assert_nil frequency
+    end
+
+    should 'alter CPUPROFILE_FREQUENCY if frequency is set' do
+      frequency = ENV['CPUPROFILE_FREQUENCY']
+      assert_nil frequency
+      app = lambda do |env|
+        frequency = ENV['CPUPROFILE_FREQUENCY']
+        [200, {}, ["hi"]]
+      end
+      profiled_app = Rack::PerftoolsProfiler.new(app, :frequency => 250)
+      profile(profiled_app, :data => :none)
+      assert_equal '250', frequency
+    end
+
+    should "allow 'printer' param to override :default_printer option'" do
+      profiled_app = Rack::PerftoolsProfiler.new(@app, :default_printer => 'pdf')
+      custom_data_env = Rack::MockRequest.env_for('__data__', :params => 'printer=gif')
+      _, headers, _ = profile(profiled_app, :data => custom_data_env)
+      assert_equal 'image/gif', headers['Content-Type']
+    end
+
+    should 'give 400 if printer is invalid' do
+      profiled_app = Rack::PerftoolsProfiler.new(@app, :default_printer => 'pdf')
+      custom_data_env = Rack::MockRequest.env_for('__data__', :params => 'printer=badprinter')
+      status, _, body = profile(profiled_app, :data => custom_data_env)
+      assert_equal 400, status
+      assert_match /Invalid printer type/, body.join
+    end
+
+    should "accept 'focus' param" do
+      profiled_app = Rack::PerftoolsProfiler.with_profiling_off(TestApp.new, :default_printer => 'text', :mode => 'walltime')
+      custom_data_env = Rack::MockRequest.env_for('__data__', :params => 'focus=method1')
+
+      status, headers, body = profile(profiled_app, :data => custom_data_env) do |app|
+        app.call(Rack::MockRequest.env_for('/method1'))
+        app.call(Rack::MockRequest.env_for('/method2'))
+      end
+      assert_match(/method1/,    RackResponseBody.new(body).to_s)
+      assert_no_match(/method2/, RackResponseBody.new(body).to_s)
+    end
+
+    should "accept 'ignore' param" do
+      profiled_app = Rack::PerftoolsProfiler.with_profiling_off(TestApp.new, :default_printer => 'text', :mode => 'walltime')
+      custom_data_env = Rack::MockRequest.env_for('__data__', :params => 'ignore=method1')
+
+      status, headers, body = profile(profiled_app, :data => custom_data_env) do |app|
+        app.call(Rack::MockRequest.env_for('/method1'))
+        app.call(Rack::MockRequest.env_for('/method2'))
+      end
+
+      assert_match(/method2/,    RackResponseBody.new(body).to_s)
+      assert_no_match(/method1/, RackResponseBody.new(body).to_s)
+    end
+
+    context "when in bundler mode" do
+      
+      should "call pprof.rb using 'bundle' command if bundler is set" do
+        status = stub_everything(:exitstatus => 0)
+        profiled_app = Rack::PerftoolsProfiler.new(@app, :bundler => true)
+        Open4.expects(:popen4).with(regexp_matches(/^bundle exec pprof\.rb/)).returns(status)
+        profile(profiled_app)
+      end
+
+      should "change directory into the current directory if custom Gemfile dir is not provided" do
+        profiled_app = Rack::PerftoolsProfiler.new(@app, :bundler => true, :gemfile_dir => 'bundler')
+        Dir.expects(:chdir).with('bundler').returns(["","",0])
+        profile(profiled_app)
+      end
+
+      should "change directory into custom Gemfile dir if provided" do
+        profiled_app = Rack::PerftoolsProfiler.new(@app, :bundler => true)
+        Dir.expects(:chdir).with('.').returns(["","",0])
+        profile(profiled_app)
+      end
+      
+    end
+
+    context "when overriding profiling mode" do
+
+      should "default to configured mode if mode is empty string" do
+        realtime = ENV['CPUPROFILE_REALTIME']
+        assert_nil realtime
+        app = lambda do |env|
+          realtime = ENV['CPUPROFILE_REALTIME']
+          [200, {}, ["hi"]]
+        end
+        profiled_app = Rack::PerftoolsProfiler.new(app, :mode => :walltime)
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => 'mode=')
+        profile(profiled_app, :start => modified_start_env, :data => :none)
+        assert_equal '1', realtime
+      end
+
+      should "set CPUPROFILE_OBJECTS to 1 if mode is 'objects'" do
+        objects = ENV['CPUPROFILE_OBJECTS']
+        assert_nil objects
+        app = lambda do |env|
+          objects = ENV['CPUPROFILE_OBJECTS']
+          [200, {}, ["hi"]]
+        end
+        profiled_app = Rack::PerftoolsProfiler.new(app, :mode => :cputime)
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => 'mode=objects')
+        profile(profiled_app, :start => modified_start_env, :data => :none)
+        assert_equal '1', objects
+      end
+
+      should "set CPUPROFILE_METHODS to 1 if mode is 'methods'" do
+        methods = ENV['CPUPROFILE_METHODS']
+        assert_nil methods
+        app = lambda do |env|
+          methods = ENV['CPUPROFILE_METHODS']
+          [200, {}, ["hi"]]
+        end
+        profiled_app = Rack::PerftoolsProfiler.new(app, :mode => :cputime)
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => 'mode=methods')
+        profile(profiled_app, :start => modified_start_env, :data => :none)
+        assert_equal '1', methods
+      end
+
+      should "return to default mode if no mode is specified" do
+        objects = ENV['CPUPROFILE_OBJECTS']
+        assert_nil objects
+        app = lambda do |env|
+          objects = ENV['CPUPROFILE_OBJECTS']
+          [200, {}, ["hi"]]
+        end
+
+        profiled_app = Rack::PerftoolsProfiler.new(app, :mode => :cputime)
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => 'mode=objects')
+        profile(profiled_app, :start => modified_start_env, :data => :none)
+        
+        assert_equal '1', objects
+
+        profile(profiled_app, :data => :none)
+        
+        assert_nil objects
+      end
+
+      should "return error message if mode is unrecognized" do
+        profiled_app = Rack::PerftoolsProfiler.new(@app)
+        mode = "foobar"
+
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => "mode=#{mode}")
+
+        status, _, body = profiled_app.call(modified_start_env)
+
+        assert_equal 400, status
+        assert_match(/Cannot change mode to '#{mode}'.\nPer-request mode changes are only available for the following modes: 'methods', 'objects'/, 
+                     RackResponseBody.new(body).to_s)
+      end
+
+      should "return error message if mode is 'walltime'" do
+        profiled_app = Rack::PerftoolsProfiler.new(@app)
+        mode = "walltime"
+
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => "mode=#{mode}")
+
+        status, _, body = profiled_app.call(modified_start_env)
+
+        assert_equal 400, status
+        assert_match(/Cannot change mode to '#{mode}'.\nPer-request mode changes are only available for the following modes: 'methods', 'objects'/, 
+                     RackResponseBody.new(body).to_s)
+      end
+
+      should "return error message if mode is 'cputime'" do
+        profiled_app = Rack::PerftoolsProfiler.new(@app)
+        mode = "cputime"
+
+        modified_start_env = Rack::MockRequest.env_for('/__start__', :params => "mode=#{mode}")
+
+        status, _, body = profiled_app.call(modified_start_env)
+
+        assert_equal 400, status
+        assert_match(/Cannot change mode to '#{mode}'.\nPer-request mode changes are only available for the following modes: 'methods', 'objects'/, 
+                     RackResponseBody.new(body).to_s)
+      end
+
+    end
+    
+  end
+
+  context 'when profiling is enabled' do
+
+    should 'not provide profiling data when __data__ is called' do
+      Rack::PerftoolsProfiler.clear_data
+      profiled_app = Rack::PerftoolsProfiler.with_profiling_off(@app, :default_printer => 'text')
+      status, _ , body = profile(profiled_app, :stop => :none)
+      assert_equal 400, status
+      assert_match(/No profiling data available./, RackResponseBody.new(body).to_s)
+    end
+
+    should 'pass on profiling params in environment' do
+      env = Rack::MockRequest.env_for('/', :params => 'times=2')
+      old_env = env.clone
+      app = @app.clone
+      expected_env = env.clone
+      expected_env['rack.request.query_string'] = 'times=2'
+      expected_env['rack.request.query_hash'] = {'times' => '2'}
+      app.expects(:call).with(expected_env)
+      profiled_app = Rack::PerftoolsProfiler.new(app, :default_printer => 'text')
+      profiled_app.call(@start_env)
+      profiled_app.call(env)
+      assert_equal env, old_env
+    end
+
+    should 'pass on non-profiling params in environment' do
+      env = Rack::MockRequest.env_for('/', :params => 'param=value')
+      old_env = env.clone
+      app = @app.clone
+      expected_env = env.clone
+      expected_env['rack.request.query_string'] = 'param=value'
+      expected_env['rack.request.query_hash'] = {'param' => 'value'}
+      app.expects(:call).with(expected_env)
+      profiled_app = Rack::PerftoolsProfiler.new(app, :default_printer => 'text')
+      profiled_app.call(@start_env)
+      profiled_app.call(env)
+      assert_equal env, old_env
+    end
+
+    should 'not alter regular calls' do
+      profiled_app = Rack::PerftoolsProfiler.with_profiling_off(@app, :default_printer => 'gif')
+      profiled_app.call(@start_env)
+      status, headers, body = profiled_app.call(@root_request_env)
+      assert_equal 200, status
+      assert_equal 'text/plain', headers['Content-Type']
+      assert_equal 'Oh hai der', RackResponseBody.new(body).to_s
+    end
+
+  end
+
+  context 'after profiling is finished' do
+
+    should 'return profiling data when __data__ is called' do
+      profiled_app = Rack::PerftoolsProfiler.with_profiling_off(@app, :default_printer => 'gif')
+      status, headers, body = profile(profiled_app)
+      assert_equal 200, status
+      assert_equal "image/gif", headers['Content-Type']
+    end
+
+  end
+  
+  should 'keeps data from multiple calls' do
+    profiled_app = Rack::PerftoolsProfiler.with_profiling_off(TestApp.new, :default_printer => 'text', :mode => 'walltime')
+    status, headers, body = profile(profiled_app) do |app|
+      app.call(Rack::MockRequest.env_for('/method1'))
+      app.call(Rack::MockRequest.env_for('/method2'))
+    end
+    assert_match(/method1/, RackResponseBody.new(body).to_s)
+    assert_match(/method2/, RackResponseBody.new(body).to_s)
+  end
+
+end