CAUSE: Too much stuff

string = params[:country]
country = COUNTRY_CODE_MAP.detect do |k,v|
  [k.downcase, v.downcase].include? string.downcase
end

• Creates array INSIDE A LOOP
• Downcase creates copies of strings
• include? causes both variables to be downcased

SOLUTION: Do less work

string = params[:country]
country = COUNTRY_CODE_MAP.detect do |k,v|
  k.casecmp(string) == 0 || v.casecmp(string) == 0
end

• No array
• No downcased copy of strings
• || instead of include?

CAUSE: Redundancy Across Requests

def subscriber_confirmation
  @subscriber_confirmation ||= expensive_lookup
end

• Lookup is expensive (external service / long db query / cpu intensive)
• Value changes rarely under known circumstances

SOLUTION: Cache With Redis

def subscriber_confirmation
  @subscriber_confirmation ||= Rails.cache.fetch(
    "subscriber_confirmation:#{Current.account}",
    :expires_in => LONG_TIME_IN_SECONDS
  ) { | key| expensive_lookup(key) }
end

• Looks up value of key
• Checks that key is not expired
• If value is missing or expired:
  • Calls block with key
  • Updates cache with result

View/action caching

CAUSE: Exceptions as part of normal application flow

class SomeModel
  def funky_method
    unless complicated_action_succeeds
      raise FunkyError, 'Something Funky Failed'
    end
  end
end

class SomeController
  def some_action
    response = SomeModel.new(params).funky_method
    render status: 200, json: response
  rescue FunkyError => e
    render status: 400, json: {errors: 'Funky Failboat!'}
  end
end

• Exception generates a backtrace
• Exception is being raised manually

SOLUTION: Return Message not Exception

class SomeModel
  def funky_method
    unless complicated_action_succeeds
      { error: 'Yeah, that happens' }
    end
  end
end

class SomeController
  def some_action
    response = SomeModel.new(params).funky_method
    status = response[:error] ? 400 : 200
    render status: status, json: response
  end
end

• Return value indicates error
• No exception at controller == No Backtrace

Excessive Logging

Rails.logger.debug "This is expensive #{some_expensive_method}"

• message is created even if it is below logging level

big_array.each do |x|
  Rails.logger.debug 'processing row'
  ...
end

• logger is called n times with the same message

Log carefully

if Rails.logger.debug?
  Rails.logger.debug "This is expensive #{some_expensive_method}"
end

• Check if you are logging debug first

Rails.logger.debug "processing #{big_array.size} rows"
big_array.each do |x|
  ...
end

• logger is called once

Too Many AR Instances

def all_contact_ids
  Contact.all.map &:contact_id
end

• Creates a lot of objects
• Retrieves all columns, only uses contact_id

Use Pluck

def all_contact_ids
  Contact.all.pluck(:contact_id)
end

• Creates a single Array
• Retrieves only contact_ids

Destroying Records Is Slow

class Contact
  has_many :addresses, dependent: :destroy

  def self.remove_bad_contacts
    self.destroy_all(bad_contact: true)
  end
end

• Instantiates each record
• Calls destroy callbacks
• Calls destroy on dependents (more instances!)

Use Delete Instead

class Contact
  has_many :addresses, dependent: :destroy

  scope :bad_contacts, -> { where(bad_contact: true) }

  def self.remove_bad_contacts
    Address.delete_all contact_id: self.bad_contacts.pluck(:contact_id)
    self.bad_contacts.delete_all
  end
end

• Does not instantiate any AR records
• Does not call destroy callbacks
• Manually delete dependencies

Reads for Validation

class Contact < ActiveRecord::Base
  validates :first_name,  uniqueness: {scope: :last_name}
end

• Saving a record requires a read and a write

Let the Database do it

class Contact < ActiveRecord::Base
  around_save :check_uniqueness

  def check_uniqueness
    yield
  rescue ActiveRecord::RecordNotUnique => exception
    errors.add :base, "contact is not unique"
    raise ActiveRecord::RecordInvalid.new(self)
  end
end

# db migration
add_index :contacts, [:firstname, :lastname], :unique => true

• Database index for the unique fields
• Mutate the exception to RecordInvalid
• RecordInvalid is handled as if valid? had failed

Inserting Multiple Records

• Many trips to the database
• Database connection churn
• Validations and callbacks