Habits - <%= user.habits.count %> Tasks - <%= user.tasks.count %> diff --git a/app/workers/welcome_email_worker.rb b/app/workers/welcome_email_worker.rb new file mode 100644 index 0000000..a6f19a4 --- /dev/null +++ b/app/workers/welcome_email_worker.rb @@ -0,0 +1,12 @@ +class WelcomeEmailWorker + + def self.queue + :welcome_email_queue + end + + + def self.perform(user_id) + user = User.find(user_id) + UserMailer.welcome_email(user.fullname, user.email).deliver + end +end \ No newline at end of file diff --git a/config/routes.rb b/config/routes.rb index 062f5b8..6ecf728 100644 --- a/config/routes.rb +++ b/config/routes.rb @@ -85,7 +85,7 @@ end constraints resque_constraint do - match "/delayed_job" => DelayedJobWeb, :anchor => false + mount Resque::Server, :at => "/resque" end # See how all your routes lay out with "rake routes" diff --git a/lib/heroku_resque_auto_scale.rb b/lib/heroku_resque_auto_scale.rb new file mode 100644 index 0000000..f5165f4 --- /dev/null +++ b/lib/heroku_resque_auto_scale.rb @@ -0,0 +1,124 @@ +require 'heroku' + +# Scale workers on Heroku automatically as your Resque queue grows. +# Mixin the +Scaling+ module into your models to get the behavior. +# +# class MyModel < ActiveRecord::Base +# extend HerokuAutoScaler::AutoScaling +# end +# +# And configure in an initializer +config/initializers/heroku_workers.rb+: +# +# HerokuAutoScaler.configure do +# process_type :nowaitworker +# scale_by {|pending| } +# end +# +# The default process type is +worker+. +# The default scaling is non-linear: +# * 1 job => 1 worker +# * 15 jobs => 2 workers +# * 25 jobs => 3 workers +# * 40 jobs => 4 workers +# * 60+ jobs => 5 workers +module HerokuResqueAutoScale + module AutoScaling + def after_perform_scale_down(*args) + HerokuAutoScaler.scale_down! + end + + def after_enqueue_scale_up(*args) + HerokuAutoScaler.scale_up! + end + + def on_failure(e, *args) + Rails.logger.info("Resque Exception for [#{self.to_s}, #{args.join(', ')}] : #{e.to_s}") + HerokuAutoScaler.scale_down! + end + end + + extend self + + def clear_resque + Resque::Worker.all.each {|w| w.unregister_worker} + end + + def configure(&block) + instance_eval(&block) if block_given? + end + + def process_type(type = nil) + @process_type ||= type || :worker + end + + def scale_by(&block) + self.scaling_block = block + end + + def scale_down! + Rails.logger.info "Scale down j:#{job_count} w:#{resque_workers}" + self.heroku_workers = 0 if job_count == 0 && resque_workers == 1 + end + + def scale_up! + pending = job_count + self.heroku_workers = workers_for(pending) if pending > 0 + end + + private + + attr_accessor :scaling_block + + def heroku + if ENV['HEROKU_USER'] && ENV['HEROKU_PASSWORD'] && ENV['HEROKU_APP'] + @heroku ||= Heroku::Client.new(ENV['HEROKU_USER'], ENV['HEROKU_PASSWORD']) + else + false + end + end + + def heroku_workers=(qty) + heroku.ps_scale(ENV['HEROKU_APP'], type: process_type, qty: qty) if heroku + end + + def job_count + Resque.info[:pending] + end + + def resque_workers + Resque.info[:working] + end + + def workers_for(pending_jobs) + if scaling_block + scaling_block.call(pending_jobs) + else + [ + { :workers => 1, # This many workers + :job_count => 1 # For this many jobs or more, until the next level + }, + { :workers => 2, + :job_count => 15 + } + # , + # { :workers => 3, + # :job_count => 25 + # }, + # { :workers => 4, + # :job_count => 40 + # }, + # { :workers => 5, + # :job_count => 60 + # } + ].reverse_each do |scale_info| + # Run backwards so it gets set to the highest value first + # Otherwise if there were 70 jobs, it would get set to 1, then 2, then 3, etc + + # If we have a job count greater than or equal to the job limit for this scale info + if pending_jobs >= scale_info[:job_count] + return scale_info[:workers] + end + end + end + end +end \ No newline at end of file diff --git a/lib/tasks/resque.rake b/lib/tasks/resque.rake new file mode 100644 index 0000000..1e4d1bd --- /dev/null +++ b/lib/tasks/resque.rake @@ -0,0 +1,13 @@ +# require "resque/tasks" +# +# task "resque:setup" => :environment + + +require 'resque/tasks' + +task "resque:setup" => :environment do + ENV['QUEUE'] = '*' +end + +desc "Alias for resque:work (To run workers on Heroku)" +task "jobs:work" => "resque:work" \ No newline at end of file