perf_check 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad9c18545aaee3bdcba0a6bb28eb307b341ba78a
-  data.tar.gz: 89809449598f93009f78b0c353ab432f7da341f5
+  metadata.gz: 3c41d74ec42bbf613535e0a755f07d509c061763
+  data.tar.gz: baa5b5b5aa29175b800e5356e90caec667a98863
 SHA512:
-  metadata.gz: 51b79c492435781ae275d452045cc34ce6d7468b0ce756a43b1ead8692a3c15a42ca6f718854718aea189c4f9aafaf089da281767d44f34eb89a441ffddb1e41
-  data.tar.gz: 6963d6cf9bf01766168a87fc3962cbdd85b9a42b46b63128c9f9defb18d2c206219d0eb359c0da8c6dc3ef066c268023ceb2a3dba7f810f245824cf4367caac8
+  metadata.gz: 699c58295c4aac2949b7d764e55cff7160080187afbc2430200016017ba21013ca710d04e7c3cbb7ea768dac378e28daf82f9cdca36e367c6f297f379d8758a1
+  data.tar.gz: b935d9879a07bc679343f5e49c5a2e549b38158f3e2b849a3e5a3655d7244d071794f1fa074b881922649c7324ab2d859eb5b550d4ebee318846d2d06d70032f

data/bin/perf_check

@@ -2,13 +2,26 @@
 
 require 'perf_check'
 
-ORIGINAL_ARGV = ARGV.clone
+app_root =
+  begin
+    dir = Dir.pwd
+    until dir == '/' || File.exist?("#{dir}/config/application.rb")
+      dir = File.dirname(dir)
+    end
 
-if File.exists?("#{PerfCheck.app_root}/tmp/pids/server.pid")
+    unless File.exist?("#{dir}/config/application.rb")
+      abort("perf_check should be run from a rails directory")
+    end
+
+    dir
+  end
+
+
+if File.exists?("#{app_root}/tmp/pids/server.pid")
   abort("It looks like a rails server is already running. Shut it down before continuing with perf_check.")
 end
 
-perf_check = PerfCheck.new
+perf_check = PerfCheck.new(app_root).tap(&:load_config)
 
 at_exit do
   cbdata = {}
@@ -21,20 +34,19 @@ at_exit do
   perf_check.trigger_when_finished_callbacks(cbdata)
 end
 
-PerfCheck.load_config
-PerfCheck::Options.parse!
-
-ARGV.each{ |route| perf_check.add_test_case(route) }
+perf_check.option_parser.parse(ARGV).each do |route|
+  perf_check.add_test_case(route)
+end
 
 if perf_check.test_cases.empty?
-  abort(PerfCheck::Options.help)
+  abort(perf_check.option_parser.help)
 end
 
 perf_check.run
 
-if PerfCheck.config.brief
+if perf_check.options.brief
   perf_check.print_brief_results
-elsif PerfCheck.config.json
+elsif perf_check.options.json
   perf_check.print_json_results
 else
   perf_check.print_full_results

data/lib/perf_check.rb

@@ -5,44 +5,69 @@ require 'benchmark'
 require 'ostruct'
 require 'colorize'
 require 'json'
+require 'logger'
 
 class PerfCheck
-  attr_accessor :options, :server, :test_cases
-
-  def self.app_root
-    @app_root ||= begin
-      dir = Dir.pwd
-      until dir == '/' || File.exist?("#{dir}/config/application.rb")
-        dir = File.dirname(dir)
-      end
-
-      unless File.exist?("#{dir}/config/application.rb")
-        abort("perf_check should be run from a rails directory")
+  class Exception < ::Exception; end
+
+  attr_reader :app_root, :options, :git, :server, :test_cases
+  attr_accessor :logger
+
+  def initialize(app_root)
+    @app_root = app_root
+
+    @options = OpenStruct.new(
+      number_of_requests: 20,
+      reference: 'master',
+      cookie: nil,
+      headers: {},
+      http_statuses: [200],
+      verify_responses: false,
+      caching: true,
+      json: false
+    )
+
+    @logger = Logger.new(STDERR).tap do |logger|
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S")}] #{msg}\n"
       end
-
-      dir
     end
+
+    @git = Git.new(self)
+    @server = Server.new(self)
+    @test_cases = []
   end
 
-  def initialize
-    self.options = OpenStruct.new
-    self.server = Server.new
-    self.test_cases = []
+  def load_config
+    if File.exists?("#{app_root}/config/perf_check.rb")
+      this = self
+      Kernel.send(:define_method, :perf_check){ this }
+      load "#{app_root}/config/perf_check.rb"
+      Kernel.send(:remove_method, :perf_check)
+    end
   end
 
   def add_test_case(route)
-    test_cases.push(TestCase.new(route.sub(/^([^\/])/, '/\1')))
+    test_cases.push(TestCase.new(self, route.sub(/^([^\/])/, '/\1')))
   end
 
   def run
-    profile_requests
+    begin
+      profile_requests
 
-    if options.reference
-      Git.stash_if_needed
-      Git.checkout_reference(options.reference)
-      test_cases.each{ |x| x.switch_to_reference_context }
+      if options.reference
+        git.stash_if_needed
+        git.checkout_reference(options.reference)
+        test_cases.each{ |x| x.switch_to_reference_context }
 
-      profile_requests
+        profile_requests
+      end
+    ensure
+      server.exit rescue nil
+      if options.reference
+        git.checkout_current_branch(false) rescue nil
+        (git.pop rescue nil) if git.stashed?
+      end
     end
   end
 
@@ -59,10 +84,10 @@ class PerfCheck
       test.cookie = options.cookie
 
       if options.diff
-        PerfCheck.logger.info("Issuing #{test.resource}")
+        logger.info("Issuing #{test.resource}")
       else
-        PerfCheck.logger.info ''
-        PerfCheck.logger.info("Benchmarking #{test.resource}:")
+        logger.info ''
+        logger.info("Benchmarking #{test.resource}:")
       end
 
       test.run(server, options)
@@ -73,18 +98,17 @@ class PerfCheck
 
   def run_migrations_up
     Bundler.with_clean_env{ puts `bundle exec rake db:migrate` }
-    Git.clean_db
+    git.clean_db
   end
 
   def run_migrations_down
-    Git.migrations_to_run_down.each do |version|
+    git.migrations_to_run_down.each do |version|
       Bundler.with_clean_env{ puts `bundle exec rake db:migrate:down VERSION=#{version}` }
     end
-    Git.clean_db
+    git.clean_db
   end
 end
 
-require 'perf_check/logger'
 require 'perf_check/server'
 require 'perf_check/test_case'
 require 'perf_check/git'

data/lib/perf_check/callbacks.rb

@@ -1,42 +1,41 @@
 # coding: utf-8
 class PerfCheck
-  def self.when_finished(&block)
+  def when_finished(&block)
     @when_finished_callbacks ||= []
     @when_finished_callbacks << block
   end
 
-  def self.when_finished_callbacks
+  def when_finished_callbacks
     @when_finished_callbacks || []
   end
 
-  def self.before_start(&block)
+  def before_start(&block)
     @before_start_callbacks ||= []
     @before_start_callbacks << block
   end
 
-  def self.before_start_callbacks
+  def before_start_callbacks
     (@before_start_callbacks || []) + [
-      proc {
-        PerfCheck.logger.info("=" * 77)
-        PerfCheck.logger.info("PERRRRF CHERRRK! Grab a ☕️  and don't touch your working tree (we automate git)")
-        PerfCheck.logger.info("=" * 77)
+      proc { |perf_check|
+        perf_check.logger.info("=" * 77)
+        perf_check.logger.info("PERRRRF CHERRRK! Grab a ☕️  and don't touch your working tree (we automate git)")
+        perf_check.logger.info("=" * 77)
       }
     ]
   end
 
 
   def trigger_before_start_callbacks(test_case)
-    PerfCheck.before_start_callbacks.each{ |f| f.call(self, test_case) }
+    before_start_callbacks.each{ |f| f.call(self, test_case) }
   end
 
   def trigger_when_finished_callbacks(data={})
-    data = data.merge(:current_branch => PerfCheck::Git.current_branch)
+    data = data.merge(:current_branch => git.current_branch)
     results = OpenStruct.new(data)
-    results[:ARGV] = ORIGINAL_ARGV
     if test_cases.size == 1
       results.current_latency = test_cases.first.this_latency
       results.reference_latency = test_cases.first.reference_latency
     end
-    PerfCheck.when_finished_callbacks.each{ |f| f.call(results) }
+    when_finished_callbacks.each{ |f| f.call(self, results) }
   end
 end

data/lib/perf_check/config.rb

@@ -1,102 +1,80 @@
 require 'optparse'
 
 class PerfCheck
-  def self.config
-    @config ||= OpenStruct.new(
-      number_of_requests: 20,
-      reference: 'master',
-      cookie: nil,
-      headers: {},
-      http_statuses: [200],
-      verify_responses: false,
-      caching: true,
-      json: false
-     )
-  end
-
-  def config
-    PerfCheck.config
-  end
-
-  alias :options :config
-
-  Options = OptionParser.new do |opts|
-    opts.banner = "Usage: perf_check [options] [route ...]"
-
-    opts.separator "\nBenchmark options:"
-    opts.on('--requests N', '-n',
-            'Use N requests in benchmark, defaults to 20') do |n|
-      config.number_of_requests = n.to_i
-    end
-
-    opts.on('--reference COMMIT', '-r',
-            'Benchmark against COMMIT instead of master') do |commit|
-      config.reference = commit
-    end
+  def option_parser
+    @optparse ||= OptionParser.new do |opts|
+      opts.banner = "Usage: perf_check [options] [route ...]"
+
+      opts.separator "\nBenchmark options:"
+      opts.on('--requests N', '-n',
+              'Use N requests in benchmark, defaults to 20') do |n|
+        options.number_of_requests = n.to_i
+      end
 
-    opts.on('--quick', '-q',
-            'Fire off 20 requests just on this branch (no comparison with master)') do
-      config.reference = nil
-    end
+      opts.on('--reference COMMIT', '-r',
+              'Benchmark against COMMIT instead of master') do |commit|
+        options.reference = commit
+      end
 
-    opts.on('--no-caching', 'Do not enable fragment caching') do
-      config.caching = false
-    end
+      opts.on('--quick', '-q',
+              'Fire off 20 requests just on this branch (no comparison with master)') do
+        options.reference = nil
+      end
 
-    opts.on('--run-migrations', 'Run migrations on the branch and unmigrate at the end') do
-      config[:run_migrations?] = true
-    end
+      opts.on('--no-caching', 'Do not enable fragment caching') do
+        options.caching = false
+      end
 
-    opts.on('--fail-fast', '-f', 'Bail immediately on non-200 HTTP response') do
-      config[:fail_fast?] = true
-    end
+      opts.on('--run-migrations', 'Run migrations on the branch and unmigrate at the end') do
+        options[:run_migrations?] = true
+      end
 
-    opts.on('--302-success', 'Consider HTTP 302 code a successful request') do
-      config.http_statuses.push(302)
-    end
+      opts.on('--302-success', 'Consider HTTP 302 code a successful request') do
+        options.http_statuses.push(302)
+      end
 
-    opts.on('--302-failure', 'Consider HTTP 302 code an unsuccessful request') do
-      config.http_statuses.delete(302)
-    end
+      opts.on('--302-failure', 'Consider HTTP 302 code an unsuccessful request') do
+        options.http_statuses.delete(302)
+      end
 
-    opts.separator "\nMisc"
-    opts.on('--cookie COOKIE', '-c') do |cookie|
-      config.cookie = cookie
-    end
+      opts.separator "\nMisc"
+      opts.on('--cookie COOKIE', '-c') do |cookie|
+        options.cookie = cookie
+      end
 
-    opts.on('--header HEADER', '-H') do |header|
-      key, value = header.split(':', 2)
-      config.headers[key.strip] = value.strip
-    end
+      opts.on('--header HEADER', '-H') do |header|
+        key, value = header.split(':', 2)
+        options.headers[key.strip] = value.strip
+      end
 
-    opts.on('--json', '-j') do
-      config.json = true
-    end
+      opts.on('--json', '-j') do
+        options.json = true
+      end
 
-    opts.on('--input FILE', '-i') do |input|
-      File.readlines(input).each do |resource|
-        ARGV << resource.strip
+      opts.on('--input FILE', '-i') do |input|
+        File.readlines(input).each do |resource|
+          ARGV << resource.strip
+        end
       end
-    end
 
-    opts.on('--verify-responses',
-            'Check whether there is a diff between the responses of this and the reference branch') do
-      config.verify_responses = true
-    end
+      opts.on('--verify-responses',
+              'Check whether there is a diff between the responses of this and the reference branch') do
+        options.verify_responses = true
+      end
 
-    opts.on('--brief', '-b') do
-      config.brief = true
-    end
+      opts.on('--brief', '-b') do
+        options.brief = true
+      end
 
-    opts.on('--diff') do
-      config.diff = true
-      config.brief = true
-      config.verify_responses = true
-      config.number_of_requests = 1
-    end
+#      opts.on('--diff') do
+#        options.diff = true
+#        options.brief = true
+#        options.verify_responses = true
+#        options.number_of_requests = 1
+#      end
 
-    opts.separator ''
-    opts.separator <<EOF
+      opts.separator ''
+      opts.separator <<EOF
 Usage examples:
   Benchmark PostController#index against master
      perf_check /user/45/posts
@@ -119,17 +97,12 @@ Usage examples:
     perf_check --diff --input FILE
 EOF
 
-    opts.separator ''
+      opts.separator ''
+    end
   end
 
   def self.diff_options
     @@diff_options ||=
       ['-U3', '--ignore-matching-lines=/mini-profiler-resources/includes.js']
   end
-
-  def self.load_config
-    if File.exists?("#{app_root}/config/perf_check.rb")
-      require "#{app_root}/config/perf_check"
-    end
-  end
 end

data/lib/perf_check/git.rb

@@ -1,84 +1,105 @@
+require 'shellwords'
 
 class PerfCheck
   class Git
-    # the branch we are on while loading the script
-    @current_branch = `git rev-parse --abbrev-ref HEAD`.strip
+    class NoSuchBranch < Exception; end
+    class StashError < Exception; end
+    class StashPopError < Exception; end
+    class BundleError < Exception; end
 
-    def self.current_branch
-      @current_branch
+    attr_reader :perf_check, :git_root, :current_branch
+    attr_accessor :logger
+
+    def initialize(perf_check)
+      @perf_check = perf_check
+      @git_root = perf_check.app_root
+      @logger = perf_check.logger
+
+      @current_branch = exec "git rev-parse --abbrev-ref HEAD"
     end
 
-    def self.checkout_reference(reference='master')
+    def checkout_reference(reference='master')
       checkout(reference)
-      at_exit do
-        PerfCheck.logger.info ''
-        Git.checkout_current_branch(false)
-      end
     end
 
-    def self.checkout_current_branch(bundle=true)
+    def checkout_current_branch(bundle=true)
       checkout(@current_branch, bundle)
     end
 
-    def self.checkout(branch, bundle=true)
-      PerfCheck.logger.info("Checking out #{branch} and bundling... ")
-      `git checkout #{branch} --quiet`
+    def checkout(branch, bundle=true)
+      logger.info("Checking out #{branch} and bundling... ")
+      exec "git checkout #{branch} --quiet"
 
       unless $?.success?
-        PerfCheck.logger.fatal("Problem with git checkout! Bailing...") && abort
+        logger.fatal("Problem with git checkout! Bailing...")
+        raise NoSuchBranch
       end
 
-      `git submodule update --quiet`
+      exec "git submodule update --quiet"
 
       if bundle
-        Bundler.with_clean_env{ `bundle` }
+        Bundler.with_clean_env{ exec "bundle" }
         unless $?.success?
-          PerfCheck.logger.fatal("Problem bundling! Bailing...") && abort
+          logger.fatal("Problem bundling! Bailing...")
+          raise BundleError
         end
       end
     end
 
-    def self.stash_if_needed
+    def stash_if_needed
       if anything_to_stash?
-        PerfCheck.logger.info("Stashing your changes... ")
-        system('git stash -q >/dev/null')
+        logger.info("Stashing your changes... ")
+        exec "git stash -q >/dev/null"
 
         unless $?.success?
-          PerfCheck.logger.fatal("Problem with git stash! Bailing...") && abort
+          logger.fatal("Problem with git stash! Bailing...")
+          raise StashError
         end
 
-        at_exit do
-          Git.pop
-        end
+        @stashed = true
       end
     end
 
-    def self.anything_to_stash?
-      git_stash = `git diff`
-      git_stash << `git diff --staged`
+    def stashed?
+      !!@stashed
+    end
+
+    def anything_to_stash?
+      git_stash = exec "git diff"
+      git_stash << exec("git diff --staged")
       !git_stash.empty?
     end
 
-    def self.pop
-      PerfCheck.logger.info("Git stash applying...")
-      system('git stash pop -q')
+    def pop
+      logger.info("Git stash applying...")
+      exec "git stash pop -q"
 
       unless $?.success?
-        PerfCheck.logger.fatal("Problem with git stash! Bailing...") && abort
+        logger.fatal("Problem with git stash! Bailing...")
+        raise StashPopError
       end
     end
 
-    def self.migrations_to_run_down
-      current_migrations_not_on_master.map { |filename| File.basename(filename, '.rb').split('_').first }
+    def migrations_to_run_down
+      current_migrations_not_on_master.map do |filename|
+        File.basename(filename, '.rb').split('_').first
+      end
     end
 
-    def self.current_migrations_not_on_master
-      %x{git diff origin/master --name-only --diff-filter=A db/migrate/}.split.reverse
+    def clean_db
+      exec "git checkout db"
+    end
+
+    private
+
+    def current_migrations_not_on_master
+      exec("git diff origin/master --name-only --diff-filter=A db/migrate/").
+        split.reverse
     end
-    private_class_method :current_migrations_not_on_master
 
-    def self.clean_db
-      `git checkout db`
+    def exec(command)
+      root = Shellwords.shellescape(git_root)
+      `cd #{root} && #{command}`.strip
     end
   end
 end

data/lib/perf_check/middleware.rb

@@ -14,7 +14,20 @@ class PerfCheck
 
     def call(env)
       self.query_count = 0
-      status, headers, body = app.call(env)
+
+      begin
+        status, headers, body = app.call(env)
+      rescue ::Exception => e
+        trace_file = "#{Rails.root}/tmp/perf_check_traces" <<
+                     "/trace-#{SecureRandom.hex(16)}.txt"
+        FileUtils.mkdir_p(File.dirname(trace_file))
+
+        File.open(trace_file, 'w') do |f|
+          f.puts("#{e.class}: #{e.message}")
+          f.write(e.backtrace.join("\n"))
+        end
+        status, headers, body = 500, {"X-PerfCheck-StackTrace" => trace_file}, ''
+      end
 
       headers['X-PerfCheck-Query-Count'] = query_count.to_s
 

data/lib/perf_check/output.rb

@@ -91,7 +91,7 @@ class PerfCheck
         results[-1].merge!(
           reference_latency: test.reference_latency,
           latency_difference: test.latency_difference,
-          speedup_factor: test.reference_latency / test.this_latency,
+          speedup_factor: test.speedup_factor,
           reference_query_count: test.reference_query_count,
           reference_requests: []
         )

data/lib/perf_check/server.rb

@@ -3,9 +3,12 @@ require 'net/http'
 require 'benchmark'
 require 'ostruct'
 require 'fileutils'
+require 'shellwords'
 
 class PerfCheck
   class Server
+    attr_reader :perf_check
+
     def self.seed_random!
       # Seed random
       srand(1)
@@ -32,14 +35,12 @@ class PerfCheck
       end
     end
 
-    def initialize
-      at_exit do
-        exit rescue nil
-      end
+    def initialize(perf_check)
+      @perf_check = perf_check
     end
 
     def pid
-      pidfile = 'tmp/pids/server.pid'
+      pidfile = "#{perf_check.app_root}/tmp/pids/server.pid"
       File.read(pidfile).to_i if File.exists?(pidfile)
     end
 
@@ -48,16 +49,18 @@ class PerfCheck
     end
 
     def prepare_to_profile
-      FileUtils.mkdir_p('tmp/perf_check/miniprofiler')
-      Dir["tmp/perf_check/miniprofiler/*"].each{|x| FileUtils.rm(x) }
+      app_root = perf_check.app_root
+      FileUtils.mkdir_p("#{app_root}/tmp/perf_check/miniprofiler")
+      Dir["#{app_root}/tmp/perf_check/miniprofiler/*"].each{|x| FileUtils.rm(x) }
     end
 
     def latest_profiler_url
-      mp_timer = Dir["tmp/perf_check/miniprofiler/mp_timers_*"].first
+      app_root = perf_check.app_root
+      mp_timer = Dir["#{app_root}/tmp/perf_check/miniprofiler/mp_timers_*"].first
       if "#{mp_timer}" =~ /mp_timers_(\w+)/
         mp_link = "/mini-profiler-resources/results?id=#{$1}"
-        FileUtils.mkdir_p('tmp/miniprofiler')
-        FileUtils.mv(mp_timer, mp_timer.sub(/^tmp\/perf_check\//, 'tmp/'))
+        FileUtils.mkdir_p("#{app_root}/tmp/miniprofiler")
+        FileUtils.mv(mp_timer, mp_timer.sub(/^#{app_root}\/tmp\/perf_check\//, "#{app_root}/tmp/"))
       end
       mp_link
     end
@@ -73,6 +76,7 @@ class PerfCheck
 
       latency = 1000 * response['X-Runtime'].to_f
       query_count = response['X-PerfCheck-Query-Count'].to_i
+      backtrace_file = response['X-PerfCheck-StackTrace']
 
       Profile.new.tap do |result|
         result.latency = latency
@@ -80,6 +84,10 @@ class PerfCheck
         result.profile_url = latest_profiler_url
         result.response_body = response.body
         result.response_code = response.code.to_i
+        result.server_memory = mem
+        if backtrace_file
+          result.backtrace = File.read(backtrace_file).lines.map(&:chomp)
+        end
       end
     end
 
@@ -93,25 +101,26 @@ class PerfCheck
 
     def start
       ENV['PERF_CHECK'] = '1'
-      if PerfCheck.config.verify_responses
+      if perf_check.options.verify_responses
         ENV['PERF_CHECK_VERIFICATION'] = '1'
       end
-      unless PerfCheck.config.caching
+      unless perf_check.options.caching
         ENV['PERF_CHECK_NOCACHING'] = '1'
       end
 
-      system('rails server -b 127.0.0.1 -d -p 3031 >/dev/null')
+      app_root = Shellwords.shellescape(perf_check.app_root)
+      system("cd #{app_root} && rails server -b 127.0.0.1 -d -p 3031 >/dev/null")
       sleep(1.5)
 
       @running = true
     end
 
     def restart
-      if !@running
-        PerfCheck.logger.info("starting rails...")
+      if !running?
+        perf_check.logger.info("starting rails...")
         start
       else
-        PerfCheck.logger.info("re-starting rails...")
+        perf_check.logger.info("re-starting rails...")
         exit
         start
       end
@@ -125,6 +134,10 @@ class PerfCheck
       3031
     end
 
+    def running?
+      @running
+    end
+
     class Profile < OpenStruct; end
   end
 end

data/lib/perf_check/test_case.rb

@@ -4,74 +4,53 @@ require 'diffy'
 
 class PerfCheck
   class TestCase
+    attr_reader :perf_check
     attr_accessor :resource
     attr_accessor :cookie, :this_response, :reference_response
     attr_accessor :this_profiles, :reference_profiles
 
-    def initialize(route)
+    def initialize(perf_check, route)
+      @perf_check = perf_check
       self.this_profiles = []
       self.reference_profiles = []
       self.resource = route
     end
 
-    def switch_to_reference_context
-      @context = :reference
-    end
-
     def run(server, options)
       unless options.diff
-        PerfCheck.logger.info("\t"+['request', 'latency', 'server rss', 'status', 'queries', 'profiler data'].map(&:underline).join("   "))
+        perf_check.logger.info("\t"+['request', 'latency', 'server rss', 'status', 'queries', 'profiler data'].map(&:underline).join("   "))
       end
 
-      profiles = (@context == :reference) ? reference_profiles : this_profiles
-
-      headers = {'Cookie' => "#{cookie}".strip}
-      headers['Accept'] = 'text/html,application/xhtml+xml,application/xml'
-      headers.merge!(PerfCheck.config.headers)
-
       (options.number_of_requests+1).times do |i|
-        profile = server.profile do |http|
-          http.get(resource, headers)
-        end
+        profile = issue_request(server, options)
+        next if i.zero? # first request just warms up the server
 
-        unless options.http_statuses.include? profile.response_code
-          if options.fail_fast?
-            File.open("tmp/perf_check/failed_request.html", 'w') do |error_dump|
-              error_dump.write(profile.response_body)
-            end
-            error = sprintf("\t%2i:\tFAILED! (HTTP %d)", i, profile.response_code)
-            PerfCheck.logger.fatal(error.red.bold)
-            PerfCheck.logger.fatal("\t   The server responded with a non-2xx status for this request.")
-            PerfCheck.logger.fatal("\t   The response has been written to tmp/perf_check/failed_request.html")
-            abort
-          end
-        end
-
-        next if i.zero?
-
-        if options.verify_responses
-          if i == 1
-            if @context == :reference
-              self.reference_response = profile.response_body
-            else
-              self.this_response = profile.response_body
-            end
-          end
+        if options.verify_responses && i == 1
+          response_for_comparison(profile.response_body)
         end
 
-        profile.server_memory = server.mem
-
         unless options.diff
           row = sprintf("\t%2i:\t  %.1fms   %4dMB\t  %s\t   %s\t   %s",
                         i, profile.latency, profile.server_memory,
                         profile.response_code, profile.query_count, profile.profile_url)
-          PerfCheck.logger.info(row)
+          perf_check.logger.info(row)
         end
 
-        profiles << profile
+        context_profiles << profile
+        unless options.http_statuses.include?(profile.response_code)
+          error = sprintf("\t  :\tFAILED! (HTTP %d)", profile.response_code)
+          perf_check.logger.warn(error.red.bold)
+          perf_check.logger.warn("\t   The server responded with an invalid http code")
+          if profile.backtrace
+            perf_check.logger.warn("Backtrace found:")
+            backtrace = [profile.backtrace[0], *profile.backtrace.grep(/#{perf_check.app_root}/)]
+            backtrace.each{ |line| perf_check.logger.warn("  #{line}") }
+          end
+          break
+        end
       end
 
-      PerfCheck.logger.info '' unless options.diff # pretty!
+      perf_check.logger.info '' unless options.diff # pretty!
     end
 
     def this_latency
@@ -96,7 +75,7 @@ class PerfCheck
       this_latency - reference_latency
     end
 
-    def latency_factor
+    def speedup_factor
       reference_latency / this_latency
     end
 
@@ -123,5 +102,35 @@ class PerfCheck
     def hash
       resource.hash
     end
+
+    def issue_request(server, options)
+      server.profile do |http|
+        http.get(resource, request_headers)
+      end
+    end
+
+    def request_headers
+      headers = {'Cookie' => "#{cookie}".strip}
+      headers['Accept'] = 'text/html,application/xhtml+xml,application/xml'
+      headers.merge!(perf_check.options.headers)
+    end
+
+    def switch_to_reference_context
+      @context = :reference
+    end
+
+    private
+
+    def context_profiles
+      (@context == :reference) ? reference_profiles : this_profiles
+    end
+
+    def response_for_comparison(response_body)
+      if @context == :reference
+        self.reference_response = response_body
+      else
+        self.this_response = response_body
+      end
+    end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: perf_check
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - rubytune
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-15 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +64,6 @@ files:
 - lib/perf_check/callbacks.rb
 - lib/perf_check/config.rb
 - lib/perf_check/git.rb
-- lib/perf_check/logger.rb
 - lib/perf_check/middleware.rb
 - lib/perf_check/output.rb
 - lib/perf_check/railtie.rb
@@ -76,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: PERF CHECKKK!

data/lib/perf_check/logger.rb

@@ -1,14 +0,0 @@
-
-require 'logger'
-
-class PerfCheck
-  def self.logger
-    @logger ||= Logger.new(STDERR).tap do |logger|
-      logger.formatter = proc do |severity, datetime, progname, msg|
-        "[#{datetime}] #{sprintf('%5s', severity)} --: #{msg}\n"
-      end
-    end
-  end
-
-  def logger; self.class.logger; end
-end