derailed_benchmarks 0.0.0 → 1.0.0

data/Rakefile

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler'
+require "bundler/gem_tasks"
+
+begin
+  Bundler.setup(:default, :development, :test)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test
+
+

data/bin/derailed

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+unless File.respond_to? :realpath
+  class File #:nodoc:
+    def self.realpath path
+      return realpath(File.readlink(path)) if symlink?(path)
+      path
+    end
+  end
+end
+lib = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/../lib')
+$: << lib
+
+
+require File.join(lib, 'derailed_benchmarks.rb')
+require 'bundler'
+Bundler.setup
+
+require 'thor'
+
+class DerailedBenchmarkCLI < Thor
+
+  desc "exec", "executes given derailed benchmark"
+  def exec(task = nil)
+    require 'derailed_benchmarks'
+    require 'rake'
+    Rake::TaskManager.record_task_metadata = true
+    require 'derailed_benchmarks/tasks'
+
+    perf_rakefile = File.expand_path(".", "perf.rake")
+    load perf_rakefile if File.exist?(perf_rakefile)
+
+    if task.nil? || task == "--help"
+      Rake.application.tasks.map do |task, n|
+        next unless task.comment
+        puts "  $ derailed exec #{task.name}  # #{task.comment}"
+      end
+    else
+      task = "perf:#{task}" unless Rake::Task.task_defined?(task)
+      Rake::Task[task].invoke
+    end
+  end
+
+  desc "bundle:objects", "measures objects created by gems"
+  define_method(:"bundle:objects") do |env = "production"|
+    setup_bundler!
+    env = [:default] + env.split(",")
+    puts "Measuring objects created by gems in groups #{ env.inspect }"
+    require 'memory_profiler'
+    report = MemoryProfiler.report do
+      Bundler.require(*env)
+    end
+    report.pretty_print
+  end
+
+  map :"bundler:objects" => :"bundle:objects"
+
+  desc "bundle:mem", "measures memory used by gems at boot time"
+  define_method(:"bundle:mem") do |env = "production"|
+    env = [:default] + env.split(",")
+    require 'get_process_mem'
+    mem    = GetProcessMem.new
+    require 'derailed_benchmarks/core_ext/kernel_require'
+    before = mem.mb
+    setup_bundler!
+    Bundler.require(*env)
+    after  = mem.mb
+    TOP_REQUIRE.print_sorted_children
+  end
+  map :"bundler:mem" => :"bundle:mem"
+
+  private
+    def setup_bundler!
+      ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+      require 'bundler/setup'
+
+      begin
+        require 'rails/all'
+      rescue LoadError
+      end
+    end
+end
+
+DerailedBenchmarkCLI.start(ARGV)

data/derailed_benchmarks.gemspec

@@ -21,5 +21,10 @@ Gem::Specification.new do |gem|
   gem.add_dependency "memory_profiler", "~> 0"
   gem.add_dependency "get_process_mem", "~> 0"
   gem.add_dependency "benchmark-ips",   "~> 2"
-end
+  gem.add_dependency "rack",            "~> 1"
+  gem.add_dependency "rake",            "~> 10.4"
 
+  gem.add_development_dependency "capybara", "~> 2"
+  gem.add_development_dependency "rails",    "~> 3"
+  gem.add_development_dependency "devise",   "~> 3"
+end

data/lib/derailed_benchmarks.rb

@@ -1,2 +1,34 @@
+require 'time'
+
+require 'rack/test'
+require 'rack/file'
+require 'benchmark/ips'
+require 'get_process_mem'
+require 'bundler'
+
 module DerailedBenchmarks
+  def self.gem_is_bundled?(name)
+    specs = ::Bundler.locked_gems.specs.each_with_object({}) {|spec, hash| hash[spec.name] = spec }
+    specs[name]
+  end
+
+  class << self
+    attr_accessor :auth
+  end
+
+  def self.add_auth(app)
+    if use_auth = ENV['USE_AUTH']
+      puts "Auth: #{use_auth}"
+      auth.add_app(app)
+    else
+      app
+    end
+  end
+end
+
+require 'derailed_benchmarks/require_tree'
+require 'derailed_benchmarks/auth_helper'
+
+if DerailedBenchmarks.gem_is_bundled?("devise")
+  DerailedBenchmarks.auth = DerailedBenchmarks::AuthHelpers::Devise.new
 end

data/lib/derailed_benchmarks/auth_helper.rb

@@ -0,0 +1,32 @@
+require 'securerandom'
+
+module DerailedBenchmarks
+  # Base helper class. Can be used to authenticate different strategies
+  # The root app will be wrapped by an authentication action
+  class AuthHelper
+    attr_reader   :app
+
+    # Put any coded needed to set up or initialize your authentication module here
+    def setup
+      raise "Must subclass"
+    end
+
+    # Gets called for every request. Place all auth logic here.
+    # Return value is expected to be an valid Rack response array.
+    # If you do not manually `app.call(env)` here, the client app
+    # will never be called.
+    def call(env)
+      raise "Must subclass"
+    end
+
+    # Returns self and sets the target app
+    def add_app(app)
+      raise "App is required argument" unless app
+      @app = app
+      setup
+      self
+    end
+  end
+end
+
+require 'derailed_benchmarks/auth_helpers/devise'

data/lib/derailed_benchmarks/auth_helpers/devise.rb

@@ -0,0 +1,36 @@
+module DerailedBenchmarks
+  class AuthHelpers
+    # Devise helper for authenticating requests
+    # Setup adds necessarry test methods, user provides a sample user.
+    # The authenticate method is called on every request when authentication is enabled
+    class Devise < AuthHelper
+      attr_accessor :user
+
+      # Include devise test helpers and turn on test mode
+      # We need to do this on the class level
+      def setup
+        # self.class.instance_eval do
+          require 'devise'
+          require 'warden'
+          extend ::Warden::Test::Helpers
+          extend ::Devise::TestHelpers
+          Warden.test_mode!
+        # end
+      end
+
+      def user
+        @user ||= begin
+          password = SecureRandom.hex
+          User.first_or_create!(email: "#{SecureRandom.hex}@example.com", password: password, password_confirmation: password)
+        end
+      end
+
+      # Logs the user in, then call the parent app
+      def call(env)
+        login_as(user)
+        app.call(env)
+      end
+    end
+  end
+end
+

data/lib/derailed_benchmarks/core_ext/kernel_require.rb

@@ -0,0 +1,72 @@
+require 'get_process_mem'
+require 'derailed_benchmarks/require_tree'
+
+ENV['CUT_OFF'] ||= "0.3"
+
+# This file contains classes and monkey patches to measure the amount of memory
+# useage requiring an individual file adds.
+
+# Monkey patch kernel to ensure that all `require` calls call the same
+# method
+module Kernel
+  alias :original_require :require
+  REQUIRE_STACK = []
+
+  def require(file)
+    Kernel.require(file)
+  end
+
+  # This breaks things, not sure how to fix
+  # def require_relative(file)
+  #   Kernel.require_relative(file)
+  # end
+  class << self
+    alias :original_require          :require
+    # alias :original_require_relative :require_relative
+  end
+
+  # The core extension we use to measure require time of all requires
+  # When a file is required we create a tree node with its file name.
+  # We then push it onto a stack, this is because requiring a file can
+  # require other files before it is finished.
+  #
+  # When a child file is required, a tree node is created and the child file
+  # is pushed onto the parents tree. We then repeat the process as child
+  # files may require additional files.
+  #
+  # When a require returns we remove it from the require stack so we don't
+  # accidentally push additional children nodes to it. We then store the
+  # memory cost of the require in the tree node.
+  def self.measure_memory_impact(file, &block)
+    mem    = GetProcessMem.new
+    node   = DerailedBenchmarks::RequireTree.new(file)
+
+    parent = REQUIRE_STACK.last
+    parent << node
+    REQUIRE_STACK.push(node)
+    begin
+      before = mem.mb
+      block.call file
+    ensure
+      REQUIRE_STACK.pop # node
+      after = mem.mb
+    end
+    node.cost = after - before
+  end
+end
+
+# Top level node that will store all require information for the entire app
+TOP_REQUIRE = DerailedBenchmarks::RequireTree.new("TOP")
+REQUIRE_STACK.push(TOP_REQUIRE)
+
+Kernel.define_singleton_method(:require) do |file|
+  measure_memory_impact(file) { |file| original_require(file) }
+end
+
+# Don't forget to assign a cost to the top level
+cost_before_requiring_anything = GetProcessMem.new.mb
+TOP_REQUIRE.cost = cost_before_requiring_anything
+def TOP_REQUIRE.print_sorted_children(*args)
+  self.cost = GetProcessMem.new.mb - self.cost
+  super
+end

data/lib/derailed_benchmarks/require_tree.rb

@@ -0,0 +1,45 @@
+# Tree structure used to store and sort require memory costs
+# RequireTree.new('get_process_mem')
+module DerailedBenchmarks
+  class RequireTree
+    attr_reader   :name
+    attr_accessor :cost
+
+    def initialize(name)
+      @name     = name
+      @children = {}
+    end
+
+    def <<(tree)
+      @children[tree.name.to_s] = tree
+    end
+
+    def [](name)
+      @children[name.to_s]
+    end
+
+    # Returns array of child nodes
+    def children
+      @children.values
+    end
+
+    def cost
+      @cost || 0
+    end
+
+    # Returns sorted array of child nodes from Largest to Smallest
+    def sorted_children
+      children.sort { |c1, c2| c2.cost <=> c1.cost }
+    end
+
+    # Recursively prints all child nodes
+    def print_sorted_children(level = 0, out = STDOUT)
+      return if cost < ENV['CUT_OFF'].to_f
+      out.puts "  " * level + "#{name}: #{cost.round(4)} mb"
+      level += 1
+      sorted_children.each do |child|
+        child.print_sorted_children(level, out)
+      end
+    end
+  end
+end

data/lib/derailed_benchmarks/tasks.rb

@@ -1,14 +1,6 @@
-namespace :perf do
-  task :setup do
-    require 'benchmark/ips'
-    require 'rack/file'
-    require 'time'
-    require 'rack/test'
-
-    require 'get_process_mem'
-
-    TEST_COUNT         = (ENV['TEST_COUNT'] || ENV['CNT'] || 1_000).to_i
 
+namespace :perf do
+  task :rails_load do
     ENV["RAILS_ENV"] ||= "production"
     ENV['RACK_ENV']  = ENV["RAILS_ENV"]
     ENV["DISABLE_SPRING"] = "true"
@@ -17,49 +9,90 @@ namespace :perf do
 
     ENV['LOG_LEVEL'] = "FATAL"
 
-    '.:lib:test:config'.split(':').each { |x| $: << x }
+    require 'rails'
+
+    puts "Booting: #{Rails.env}"
+
+    %W{ . lib test config }.each do |file|
+      $LOAD_PATH << file
+    end
 
     require 'application'
 
     Rails.env = ENV["RAILS_ENV"]
 
-    APP = Rails.application
-    # puts APP.method(:initialize!).source_location
+    DERAILED_APP = Rails.application
 
-    APP.initialize! unless APP.initialized?
-    ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
-    ActiveRecord::Migration.verbose = true
-    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, nil)
+    if DERAILED_APP.respond_to?(:initialized?)
+      DERAILED_APP.initialize! unless DERAILED_APP.initialized?
+    else
+      DERAILED_APP.initialize! unless DERAILED_APP.instance_variable_get(:@initialized)
+    end
 
-    APP.config.consider_all_requests_local = true
+    if defined? ActiveRecord
+      if defined? ActiveRecord::Tasks::DatabaseTasks
+        ActiveRecord::Tasks::DatabaseTasks.create_current
+      else # Rails 3.2
+        raise "No valid database for #{ENV['RAILS_ENV']}, please create one" unless ActiveRecord::Base.connection.active?.inspect
+      end
 
+      ActiveRecord::Migrator.migrations_paths = DERAILED_APP.paths['db/migrate'].to_a
+      ActiveRecord::Migration.verbose         = true
+      ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, nil)
+    end
 
-    @app = Rack::MockRequest.new(APP)
+    DERAILED_APP.config.consider_all_requests_local = true
+  end
 
-    puts "Booting: #{Rails.env}"
+  task :rack_load do
+    puts "You're not using Rails"
+    puts "You need to tell derailed how to boot your app"
+    puts "In your perf.rake add:"
+    puts
+    puts "namespace :perf do"
+    puts "  task :rack_load do"
+    puts "    # DERAILED_APP = your code here"
+    puts "  end"
+    puts "end"
+  end
+
+  task :setup do
+    if DerailedBenchmarks.gem_is_bundled?("railties")
+      Rake::Task["perf:rails_load"].invoke
+    else
+      Rake::Task["perf:rack_load"].invoke
+    end
+
+    TEST_COUNT  = (ENV['TEST_COUNT'] || ENV['CNT'] || 1_000).to_i
+    PATH_TO_HIT = ENV["PATH_TO_HIT"] || ENV['ENDPOINT'] || "/"
+    puts "Endpoint: #{ PATH_TO_HIT.inspect }"
 
-    PATH_TO_HIT = ENV["PATH_TO_HIT"] || "/"
+    DERAILED_APP = DerailedBenchmarks.add_auth(DERAILED_APP)
     if server = ENV["USE_SERVER"]
       @port = (3000..3900).to_a.sample
+      puts "Port: #{ @port.inspect }"
+      puts "Server: #{ server.inspect }"
       thread = Thread.new do
-        Rack::Server.start(app: APP, :Port => @port, environment: "none", server: server)
+        Rack::Server.start(app: DERAILED_APP, :Port => @port, environment: "none", server: server)
       end
       sleep 1
 
-      def call_app
-        `curl http://localhost:#{@port}#{PATH_TO_HIT} -s`
-        raise "Bad request: #{response.body}" unless $?.success?
+      def call_app(path = File.join("/", PATH_TO_HIT))
+        cmd = "curl http://localhost:#{@port}#{path} -s --fail 2>&1"
+        response = `#{cmd}`
+        raise "Bad request to #{cmd.inspect} Response:\n#{ response.inspect }" unless $?.success?
       end
     else
+      @app = Rack::MockRequest.new(DERAILED_APP)
+
       def call_app
         response = @app.get(PATH_TO_HIT)
-        raise "Bad request: #{response.body}" unless response.status == 200
+        raise "Bad request: #{ response.body }" unless response.status == 200
         response
       end
     end
   end
 
-
   desc "hits the url TEST_COUNT times"
   task :test => [:setup] do
     Benchmark.bm { |x|
@@ -71,9 +104,15 @@ namespace :perf do
     }
   end
 
+  desc "stackprof"
   task :stackprof => [:setup] do
     # [:wall, :cpu, :object]
-    require 'stackprof'
+    begin
+      require 'stackprof'
+    rescue LoadError
+      raise "Add stackprof to your gemfile to continue `gem 'stackprof', group: :development`"
+    end
+    TEST_COUNT = (ENV["TEST_COUNT"] ||= "100").to_i
     file = "tmp/#{Time.now.iso8601}-stackprof-cpu-myapp.dump"
     StackProf.run(mode: :cpu, out: file) do
       Rake::Task["perf:test"].invoke
@@ -84,86 +123,11 @@ namespace :perf do
   end
 
   task :kernel_require_patch do
-    require 'get_process_mem'
-
-    class RequireTree
-      attr_reader :name
-      attr_accessor :cost
-
-      def initialize(name)
-        @name = name
-        @children = {}
-      end
-
-      def <<(tree)
-        @children[tree.name] = tree
-      end
-
-      def [](name)
-        @children[name]
-      end
-
-      def children
-        @children.values
-      end
-
-      def cost
-        @cost || 0
-      end
-
-      def sorted_children
-        children.sort { |c1, c2| c2.cost <=> c1.cost }
-      end
-
-      def print_sorted_children(level = 0)
-        return if cost < ENV['CUT_OFF'].to_f
-        puts "  " * level + "#{name}: #{cost.round(4)} mb"
-        level += 1
-        sorted_children.each do |child|
-          child.print_sorted_children(level)
-        end
-      end
-    end
-
-
-
-    module Kernel
-      alias :original_require :require
-      REQUIRE_STACK = []
-
-      def require file
-        Kernel.require(file)
-      end
-
-      class << self
-        alias :original_require :require
-      end
-    end
-
-    TOP_REQUIRE = RequireTree.new("TOP")
-    REQUIRE_STACK.push(TOP_REQUIRE)
-
-    Kernel.define_singleton_method(:require) do |file|
-      mem    = GetProcessMem.new
-      node   = RequireTree.new(file)
-
-      parent = REQUIRE_STACK.last
-      parent << node
-      REQUIRE_STACK.push(node)
-      begin
-        before = mem.mb
-        original_require file
-      ensure
-        REQUIRE_STACK.pop # node
-        after = mem.mb
-      end
-      node.cost = after - before
-    end
+    require 'derailed_benchmarks/core_ext/kernel_require.rb'
   end
 
   desc "show memory usage caused by invoking require per gem"
-  task :require_bench => [:kernel_require_patch , :setup] do
-    ENV['CUT_OFF'] ||= "0.3"
+  task :mem => [:kernel_require_patch, :setup] do
     puts "## Impact of `require <file>` on RAM"
     puts
     puts "Showing all `require <file>` calls that consume #{ENV['CUT_OFF']} mb or more of RSS"
@@ -176,9 +140,7 @@ namespace :perf do
 
     call_app
 
-    TOP_REQUIRE.sorted_children.each do |child|
-      child.print_sorted_children
-    end
+    TOP_REQUIRE.print_sorted_children
   end
 
   desc "outputs ram usage over time"
@@ -273,7 +235,7 @@ namespace :perf do
 
 
   desc "profiles ruby allocation"
-  task :mem => [:setup] do
+  task :objects => [:setup] do
     require 'memory_profiler'
     call_app
     GC.start
@@ -287,5 +249,4 @@ namespace :perf do
     end
     report.pretty_print
   end
-
 end