performance_promise 0.0.1

data/lib/performance_promise/validations/number_of_db_queries.rb

@@ -0,0 +1,30 @@
+module ValidateNumberOfQueries
+  def validate_makes(db_queries, render_time, makes)
+    makes = makes.evaluate  # force evaluation of lazy evaluated promise
+
+    passes = (db_queries.length <= makes)
+    error_message = ''
+    backtrace = []
+
+    if passes
+        return passes, error_message, backtrace
+    end
+
+    guessed_order = Utils.guess_order(db_queries)
+    error_message = "promised #{makes}, made #{db_queries.length} (possibly #{guessed_order})"
+    backtrace = []
+    Utils.summarize_queries(db_queries).each do |db_query, count|
+      statement = "#{count} x #{db_query[:sql]}"
+      backtrace << statement
+      db_query[:trace].each do |trace|
+        if trace.starts_with?('app')
+          file, line_number = trace.split(':')
+          trace = "    |_" + File.read(file).split("\n")[line_number.to_i - 1].strip + ' (' + trace + ')'
+        end
+        backtrace << trace
+      end
+    end
+
+    return passes, error_message, backtrace
+  end
+end

data/lib/performance_promise/validations/time_taken_for_render.rb

@@ -0,0 +1,13 @@
+module ValidateTimeTakenForRender
+  def validate_takes(db_queries, render_time, takes)
+    passes = (render_time <= takes)
+    error_message = ''
+    backtrace = []
+
+    unless passes
+        error_message = "promised #{takes} seconds, took #{render_time} seconds"
+    end
+
+    return passes, error_message, backtrace
+  end
+end

data/lib/performance_promise.rb

@@ -0,0 +1,116 @@
+require 'performance_promise/decorators'
+require 'performance_promise/sql_recorder.rb'
+require 'performance_promise/utils.rb'
+require 'performance_promise/lazily_evaluated.rb'
+require 'performance_promise/performance_validations.rb'
+
+module PerformancePromise
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  def self.start
+    return unless PerformancePromise.configuration.enable
+    return unless PerformancePromise.configuration.allowed_environments.include?(Rails.env)
+
+    ActiveSupport::Notifications.subscribe "sql.active_record" do |name, start, finish, id, payload|
+      SQLRecorder.instance.record(payload, finish - start)
+    end
+
+    ActiveSupport::Notifications.subscribe "start_processing.action_controller" do |name, start, finish, id, payload|
+      SQLRecorder.instance.flush
+    end
+
+    ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
+      db_queries = SQLRecorder.instance.flush
+      render_time = finish - start
+      method_name = "#{payload[:controller]}\##{payload[:action]}"
+      promised = PerformancePromise.promises[method_name]
+      if promised
+        PerformancePromise::validate_promise(method_name, db_queries, render_time, promised)
+      elsif PerformancePromise.configuration.untagged_methods_are_speedy
+        PerformancePromise.configuration.logger.warn 'No promises made. Assuming Speedy'
+        promised = PerformancePromise.configuration.speedy_promise
+        PerformancePromise::validate_promise(method_name, db_queries, render_time, promised)
+      end
+    end
+  end
+
+  class Configuration
+    attr_accessor :enable
+    attr_accessor :validations
+    attr_accessor :logger
+    attr_accessor :allowed_environments
+    attr_accessor :speedy_promise
+    attr_accessor :untagged_methods_are_speedy
+    attr_accessor :throw_exception
+
+    def initialize
+      # Set default values
+      @enable = false
+      @validations = [
+        :makes,
+      ]
+      @logger = Rails.logger
+      @allowed_environments = [
+        'development',
+        'test',
+      ]
+      @untagged_methods_are_speedy = false
+      @speedy_promise = {
+        :makes => 1.query,
+        :takes => 1.second,
+      }
+      @throw_exception = true
+    end
+  end
+
+  class BrokenPromise < RuntimeError
+  end
+
+  @@promises = {}
+
+  def self.promises
+    @@promises
+  end
+
+  def self.validate_promise(method, db_queries, render_time, options)
+    return if options[:skip]
+    promise_broken = false
+    self.configuration.validations.each do |validation|
+      promised = options[validation]
+      if promised
+        validation_method = 'validate_' + validation.to_s
+        passed, error_message, backtrace =
+          PerformanceValidations.send(validation_method, db_queries, render_time, promised)
+        unless passed
+          if PerformancePromise.configuration.throw_exception
+            bp = BrokenPromise.new("Broken promise: #{error_message}")
+            bp.set_backtrace(backtrace)
+            raise bp
+          else
+            PerformancePromise.configuration.logger.warn '-' * 80
+            PerformancePromise.configuration.logger.warn Utils.colored(:red, error_message)
+            backtrace.each do |trace|
+              PerformancePromise.configuration.logger.warn Utils.colored(:cyan, error_message)
+            end
+            PerformancePromise.configuration.logger.warn '-' * 80
+          end
+          promise_broken = true
+        end
+      end
+    end
+    PerformanceValidations.report_promise_passed(method, db_queries, options) unless promise_broken
+  end
+
+end
+
+
+class ApplicationController < ActionController::Base
+  extend MethodDecorators
+end

data/performance_promise.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+  s.name        = 'performance_promise'
+  s.version     = '0.0.1'
+  s.date        = '2015-12-14'
+  s.summary     = 'Validate your Rails actions\' performance'
+  s.description = 'Validate your Rails actions\' performance'
+  s.authors     = ['Bipin Suresh']
+  s.email       = 'bipins@alumni.stanford.edu'
+  s.files       = `git ls-files -z`.split("\x0")
+  s.test_files  = s.files.grep(%r{^(test|spec|features)/})
+  s.homepage    = 'http://rubygems.org/gems/performance_promise'
+  s.license     = 'MIT'
+end

data/spec/performance_promise_spec/lazily_evaluated.rb

@@ -0,0 +1,53 @@
+require 'active_support/time'
+require 'logger'
+require './lib/performance_promise/performance.rb'
+
+
+describe 'LazilyEvaluated' do
+  it 'creates a lazy-evaluated object a Fixnum' do
+    expect(1.query.class).to be LazilyEvaluated
+    expect(2.queries.class).to be LazilyEvaluated
+  end
+
+  it 'creates a lazy-evaluatd object from ActiveRecord::Base' do
+    expect(ActiveRecord::Base.N.queries.class).to be LazilyEvaluated
+  end
+
+  it 'creates a new lazy-evaluated object from arithmetic operations' do
+    expect((LazilyEvaluated.new(1) + LazilyEvaluated.new(2)).class).to be LazilyEvaluated
+    expect((LazilyEvaluated.new(1) - LazilyEvaluated.new(2)).class).to be LazilyEvaluated
+    expect((LazilyEvaluated.new(1) * LazilyEvaluated.new(2)).class).to be LazilyEvaluated
+    expect((LazilyEvaluated.new(1) / LazilyEvaluated.new(2)).class).to be LazilyEvaluated
+  end
+
+  context '#evaluate' do
+    before(:all) do
+      PerformancePromise.configure do |config|
+        config.enable = true
+      end
+      PerformancePromise.start
+    end
+
+    it 'short-circuits in production' do
+      expect(Rails).to receive(:env).and_return('production')
+      expect(ActiveRecord::Base).not_to receive(:count)
+      expect(ActiveRecord::Base.N.queries.evaluate).to be 0
+    end
+
+    it 'evaluates Fixnums correctly' do
+      expect((1.query).evaluate).to be 1
+    end
+
+    it 'lazily evaluates models' do
+      expect(ActiveRecord::Base).to receive(:count)
+      ActiveRecord::Base.N.evaluate
+    end
+
+    it 'evaluates simple arithmetic operations correctly' do
+      expect((1.query + 2.queries).evaluate).to be 3
+      expect((2.queries - 1.query).evaluate).to be 1
+      expect((2.queries * 2.queries).evaluate).to be 4
+      expect((2.queries / 2.queries).evaluate).to be 1
+    end
+  end
+end

data/spec/performance_promise_spec/performance.rb

@@ -0,0 +1,31 @@
+require './lib/performance_promise/performance.rb'
+
+
+describe 'Performance' do
+  before(:all) do
+    class ArticleController
+      extend MethodDecorators
+    end
+  end
+
+  it 'does not registers a promise when a function is not decorated' do
+    expect(PerformancePromise.promises['ArticleController#index']).to be_falsey
+  end
+
+  it 'registers a promise when a function is decorated' do
+    a = ArticleController.new
+    class ArticleController
+      Performance :makes => 1.query
+      def index
+      end
+    end
+    expect(PerformancePromise.promises['ArticleController#index']).to be_truthy
+  end
+
+  it 'calls the decorated function when called' do
+    a = ArticleController.new
+    expect(PerformancePromise.promises['ArticleController#index']).to be_truthy
+    expect(a).to receive(:index).with('argument')
+    a.index('argument')
+  end
+end

data/spec/performance_promise_spec/speedy.rb

@@ -0,0 +1,14 @@
+require './lib/performance_promise/speedy.rb'
+
+
+describe 'Speedy' do
+  it 'promises speedy configuration when tagged with Speedy()' do
+    class ArticleController
+      Speedy()
+      def index
+      end
+    end
+    speedy_promise = PerformancePromise.configuration.speedy_promise
+    expect(PerformancePromise.promises['ArticleController#index']).to equal(speedy_promise)
+  end
+end

data/spec/performance_promise_spec.rb

@@ -0,0 +1,230 @@
+require 'active_support/time'
+require 'logger'
+require './lib/performance_promise.rb'
+require './lib/performance_promise/decorators.rb'
+
+
+RSpec.describe 'PerformancePromise' do
+  context '.start' do
+    context 'when not enabled' do
+      before(:each) do
+        PerformancePromise.configure do |config|
+          config.enable = false
+        end
+      end
+
+      it 'does not subscribe to any events' do
+        expect(ActiveSupport::Notifications).not_to receive(:subscribe)
+        PerformancePromise.start
+      end
+    end
+
+    context 'when enabled' do
+      before(:each) do
+        PerformancePromise.configure do |config|
+          config.enable = true
+        end
+      end
+
+      context 'when in production' do
+        before(:each) do
+          expect(Rails).to receive(:env).and_return('production')
+        end
+
+        it 'does not subscribe to any events' do
+          expect(ActiveSupport::Notifications).not_to receive(:subscribe)
+          PerformancePromise.start
+        end
+      end
+
+      context 'when in development' do
+        it 'subscribe to all events' do
+          expect(ActiveSupport::Notifications).to receive(:subscribe).with('sql.active_record')
+          expect(ActiveSupport::Notifications).to receive(:subscribe).with('start_processing.action_controller')
+          expect(ActiveSupport::Notifications).to receive(:subscribe).with('process_action.action_controller')
+          PerformancePromise.start
+        end
+      end
+    end
+  end
+
+  context 'after it is started' do
+    before(:all) do
+      PerformancePromise.configure do |config|
+        config.enable = true
+      end
+      PerformancePromise.start
+    end
+
+    it 'records the statement when a SQL statement is executed' do
+      expect(SQLRecorder.instance).to receive(:record)
+      ActiveSupport::Notifications.instrument('sql.active_record')
+    end
+
+    it 'flushes the Recorder when an action loads' do
+      expect(SQLRecorder.instance).to receive(:flush)
+      ActiveSupport::Notifications.instrument('start_processing.action_controller')
+    end
+
+    context 'when the action completes' do
+      context 'when the method is tagged' do
+        before(:each) do
+          PerformancePromise.promises['ActionController#index'] = {
+            :makes => 1.queries,
+          }
+        end
+        it 'validates the promise when the method is tagged' do
+          expect(PerformancePromise).to receive(:validate_promise)
+          ActiveSupport::Notifications.instrument(
+            'process_action.action_controller', {
+              :controller => :ActionController,
+              :action => :index,
+            }
+          )
+        end
+      end
+
+      context 'when the method is untagged' do
+        before(:each) do
+          PerformancePromise.promises['ActionController#index'] = nil
+        end
+
+        it 'validates the promise if Speedy is enabled by default' do
+          PerformancePromise.configure do |config|
+            config.untagged_methods_are_speedy = true
+          end
+          expect(PerformancePromise).to receive(:validate_promise)
+          expect(PerformancePromise.configuration.logger).to receive(:warn).with('No promises made. Assuming Speedy')
+          ActiveSupport::Notifications.instrument(
+            'process_action.action_controller', {
+              :controller => :ActionController,
+              :action => :index,
+            }
+          )
+        end
+
+        it 'does not validate promise if Speedy is not enabled by default' do
+          PerformancePromise.configure do |config|
+            config.untagged_methods_are_speedy = false
+          end
+          expect(PerformancePromise).not_to receive(:validate_promise)
+          ActiveSupport::Notifications.instrument(
+            'process_action.action_controller', {
+              :controller => :ActionController,
+              :action => :index,
+            }
+          )
+        end
+      end
+    end
+  end
+
+  context '.validate_promise' do
+    before(:each) do
+      PerformancePromise.configure do |config|
+        config.enable = true
+        config.validations = []
+      end
+      PerformancePromise.start
+    end
+
+    it 'passes promises if all options are disabled' do
+      expect(PerformanceValidations).not_to receive(:report_failed_makes)
+      expect(PerformanceValidations).not_to receive(:report_failed_takes)
+      expect(PerformanceValidations).to receive(:report_promise_passed)
+      PerformancePromise.validate_promise('ActionController#index', [], 1, {})
+    end
+
+    context 'when asked to validate number of queries' do
+      before(:each) do
+        PerformancePromise.configure do |config|
+          config.validations = [
+            :makes,
+          ]
+        end
+      end
+
+      it 'does not do anything if no actual promise is made on #queries' do
+        expect(PerformanceValidations).not_to receive(:report_failed_makes)
+        expect(PerformanceValidations).to receive(:report_promise_passed)
+        PerformancePromise.validate_promise('ActionController#index', [], 1, {})
+      end
+
+      context 'when an actual promise is made' do
+        it 'reports a failure when a promise fails' do
+          options = {
+            :makes => 0.queries,
+          }
+          queries = [
+            'SELECT * from articles',
+          ]
+          expect(PerformanceValidations).to receive(:report_failed_makes).and_return(['', []])
+          expect {
+            PerformancePromise.validate_promise('ActionController#index', queries, 1, options)
+          }.to raise_error(PerformancePromise::BrokenPromise)
+        end
+
+        it 'reports a success when a promise passes' do
+          options = {
+            :makes => 1.query,
+          }
+          queries = [
+            'SELECT * from articles',
+          ]
+          expect(PerformanceValidations).not_to receive(:report_failed_makes)
+          expect(PerformanceValidations).to receive(:report_promise_passed)
+          PerformancePromise.validate_promise('ActionController#index', queries, 1, options)
+        end
+
+        it 'does not fail if an action is explicitly skipped' do
+          options = {
+            :makes => 0.queries,
+            :skip => true,
+          }
+          queries = [
+            'SELECT * from articles',
+          ]
+          expect(PerformanceValidations).not_to receive(:report_failed_makes)
+          PerformancePromise.validate_promise('ActionController#index', queries, 1, options)
+        end
+      end
+    end
+
+    context 'when asked to validate time taken for render' do
+      before(:each) do
+        PerformancePromise.configure do |config|
+          config.validations = [
+            :takes,
+          ]
+        end
+      end
+
+      it 'does not do anything if no actual promise is made on time taken' do
+        expect(PerformanceValidations).not_to receive(:report_failed_takes)
+        expect(PerformanceValidations).to receive(:report_promise_passed)
+        PerformancePromise.validate_promise('ActionController#index', [], 1, {})
+      end
+
+      context 'when an actual promise is made' do
+        it 'reports a failure when a promise fails' do
+          options = {
+            :takes => 0.seconds,
+          }
+          expect(PerformanceValidations).to receive(:report_failed_takes).and_return(['', []])
+          expect {
+            PerformancePromise.validate_promise('ActionController#index', [], 1, options)
+          }.to raise_error(PerformancePromise::BrokenPromise)
+        end
+
+        it 'reports a success when a promise passes' do
+          options = {
+            :takes => 1,
+          }
+          expect(PerformanceValidations).not_to receive(:report_failed_takes)
+          expect(PerformanceValidations).to receive(:report_promise_passed)
+          PerformancePromise.validate_promise('ActionController#index', [], 1, options)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,121 @@
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end
+
+
+module Rails
+  class << self
+    def root
+      File.expand_path(__FILE__).split('/')[0..-3].join('/')
+    end
+
+    def logger
+      Logger.new(STDOUT)
+    end
+
+    def env
+      "test"
+    end
+  end
+end
+
+module ActionController
+  class Base
+  end
+end
+
+module ActiveRecord
+  class Base
+    def self.count
+    end
+  end
+end