perf_check 0.1.18 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5210e19711849c1d31c9a59f11f3a7f492e9c48
-  data.tar.gz: e57b035135efc2569d20d3a18cb776c979894274
+  metadata.gz: b748791510099f0d04eccd3624623f0f268484a1
+  data.tar.gz: ebd96c65c3d27d78bd64cf01727e1e5a476e1d89
 SHA512:
-  metadata.gz: 588ac42f1b7b9b649f798395c8876430862f7fb6f56e56423172b65c8cc53f4a4390ceed18c1a73c2129649d54f3fcebc540dffce51f36f082ddc2ee9ffdc3a9
-  data.tar.gz: 85e004752e36cb9176ad4543dfee9d6ba9043d478ab58505f992b6267667ff2b0474040a3dae53717d8ddba3677b2b2ff5ea73a41b877f54bdc56135d5d0d8df
+  metadata.gz: ee57d225bcd04131ddbc874688eb383db6ca7296c44372e4e49bb0ab1b22f77088715e7cef012321594516620ff5a40aff528c19891ff5af69af3d249dd1de16
+  data.tar.gz: 0e4426dc65b80ef2ac67f931f1c84eed0dbbe6e3957a3844072ab02b9d7f2733be7a168601dd7d12156bb2e23417fa105fce613d7b02a3996d0ac13231e057f4

data/bin/perf_check

@@ -2,157 +2,38 @@
 
 require 'perf_check'
 
-perf_check = PerfCheck.new
-options = perf_check.options
-options.login = nil
-options.number_of_requests = 10
-options.reference = 'master'
-options.http_statuses = [200]
-options.verify_responses = false
-options.caching = true
-
 ORIGINAL_ARGV = ARGV.clone
 
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: perf_check [options] [route ...]"
-
-  opts.separator 'Login options:'
-  opts.on('--admin', 'Log in as admin user for route') do
-    options.login = :admin
-  end
-
-  opts.on('--standard', 'Log in as standard user for route') do
-    options.login = :standard
-  end
-
-  opts.on('--super', 'Log in as super user') do
-    options.login = :super
-  end
-
-  opts.on('--user USER', '-u', 'Log in as USER') do |user|
-    options.login = user
-  end
-
-  opts.on('--no-login', '-L', "Don't log in") do
-    options.login = nil
-  end
-
-  opts.separator "\nBenchmark options:"
-  opts.on('--requests N', '-n',
-          'Use N requests in benchmark, defaults to 10') do |n|
-    options.number_of_requests = n.to_i
-  end
-
-  opts.on('--reference COMMIT', '-r',
-          'Benchmark against COMMIT instead of master') do |commit|
-    options.reference = commit
-  end
-
-  opts.on('--quick', '-q',
-          'Fire off 5 requests just on this branch, no comparison with master') do
-    options.number_of_requests = 5
-    options.reference = nil
-  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
-    options[:fail_fast?] = true
-  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
-    options.http_statuses.delete(302)
-  end
-
-  opts.separator "\nMisc"
-  opts.on('--input FILE', '-i') do |input|
-    File.readlines(input).each do |resource|
-      ARGV << resource.strip
-    end
-  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
+perf_check = PerfCheck.new
 
-  opts.on('--brief', '-b') do
-    options.brief = true
-  end
+at_exit do
+  cbdata = {}
 
-  opts.on('--diff') do
-    options.diff = true
-    options.brief = true
-    options.verify_responses = true
-    options.number_of_requests = 1
+  if $!
+    cbdata[:error_message] = "#{$!.class}: #{$!.message}\n"
+    cbdata[:error_message] << $!.backtrace.map{|x| "\t#{x}"}.join("\n")
   end
 
-  opts.separator ''
-  opts.separator <<EOF
-Usage examples:
-  Benchmark PostController#index against master
-     perf_check /user/45/posts
-     perf_check /user/45/posts -n5
-     perf_check /user/45/posts --standard
-     perf_check /user/45/posts --admin
-
-  Benchmark against a specific commit
-     perf_check /user/45/posts -r 0123abcdefg
-     perf_check /user/45/posts -r HEAD~2
-
-  Benchmark the changes in the working tree
-     perf_check /user/45/posts -r HEAD
-
-  Benchmark and diff the output against master
-     perf_check /user/45/posts --verify-responses
-
-  Just diff the output on your branch with master
-     perf_check /user/45/posts --diff
-
-  Diff a bunch of urls listed in a file (newline seperated)
-    perf_check --diff --input FILE
-EOF
+  perf_check.trigger_when_finished_callbacks(cbdata)
 end
 
-error = nil
-begin
-  opts.parse!
+PerfCheck.load_config
+PerfCheck::Options.parse!
 
-  PerfCheck.require_rails(options)
+ARGV.each{ |route| perf_check.add_test_case(route) }
 
-  ARGV.each do |route|
-    perf_check.add_test_case(route)
-  end
-
-  if perf_check.test_cases.empty?
-    abort(opts.help)
-  end
-
-  perf_check.trigger_before_start_callback
+if perf_check.test_cases.empty?
+  abort(PerfCheck::Options.help)
+end
 
-  perf_check.sanity_check
-  perf_check.run
+perf_check.run
 
-  if options.brief
-    perf_check.print_brief_results
-  else
-    perf_check.print_results
-  end
-rescue Exception => error
-ensure
-  cbdata = {}
-  if error
-    cbdata[:error_message] = "#{error.class}: #{error.message}\n"
-    cbdata[:error_message] << error.backtrace.map{|x| "\t#{x}"}.join("\n")
-  end
-  perf_check.trigger_when_finished_callback(cbdata)
-  raise error if error
+if PerfCheck.config.brief
+  perf_check.print_brief_results
+elsif PerfCheck.config.json
+  perf_check.print_json_results
+else
+  perf_check.print_full_results
 end
 
 #            _______________________

data/lib/perf_check/git.rb

@@ -11,28 +11,42 @@ class PerfCheck
     def self.checkout_reference(reference='master')
       checkout(reference)
       at_exit do
-        $stderr.puts
-        Git.checkout_current_branch
+        logger.info ''
+        Git.checkout_current_branch(false)
       end
     end
 
-    def self.checkout_current_branch
-      checkout(@current_branch)
+    def self.checkout_current_branch(bundle=true)
+      checkout(@current_branch, bundle)
     end
 
-    def self.checkout(branch)
-      $stderr.print "Checking out #{branch} and bundling... "
+    def self.checkout(branch, bundle=true)
+      logger.info("Checking out #{branch} and bundling... ")
       `git checkout #{branch} --quiet`
-      abort "Problem with git checkout! Bailing..." unless $?.success?
-      `bundle`
-      abort "Problem bundling! Bailing..." unless $?.success?
+
+      unless $?.success?
+        logger.fatal("Problem with git checkout! Bailing...") && abort
+      end
+
+      `git submodule update --quiet`
+
+      if bundle
+        Bundler.with_clean_env{ `bundle` }
+        unless $?.success?
+          logger.fatal("Problem bundling! Bailing...") && abort
+        end
+      end
     end
 
     def self.stash_if_needed
       if anything_to_stash?
-        $stderr.print("Stashing your changes... ")
+        logger.info("Stashing your changes... ")
         system('git stash -q >/dev/null')
-        abort("Problem with git stash! Bailing...") unless $?.success?
+
+        unless $?.success?
+          logger.fatal("Problem with git stash! Bailing...") && abort
+        end
+
         at_exit do
           Git.pop
         end
@@ -46,13 +60,12 @@ class PerfCheck
     end
 
     def self.pop
-      warn("Git stash applying...")
+      logger.info("Git stash applying...")
       system('git stash pop -q')
-      abort("Problem with git stash! Bailing...") unless $?.success?
-    end
-  end
 
-  def self.normalize_resource(resource)
-    resource.sub(/^([^\/])/, '/\1')
+      unless $?.success?
+        logger.fatal("Problem with git stash! Bailing...") && abort
+      end
+    end
   end
 end

data/lib/perf_check/railtie.rb

@@ -1,9 +1,8 @@
 class PerfCheck
   class Railtie < Rails::Railtie
+    config.before_initialize do |app|
 
-    config.before_initialize do
-
-      if defined?(Rack::MiniProfiler) && ENV['PERF_CHECK']
+      if defined?(Rack::MiniProfiler)
         # Integrate with rack-mini-profiler
         tmp = "#{Rails.root}/tmp/perf_check/miniprofiler"
         FileUtils.mkdir_p(tmp)
@@ -12,19 +11,20 @@ class PerfCheck
           Rack::MiniProfiler::FileStore.new(:path => tmp)
       end
 
-      if ENV['PERF_CHECK']
-        # Force cacheing .... :\
-        config = Rails::Application::Configuration
-        config.send(:define_method, :cache_classes){ true }
+      # Force caching .... :\
+      config = Rails::Application::Configuration
+      config.send(:define_method, :cache_classes){ true }
 
-        fragment_caching = !ENV['PERF_CHECK_NOCACHING']
-        config = ActiveSupport::Configurable::Configuration
-        config.send(:define_method, :perform_caching){ fragment_caching }
-      end
+      fragment_caching = !ENV['PERF_CHECK_NOCACHING']
+      config = ActiveSupport::Configurable::Configuration
+      config.send(:define_method, :perform_caching){ fragment_caching }
 
-      if ENV['PERF_CHECK'] && ENV['PERF_CHECK_VERIFICATION']
+      if ENV['PERF_CHECK_VERIFICATION']
         PerfCheck::Server.seed_random!
       end
+
+      require 'perf_check/middleware'
+      app.middleware.use PerfCheck::Middleware
     end
   end
 end

data/lib/perf_check/server.rb

@@ -6,54 +6,6 @@ require 'fileutils'
 
 class PerfCheck
   class Server
-    def self.authorization(&block)
-      define_method(:login, &block)
-    end
-
-    def self.authorization_action(method, login_route, &block)
-      Rails.application.reload_routes!
-      p = PerfCheck::Server.recognize_path(login_route, :method => method)
-      controller = "#{p[:controller]}_controller".classify.constantize
-      action = p[:action]
-
-      controller.send(:define_method, :get_perf_check_session, &block)
-      controller.send(:define_method, action) do
-        login = params[:login_symbol].presence.try(:to_sym) || params[:login]
-        get_perf_check_session(login, params[:route])
-        render :nothing => true
-      end
-      controller.send(:skip_before_filter, :verify_authenticity_token)
-
-      authorization do |login, route|
-        http = Net::HTTP.new(host, port)
-        params = login.is_a?(Symbol) ? "login_symbol=#{login}" : "login=#{login}"
-        if method == :post
-          response = http.post(login_route, params)
-        elsif method == :get
-          response = http.get(login_route+"?#{params}")
-        end
-
-        response['Set-Cookie']
-      end
-    end
-
-    def self.mounted_path(engine)
-      route = Rails.application.routes.routes.detect do |route|
-        route.app == engine
-      end
-      route && route.path
-    end
-
-    def self.recognize_path(path, opts={})
-      Rails::Engine.subclasses.each do |engine|
-        if match = mounted_path(engine) =~ path
-          path = path.sub(match.to_s, '')
-          return engine.routes.recognize_path(path, opts)
-        end
-      end
-      Rails.application.routes.recognize_path(path, opts)
-    end
-
     def self.seed_random!
       # Seed random
       srand(1)
@@ -80,27 +32,12 @@ class PerfCheck
       end
     end
 
-    def self.sign_cookie_data(key, data, opts={})
-      opts[:serializer] ||= Marshal
-      secret = Rails.application.config.secret_token
-
-      marshal = ActiveSupport::MessageVerifier.new(secret,
-                                                   :serializer => opts[:serializer])
-      marshal_value = marshal.generate(data)
-
-      "#{key}=#{marshal_value}"
-    end
-
     def initialize
       at_exit do
-        exit
+        exit rescue nil
       end
     end
 
-    def login(login, route)
-      ''
-    end
-
     def pid
       pidfile = 'tmp/pids/server.pid'
       File.read(pidfile).to_i if File.exists?(pidfile)
@@ -130,14 +67,16 @@ class PerfCheck
       response = nil
       prepare_to_profile
 
-      latency = 1000 * Benchmark.measure do
-        http.start
-        response = yield(http)
-        http.finish
-      end.real
+      http.start
+      response = yield(http)
+      http.finish
+
+      latency = 1000 * response['X-Runtime'].to_f
+      query_count = response['X-PerfCheck-Query-Count'].to_i
 
       Profile.new.tap do |result|
         result.latency = latency
+        result.query_count = query_count
         result.profile_url = latest_profiler_url
         result.response_body = response.body
         result.response_code = response.code.to_i
@@ -153,6 +92,14 @@ class PerfCheck
     end
 
     def start
+      ENV['PERF_CHECK'] = '1'
+      if PerfCheck.config.verify_responses
+        ENV['PERF_CHECK_VERIFICATION'] = '1'
+      end
+      unless PerfCheck.config.caching
+        ENV['PERF_CHECK_NOCACHING'] = '1'
+      end
+
       system('rails server -b 127.0.0.1 -d -p 3031 >/dev/null')
       sleep(1.5)
 
@@ -161,10 +108,10 @@ class PerfCheck
 
     def restart
       if !@running
-        $stderr.print "starting rails...\n"
+        logger.info("starting rails...")
         start
       else
-        $stderr.print "re-starting rails...\n"
+        logger.info("re-starting rails...")
         exit
         start
       end

data/lib/perf_check/test_case.rb

@@ -4,19 +4,13 @@ require 'diffy'
 
 class PerfCheck
   class TestCase
-    attr_accessor :resource, :controller, :action, :format
+    attr_accessor :resource
     attr_accessor :cookie, :this_response, :reference_response
     attr_accessor :this_profiles, :reference_profiles
 
     def initialize(route)
-      params = PerfCheck::Server.recognize_path(route)
-
       self.this_profiles = []
       self.reference_profiles = []
-
-      self.controller = params[:controller]
-      self.action = params[:action]
-      self.format = params[:format]
       self.resource = route
     end
 
@@ -26,19 +20,14 @@ class PerfCheck
 
     def run(server, options)
       unless options.diff
-        print("\t"+'request #'.underline)
-        print("  "+'latency'.underline)
-        print("   "+'server rss'.underline)
-        print("   "+'status'.underline)
-        puts("   "+'profiler data'.underline)
+        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}"}
-      unless self.format
-        headers['Accept'] = 'text/html,application/xhtml+xml,application/xml'
-      end
+      headers = {'Cookie' => "#{cookie}".strip}
+      headers['Accept'] = 'text/html,application/xhtml+xml,application/xml'
+
       (options.number_of_requests+1).times do |i|
         profile = server.profile do |http|
           http.get(resource, headers)
@@ -50,10 +39,10 @@ class PerfCheck
               error_dump.write(profile.response_body)
             end
             error = sprintf("\t%2i:\tFAILED! (HTTP %d)", i, profile.response_code)
-            puts(error.red.bold)
-            puts("\t   The server responded with a non-2xx status for this request.")
-            puts("\t   The response has been written to tmp/perf_check/failed_request.html")
-            exit(1)
+            logger.fatal(error.red.bold)
+            logger.fatal("\t   The server responded with a non-2xx status for this request.")
+            logger.fatal("\t   The response has been written to tmp/perf_check/failed_request.html")
+            abort
           end
         end
 
@@ -69,15 +58,19 @@ class PerfCheck
           end
         end
 
+        profile.server_memory = server.mem
+
         unless options.diff
-          printf("\t%2i:\t   %.1fms   %4dMB\t  %s\t   %s\n",
-                 i, profile.latency, server.mem,
-                 profile.response_code, profile.profile_url)
+          row = sprintf("\t%2i:\t  %.1fms   %4dMB\t  %s\t   %s",
+                        i, profile.latency, profile.server_memory,
+                        profile.response_code, profile.query_count, profile.profile_url)
+          logger.info(row)
         end
 
         profiles << profile
       end
-      puts unless options.diff # pretty!
+
+      logger.info '' unless options.diff # pretty!
     end
 
     def this_latency
@@ -89,6 +82,15 @@ class PerfCheck
       reference_profiles.map(&:latency).inject(0.0, :+) / reference_profiles.size
     end
 
+    def this_query_count
+      this_profiles.map(&:query_count).inject(0, :+) / this_profiles.size
+    end
+
+    def reference_query_count
+      return nil if reference_profiles.empty?
+      reference_profiles.map(&:query_count).inject(0, :+) / reference_profiles.size
+    end
+
     def latency_difference
       this_latency - reference_latency
     end

data/lib/perf_check.rb

@@ -1,56 +1,27 @@
-# coding: utf-8
-
-require 'optparse'
 require 'net/http'
 require 'digest'
 require 'fileutils'
 require 'benchmark'
 require 'ostruct'
 require 'colorize'
+require 'json'
 
 class PerfCheck
   attr_accessor :options, :server, :test_cases
 
-  def self.diff_options
-    @@diff_options ||=
-      ['-U3', '--ignore-matching-lines=/mini-profiler-resources/includes.js']
-  end
-
-  def self.require_rails(options)
-    ENV['PERF_CHECK'] = '1'
-    if options.verify_responses
-      ENV['PERF_CHECK_VERIFICATION'] = '1'
-    end
-    if !options.caching
-      ENV['PERF_CHECK_NOCACHING'] = '1'
-    end
+  def self.app_root
+    @app_root ||= begin
+      dir = Dir.pwd
+      until dir == '/' || File.exist?("#{dir}/config/application.rb")
+        dir = File.dirname(dir)
+      end
 
-    app_root = Dir.pwd
-    until app_root == '/' || File.exist?("#{app_root}/config/application.rb")
-      app_root = File.dirname(app_root)
-    end
+      unless File.exist?("#{dir}/config/application.rb")
+        abort("perf_check should be run from a rails directory")
+      end
 
-    unless File.exist?("#{app_root}/config/application.rb")
-      abort("perf_check should be run from a rails directory")
+      dir
     end
-
-    require "#{app_root}/config/environment"
-  end
-
-  def self.when_finished(&block)
-    @when_finished_callback = block
-  end
-
-  def self.when_finished_callback
-    @when_finished_callback || proc{ |*args| }
-  end
-
-  def self.before_start(&block)
-    @before_start_callback = block
-  end
-
-  def self.before_start_callback
-    @before_start_callback || proc{ |*args| }
   end
 
   def initialize
@@ -60,139 +31,52 @@ class PerfCheck
   end
 
   def add_test_case(route)
-    route = PerfCheck.normalize_resource(route)
-    test_cases.push(TestCase.new(route))
-  end
-
-  def sanity_check
-    if ENV['RAILS_ENV'] == 'production'
-      abort("perf_check cannot be run in the production environment")
-    end
-
-    if Git.current_branch == "master"
-      puts("Yo, profiling master vs. master isn't too useful, but hey, we'll do it")
-    end
-
-    puts "="*77
-    print "PERRRRF CHERRRK! Grab a ☕️  and don't touch your working tree "
-    puts "(we automate git)"
-    puts "="*77
+    test_cases.push(TestCase.new(route.sub(/^([^\/])/, '/\1')))
   end
 
   def run
-    (options.reference ? 2 : 1).times do |i|
-      if i == 1
-        Git.stash_if_needed
-        Git.checkout_reference(options.reference)
-        test_cases.each{ |x| x.switch_to_reference_context }
-      end
-
-      server.restart
-      test_cases.each_with_index do |test, i|
-        server.restart unless i.zero? || options.diff
-
-        if options.login
-          test.cookie = server.login(options.login, test)
-        end
-
-        if options.diff
-          puts "Issuing #{test.resource}"
-        else
-          puts("\nBenchmarking #{test.resource}:")
-        end
-        test.run(server, options)
-      end
-    end
-  end
-
-  def trigger_before_start_callback
-    PerfCheck.before_start_callback.call(self)
-  end
-
-  def trigger_when_finished_callback(data={})
-    data = data.merge(:current_branch => PerfCheck::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_callback.call(results)
-  end
-
-  def print_diff_results(diff)
-    if diff.changed?
-      print(" Diff: #{diff.file}".bold.light_red)
-    else
-      print(" Diff: Output is identical!".bold.light_green)
-    end
-  end
-
-  def print_brief_results
-    test_cases.each do |test|
-      print(test.resource.ljust(40) + ': ')
-
-      codes = (test.this_profiles+test.reference_profiles).map(&:response_code).uniq
-      print("(HTTP "+codes.join(',')+") ")
+    trigger_before_start_callbacks
 
-      printf('%.1fms', test.this_latency)
+    profile_requests
 
-      puts && next if test.reference_profiles.empty?
+    if options.reference
+      Git.stash_if_needed
+      Git.checkout_reference(options.reference)
+      test_cases.each{ |x| x.switch_to_reference_context }
 
-      print(sprintf(' (%+5.1fms)', test.latency_difference).bold)
-      print_diff_results(test.response_diff) if options.verify_responses
-      puts
+      profile_requests
     end
   end
 
-  def print_results
-    puts("==== Results ====")
-    test_cases.each do |test|
-      puts(test.resource.bold)
+  private
 
-      if test.reference_profiles.empty?
-        printf("your branch: ".rjust(15)+"%.1fms\n", test.this_latency)
-        next
-      end
+  def profile_requests
+    server.restart
+    test_cases.each_with_index do |test, i|
+      server.restart unless i.zero? || options.diff
 
-      master_latency = sprintf('%.1fms', test.reference_latency)
-      this_latency = sprintf('%.1fms', test.this_latency)
-      difference = sprintf('%+.1fms', test.latency_difference)
+      test.cookie = options.cookie
 
-      if test.latency_difference < 0
-        change_factor = test.reference_latency / test.this_latency
-      else
-        change_factor = test.this_latency / test.reference_latency
-      end
-      formatted_change = sprintf('%.1fx', change_factor)
-
-      percent_change = 100*(test.latency_difference / test.reference_latency).abs
-      if percent_change < 10
-        formatted_change = "yours is about the same"
-        color = :blue
-      elsif test.latency_difference < 0
-        formatted_change = "yours is #{formatted_change} faster!"
-        color = :green
+      if options.diff
+        logger.info("Issuing #{test.resource}")
       else
-        formatted_change = "yours is #{formatted_change} slower!!!"
-        color = :light_red
+        logger.info ''
+        logger.info("Benchmarking #{test.resource}:")
       end
-      formatted_change = difference + " (#{formatted_change})"
 
-      puts("master: ".rjust(15)     + "#{master_latency}")
-      puts("your branch: ".rjust(15)+ "#{this_latency}")
-      puts(("change: ".rjust(15)     + "#{formatted_change}").bold.send(color))
-
-      print_diff_results(test.response_diff) if options.verify_responses
+      test.run(server, options)
     end
   end
 end
 
-
+require 'perf_check/logger'
 require 'perf_check/server'
 require 'perf_check/test_case'
 require 'perf_check/git'
+require 'perf_check/config'
+require 'perf_check/callbacks'
+require 'perf_check/output'
 
-if defined?(Rails)
+if defined?(Rails) && ENV['PERF_CHECK']
   require 'perf_check/railtie'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: perf_check
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.2.1
 platform: ruby
 authors:
 - rubytune