derailed_benchmarks 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de696c65bb7e1fd25ec48fed45e6c8b6d7051c3f
+  data.tar.gz: 60f83ef96828857be4e501da08d95a449ab71a00
+SHA512:
+  metadata.gz: 0852320d09632e4bb7a4e47dad84128708fa25b01c5ccd007d1ff66a4e05d1ed93097442759cee7d043dd3240d04f618a7b3e320b4e6eea0ac24fe1a5334bdc2
+  data.tar.gz: 085ea3fde49d10c5cc2c23d77a8c2891cb6888b33c176f573d027268260e6e8d14aee0f91b9d5eccc5993696c27ebe4b3683e3eef43e75b878d5bf665aea79af

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/README.md

@@ -0,0 +1,134 @@
+## Derailed Benchmarks
+
+A series of things you can use to benchmark a Rails app
+
+## Install
+
+Put this in your gemfile:
+
+```
+gem 'derailed_benchmarks' group: :development
+```
+
+Then run `$ bundle install`.
+
+This part is **important** run this command to create a `perf.rake`
+
+```
+$ cat <<  EOF > perf.rake
+  require 'bundler'
+  Bundler.setup
+
+  require 'derailed_benchmarks'
+  require 'derailed_benchmarks/tasks'
+EOF
+```
+
+The file should look like this:
+
+```
+$ cat perf.rake
+  require 'bundler'
+  Bundler.setup
+
+  require 'derailed_benchmarks'
+  require 'derailed_benchmarks/tasks'
+```
+
+This is done so the benchmarks will be loaded before your application, this is important for some benchmarks and less for others. This also prevents you from accidentally loading these benchmarks when you don't need them.
+
+## Run
+
+To find out the tasks available you can use `$ rake -f perf.rake -T` which essentially says use the file `perf.rake` and list all the tasks.
+
+```
+$ rake -f perf.rake -T
+rake perf:allocated_objects  # outputs allocated object diff after app is called TEST_COUNT times
+rake perf:ips                # ips
+rake perf:mem                # profiles ruby allocation
+rake perf:ram_over_time      # outputs ram usage over time
+rake perf:require_bench      # show memory usage caused by invoking require per gem
+rake perf:stackprof          # sampling stack time
+rake perf:test               # hits the url TEST_COUNT times
+```
+
+All the rake tasks accept configuration in the form of environment variables. For example, this command will measure the time it takes to hit your site `100,000` times:
+
+```
+$ rake -f perf.rake perf:test TEST_COUNT=100_000
+```
+
+
+## Config
+
+Here are the common environment variables.
+
+### PATH_TO_HIT
+
+By default tasks will hit your homepage `/`. If you want to hit a different url use `PATH_TO_HIT` for example if you wanted to go to `users/new` you can execute:
+
+```
+PATH_TO_HIT=/users/new
+```
+
+### USE_SERVER
+
+All tests are run without a webserver by default, if you want to use a webserver set `USE_SERVER` to a Rack::Server compliant server, such as `webrick`.
+
+```
+USE_SERVER=webrick
+```
+
+### TEST_COUNT
+
+If the test contains an interation (most of them do), control how many times the test will loop before exiting with `TEST_COUNT`. To run `1` time you can execute
+
+```
+TEST_COUNT=1
+```
+
+Note some tasks have different defaults.
+
+
+## Task Specific notes
+
+
+### perf:mem
+
+This task uses `memory_profiler` to see where memory is allocated while it is running. By default it will iterate once
+
+
+### perf:ips
+
+Determines the number of times your app can serve a web request each second (iterations per second). Higher number is better. Note this will be much larger if you do not use a server.
+
+
+### perf:ram_over_time
+
+Your app will use memory differently over time, this task records RSS memory usage every 5 seconds and outputs the value to STDOUT and to a file in `tmp/`. You can use this to build graphs (https://drive.google.com).
+
+
+### perf:require_bench
+
+Shows the amount of memory (RAM) each library takes up when it is required.
+
+
+```
+action_controller/railtie: 1.06 mb
+  action_controller: 0.72 mb
+    action_controller/metal/live: 0.38 mb
+      action_dispatch/http/response: 0.17 mb
+        rack/request: 0.05 mb
+```
+
+
+## License
+
+MIT
+
+
+## Acknowledgements
+
+Most of the commands are wrappers around other libraries, go check them out. Also thanks to [@tenderlove](https://twitter.com/tenderlove) as I cribbed some of the Rails init code in `$ rake perf:setup` from one of his projects.
+
+kthksbye [@schneems](https://twitter.com/schneems)

data/derailed_benchmarks.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'derailed_benchmarks/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "derailed_benchmarks"
+  gem.version       = DerailedBenchmarks::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{ Go faster, off the Rails }
+  gem.summary       = %q{ Benchmarks designed to performance test your ENTIRE site }
+  gem.homepage      = "https://github.com/schneems/derailed_benchmarks"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "memory_profiler", "~> 0"
+  gem.add_dependency "get_process_mem", "~> 0"
+  gem.add_dependency "benchmark-ips",   "~> 2"
+end
+

data/lib/derailed_benchmarks.rb

@@ -0,0 +1,2 @@
+module DerailedBenchmarks
+end

data/lib/derailed_benchmarks/tasks.rb

@@ -0,0 +1,291 @@
+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
+
+    ENV["RAILS_ENV"] ||= "production"
+    ENV['RACK_ENV']  = ENV["RAILS_ENV"]
+    ENV["DISABLE_SPRING"] = "true"
+
+    ENV["SECRET_KEY_BASE"] ||= "foofoofoo"
+
+    ENV['LOG_LEVEL'] = "FATAL"
+
+    '.:lib:test:config'.split(':').each { |x| $: << x }
+
+    require 'application'
+
+    Rails.env = ENV["RAILS_ENV"]
+
+    APP = Rails.application
+    # puts APP.method(:initialize!).source_location
+
+    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)
+
+    APP.config.consider_all_requests_local = true
+
+
+    @app = Rack::MockRequest.new(APP)
+
+    puts "Booting: #{Rails.env}"
+
+    PATH_TO_HIT = ENV["PATH_TO_HIT"] || "/"
+    if server = ENV["USE_SERVER"]
+      @port = (3000..3900).to_a.sample
+      thread = Thread.new do
+        Rack::Server.start(app: 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?
+      end
+    else
+      def call_app
+        response = @app.get(PATH_TO_HIT)
+        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|
+      x.report("#{TEST_COUNT} requests") {
+        TEST_COUNT.times {
+          call_app
+        }
+      }
+    }
+  end
+
+  task :stackprof => [:setup] do
+    # [:wall, :cpu, :object]
+    require 'stackprof'
+    file = "tmp/#{Time.now.iso8601}-stackprof-cpu-myapp.dump"
+    StackProf.run(mode: :cpu, out: file) do
+      Rake::Task["perf:test"].invoke
+    end
+    cmd = "stackprof #{file}"
+    puts "Running `#{cmd}`. Execute `stackprof --help` for more info"
+    puts `#{cmd}`
+  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
+  end
+
+  desc "show memory usage caused by invoking require per gem"
+  task :require_bench => [:kernel_require_patch , :setup] do
+    ENV['CUT_OFF'] ||= "0.3"
+    puts "## Impact of `require <file>` on RAM"
+    puts
+    puts "Showing all `require <file>` calls that consume #{ENV['CUT_OFF']} mb or more of RSS"
+    puts "Configure with `CUT_OFF=0` for all entries or `CUT_OFF=5` for few entries"
+
+    puts "Note: Files only count against RAM on their first load."
+    puts "      If multiple libraries require the same file, then"
+    puts "       the 'cost' only shows up under the first library"
+    puts
+
+    call_app
+
+    TOP_REQUIRE.sorted_children.each do |child|
+      child.print_sorted_children
+    end
+  end
+
+  desc "outputs ram usage over time"
+  task :ram_over_time => [:setup] do
+    puts "PID: #{Process.pid}"
+    ram = GetProcessMem.new
+    @keep_going = true
+    begin
+      unless ENV["SKIP_FILE_WRITE"]
+        ruby = `ruby -v`
+        FileUtils.mkdir_p("tmp")
+        file = File.open("tmp/#{Time.now.iso8601}-#{ruby}-memory-#{TEST_COUNT}-times.txt", 'w')
+        file.sync = true
+      end
+
+      ram_thread = Thread.new do
+        while @keep_going
+          mb = ram.mb
+          STDOUT.puts mb
+          file.puts mb unless ENV["SKIP_FILE_WRITE"]
+          sleep 5
+        end
+      end
+
+      TEST_COUNT.times {
+        call_app
+      }
+    ensure
+      @keep_going = false
+      ram_thread.join
+      file.close unless ENV["SKIP_FILE_WRITE"]
+    end
+  end
+
+  desc "iterations per second"
+  task :ips => [:setup] do
+    Benchmark.ips do |x|
+      x.report("ips") { call_app }
+    end
+  end
+
+  desc "outputs GC::Profiler.report data while app is called TEST_COUNT times"
+  task :gc => [:setup] do
+    GC::Profiler.enable
+    TEST_COUNT.times { call_app }
+    GC::Profiler.report
+    GC::Profiler.disable
+  end
+
+  task :foo => [:setup] do
+    require 'objspace'
+    call_app
+
+    before = Hash.new { 0 }
+    after  = Hash.new { 0 }
+    after_size = Hash.new { 0 }
+    GC.start
+    GC.disable
+
+    TEST_COUNT.times { call_app }
+
+    rvalue_size = GC::INTERNAL_CONSTANTS[:RVALUE_SIZE]
+    ObjectSpace.each_object do |obj|
+      after[obj.class] += 1
+      memsize = ObjectSpace.memsize_of(obj) + rvalue_size
+      # compensate for API bug
+      memsize = rvalue_size if memsize > 100_000_000_000
+      after_size[obj.class] += memsize
+    end
+
+    require 'pp'
+    pp after.sort {|(k,v), (k2, v2)| v2 <=> v }
+    puts "========="
+    puts
+    puts
+    pp after_size.sort {|(k,v), (k2, v2)| v2 <=> v }
+  end
+
+  desc "outputs allocated object diff after app is called TEST_COUNT times"
+  task :allocated_objects => [:setup] do
+    call_app
+    GC.start
+    GC.disable
+    start = ObjectSpace.count_objects
+    TEST_COUNT.times { call_app }
+    finish = ObjectSpace.count_objects
+    GC.enable
+    finish.each do |k,v|
+      puts k => (v - start[k]) / TEST_COUNT.to_f
+    end
+  end
+
+
+  desc "profiles ruby allocation"
+  task :mem => [:setup] do
+    require 'memory_profiler'
+    call_app
+    GC.start
+
+    num = Integer(ENV["TEST_COUNT"] || 1)
+    opts = {}
+    opts[:ignore_files] = /#{ENV['IGNORE_FILES_REGEXP']}/ if ENV['IGNORE_FILES_REGEXP']
+    puts "Running #{num} times"
+    report = MemoryProfiler.report(opts) do
+      num.times { call_app }
+    end
+    report.pretty_print
+  end
+
+end

data/lib/derailed_benchmarks/version.rb

@@ -0,0 +1,3 @@
+module DerailedBenchmarks
+  VERSION = "0.0.0"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: derailed_benchmarks
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Richard Schneeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: get_process_mem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: " Go faster, off the Rails "
+email:
+- richard.schneeman+rubygems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- derailed_benchmarks.gemspec
+- lib/derailed_benchmarks.rb
+- lib/derailed_benchmarks/tasks.rb
+- lib/derailed_benchmarks/version.rb
+homepage: https://github.com/schneems/derailed_benchmarks
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Benchmarks designed to performance test your ENTIRE site
+test_files: []
+has_rdoc: