disque_jockey 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec24b527a949eebcfd10f84df9ea4c15224442de
+  data.tar.gz: bf38d59c5f6b95b619171f8fd64d74129d253470
+SHA512:
+  metadata.gz: 45bcdbf55a10a3420285c16d8a9007c4b7b7d95a956780e1ba6db9d98524a2877cee3a1a2b82aad7aec0056258315659f35b4f5a3aa55fffb3d60139bfa3805f
+  data.tar.gz: 74e2838237a2a8793d7dffb0f09839ce72a10feffd618bce9f797edefc040e94184f28112bc457c87071647380a6ca09690ca2f9451d4dfd999ebd72cd976658

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+*.gem
+.bundle/
+.DS_Store
+test.log
+tmp/
+pkg/

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,66 @@
+# DisqueJockey
+DisqueJockey is a fast, concurrent background job processing framework for the Disque message queue.
+# Getting Started
+First, you should run a Disque server if you aren't already doing so.
+Disque source and build instructions can be found at: https://github.com/antirez/disque
+
+Once Disque is set up:
+````
+git clone git@github.com:DevinRiley/disque_jockey.git
+````
+
+cd into the project directory
+Install the gem dependencies with bundler
+````
+bundle install
+````
+
+to build the gem:
+````
+rake build
+````
+
+to install the gem on your machine:
+````
+gem install pkg/disque_jockey-0.0.1.gem
+````
+
+Now you're ready to use disque_jockey!
+
+## Writing your first worker
+DisqueJockey provides a framework for creating background task workers.  Workers subscribe to a disque queue and are given jobs from the queue.
+
+Your worker should inherit from the DisqueJockey::Worker class
+
+```ruby
+require 'disque_jockey'
+class ExampleWorker < DisqueJockey::Worker
+  subscribe_to 'example-queue'
+  def handle(job)
+    logger.info("Peforming job: #{job}")
+  end
+end
+```
+Your worker class must do two things:
+- call the subscribe_to method with the name of a queue
+- implement a handle method, which will take a job as its argument. Jobs from Disque are strings.
+
+
+Lastly, you must place your worker in a directory named 'workers'
+
+Once your worker is written and placed in a workers directory, you can call disque_jockey from the command line and it will start up your workers and begin delivering jobs to them.
+
+````
+disque_jockey
+````
+
+Messages successfully handled by a worker (ie no exceptions raised from the handle method) will be acknowledged and removed from the queue.
+
+##Roadmap:
+DisqueJockey is not a currently a production-ready system, and there are a number of goals for it that have not been met yet.
+Here is a list of functionality I'd like to add to DisqueJockey in the near future:
+- Allow workers to set auto-acknowledge or fast-acknowledge of messages.
+- Better test coverage around worker groups
+- Command line options (e.g. environment)
+- Rails integration (ActiveJob Adapter)
+- More use cases in the README (e.g. how to use alongside Rails)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/disque_jockey

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'disque_jockey'
+DisqueJockey.run!

data/disque_jockey.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'disque_jockey/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'disque_jockey'
+  gem.version       = DisqueJockey::VERSION
+  gem.authors       = ['Devin Riley']
+  gem.email         = ['devinriley84+disque_jockey@gmail.com']
+  gem.license       = "MIT"
+  gem.description   = "A framework for managing and running ruby background workers."
+  gem.summary       = "A background job framework."
+  gem.homepage      = 'https://github.com/DevinRiley/disque_jockey'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = ['disque_jockey']
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.require_paths = ['lib']
+  gem.add_runtime_dependency 'disque'
+  gem.add_runtime_dependency 'logging'
+  gem.add_development_dependency('rspec', '~> 3.1', '>= 3.0')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('pry')
+end

data/lib/disque_jockey/broker.rb

@@ -0,0 +1,22 @@
+require 'disque'
+module DisqueJockey
+  class Broker
+
+    def initialize(nodes = ["127.0.0.1:7711"], *args)
+      @client = Disque.new(nodes, *args)
+    end
+
+    def fetch_message_from(queue)
+      # fetch returns an array of jobs, but we just want the first one
+      @client.fetch(from: [queue]).first
+    end
+
+    def acknowledge(job_id)
+      response = @client.call('ACKJOB', job_id)
+      # If there is an error acking the job the Disque client 
+      # *returns* an error object but doesn't raise it, 
+      # so we raise it here ourselves.
+      response.is_a?(RuntimeError) ? raise(response) : true
+    end
+  end
+end

data/lib/disque_jockey/configuration.rb

@@ -0,0 +1,29 @@
+module DisqueJockey
+  class Configuration
+    attr_accessor :logger, :worker_groups, :log_path, :env
+    def initialize
+      # set defaults
+      @worker_groups = worker_groups_for_environment
+      @log_path = log_path_for_environment
+    end
+
+    def env
+      @env ||= ENV['DISQUE_JOCKEY_ENV'] || 'development'
+    end
+
+    def daemonize?
+      env != 'development'
+    end
+
+    def log_path_for_environment
+      env == 'test' ? 'spec/log' : 'log'
+    end
+
+    # TODO: just read this from a config file
+    def worker_groups_for_environment
+      env == 'development' ? 2 : 4
+    end
+
+  end
+end
+

data/lib/disque_jockey/logger.rb

@@ -0,0 +1,83 @@
+require 'logging'
+
+module DisqueJockey
+  class Logger
+
+    def initialize(klass)
+      init_color_scheme
+      @logger = Logging.logger[klass]
+      @logger.add_appenders(*log_appenders)
+      @logger.level = :info
+    end
+
+    def logger
+      @logger
+    end
+
+    # logging levels
+    def fatal(message)
+      @logger.fatal(message)
+    end
+
+    def error(message)
+      @logger.error(message)
+    end
+
+    def warn(message)
+      @logger.warn(message)
+    end
+
+    def info(message)
+      @logger.info(message)
+    end
+
+    def debug(message)
+      @logger.debug(message)
+    end
+
+    private
+
+    def log_appenders
+      appenders = []
+      appenders << file_appender
+      appenders << stdout_appender if DisqueJockey.configuration.env == 'development'
+      return appenders
+    end
+
+    def file_appender
+      begin
+        Logging.appenders.file("#{DisqueJockey.configuration.log_path}/#{DisqueJockey.configuration.env}.log",
+          { layout: Logging.layouts.pattern(log_pattern) })
+      rescue
+        raise "You must provide a valid log path and log file!  DisqueJockey by default will log to the current directory /log/environment.log.  Make sure that directory exists and the file is writeable!. Configure DisqueJockey's log path before running if you'd like to specify a custom path"
+      end
+    end
+
+    def stdout_appender
+      # only add colors to the STDOUT appender to prevent color codes
+      # from getting into the log files and potentially impacting commands
+      # like 'less' and 'more'
+      Logging.appenders.stdout({ layout: Logging.layouts.pattern(log_pattern.merge(color_scheme: 'bright')) })
+    end
+
+    def log_pattern
+      { pattern: '[%d] %-5l %c: %m\n' }
+    end
+
+    def init_color_scheme
+      Logging.color_scheme('bright',
+      :levels => {
+        :info  => :green,
+        :warn  => :yellow,
+        :error => :red,
+        :fatal => [:white, :on_red]
+      },
+      :date => :blue,
+      :logger => :magenta,
+      :message => :white
+      )
+    end
+
+  end
+end
+

data/lib/disque_jockey/supervisor.rb

@@ -0,0 +1,84 @@
+module DisqueJockey
+  class Supervisor
+
+    def self.work!
+      Process.daemon(true) if DisqueJockey.configuration.daemonize?
+      load_workers
+      spawn_worker_groups
+      trap_signals_in_parent
+      monitor_worker_groups
+    end
+
+    def self.logger
+      @logger ||= DisqueJockey::Logger.new('DisqueJockey')
+    end  
+
+    def self.worker_classes
+      @worker_classes ||= []
+    end
+
+    private
+
+    def self.child_pids
+      @child_pids ||= []
+    end
+
+    def self.register_worker(worker_class)
+      worker_classes.push(worker_class)
+    end
+
+    def self.load_workers
+      Dir.glob('**/workers/*.rb') {|f| require File.expand_path(f)}
+    end
+
+    def self.spawn_worker_groups
+      DisqueJockey.configuration.worker_groups.times { spawn_worker_group }
+    end
+
+    def self.spawn_worker_group
+      child_pids << Process.fork { WorkerGroup.new(worker_classes).work! }
+    end
+
+    def self.monitor_worker_groups
+      # this method never returns, it just
+      # spawns new worker groups if their
+      # processes exit.
+      # DisqueJockey only exits if it receives a 
+      # kill signal
+      loop do
+        @dead_disque_jockeys.each do
+          child_pid = @dead_disque_jockeys.shift
+          logger.error "Child worker group exited: #{child_pid}"
+          child_pids.delete(child_pid)
+          spawn_worker_group
+        end
+        sleep(0.1)
+      end
+    end
+
+    def self.trap_signals_in_parent
+      @dead_disque_jockeys = []
+      %w(QUIT TERM INT ABRT CLD).each do |sig|
+        trap(sig) do
+          if sig == 'CLD'
+            # if a child process dies, we want to 
+            # respawn another worker group
+            # This needs to be reentrant, so we queue up dead child
+            # processes to be handled in the run loop, rather than 
+            # acting here
+            @dead_disque_jockeys << Process.wait
+          else 
+            begin
+              child_pids.each { |pid| Process.kill(sig, pid) }
+            ensure exit
+            end
+          end
+
+        end
+      end
+    end
+
+
+
+  end
+end

data/lib/disque_jockey/version.rb

@@ -0,0 +1,3 @@
+module DisqueJockey
+  VERSION = '0.0.1'
+end

data/lib/disque_jockey/worker.rb

@@ -0,0 +1,45 @@
+module DisqueJockey
+  class Worker
+    attr_reader :logger
+    def initialize(logger)
+      @logger = logger.new(self.class.to_s + rand(1000).to_s)
+    end
+
+    def log_exception(e)
+      logger.error "#{self.class} raised exception #{e.inspect}: "
+      logger.error ">   " + e.backtrace.reject{|l| l =~ /\.rvm/ }.join("\n>   ")
+    end
+
+    class << self
+      attr_reader :queue_name, :thread_count, :timeout_seconds
+
+      # This worker class will subscribe to queue
+      def subscribe_to(queue)
+        @queue_name = queue
+      end
+
+      # minimum number of worker instances of a given worker class.
+      def threads(size)
+        @thread_count = [[size, 1].max, 10].min
+      end
+
+      # seconds to wait for a job to be handled before timing out the worker.
+      # (capped between 0.01 seconds and one hour)
+      def timeout(seconds)
+        @timeout_seconds = [[seconds, 0.01].max, 3600].min
+      end
+
+      protected
+
+      # callback method fired when a class inherits from DisqueJockey::Worker
+      def inherited(type)
+        # these are the defaults
+        type.threads 2
+        type.timeout 30
+        # register the new worker type so we can start giving it jobs
+        Supervisor.register_worker(type)
+      end
+    end
+
+  end
+end

data/lib/disque_jockey/worker_group.rb

@@ -0,0 +1,108 @@
+# A WorkerGroup lives in its own process
+# and runs workers of each worker class.  It is effectively
+# a self-contained unit of workers that fetch jobs and work.
+module DisqueJockey
+  class WorkerGroup
+
+    def initialize(worker_classes = [])
+      @worker_classes = worker_classes # array of classes to instantiate in our group
+      @worker_pool = {} # initialize a hash for storing workers
+    end
+
+    def work!
+      register_signal_handlers
+      Supervisor.logger.info("Starting worker group with PID #{Process.pid}...")
+      start_workers
+      work_until_signal
+    end
+
+    private
+
+    # This loop is in a method so that we can stub it in tests
+    def work_until_signal
+      loop do 
+        break if handle_signals
+        sleep(0.1)
+      end
+    end
+
+    # Register signal handlers to shut down the worker group.
+    def register_signal_handlers
+      Thread.main[:signal_queue] = []
+      %w(QUIT TERM INT ABRT).each do |signal|
+        # This needs to be reentrant, so we queue up signals to be handled
+        # in the run loop, rather than acting on signals here
+        trap(signal) { Thread.main[:signal_queue] << signal }
+      end
+    end 
+
+    # instantiate all the workers we want and start giving
+    # them jobs to do
+    def start_workers
+      @worker_classes.each do |worker_class|
+        build_worker_pool(worker_class)
+        # Each worker_class (and hence, queue), get its own
+        # thread because the Disque client library blocks
+        # when waiting for a job from a queue.
+        Thread.new { fetch_job_and_work(worker_class) }
+      end
+    end
+
+    # Deal with signals we receive from the OS by logging the signal
+    # and then killing the worker group
+    def handle_signals
+      signal = Thread.main[:signal_queue].shift
+      if signal
+        Supervisor.logger.info("Received signal #{signal}. Shutting down worker group with PID #{Process.pid}...")
+        return true
+      end
+    end
+
+    # The worker pool gives us a fixed number of worker instances of each class
+    # to do the work.  This could be improved by dynamically instantiating
+    # and removing workers from the pool based on workload.  For now, we use
+    # a fixed number.
+    def build_worker_pool(worker_class)
+      Supervisor.logger.info("Launching #{worker_class.thread_count} #{worker_class}s")
+      worker_class.thread_count.times do
+        # Use the Queue class so we access our worker pools
+        # from different threads without issues.
+        @worker_pool[worker_class] ||= Queue.new
+        @worker_pool[worker_class].push worker_class.new(Logger)
+      end
+    end
+
+    # Here we actually get jobs to work on and hand them off to worker
+    # instances.
+    def fetch_job_and_work(worker_class)
+      broker = Broker.new
+      loop do
+        # this method blocks until a job is returned
+        _, job_id, job = broker.fetch_message_from(worker_class.queue_name)
+        # Queue#pop will block until a worker becomes available
+        worker = @worker_pool[worker_class].pop
+        # now that we have a worker, give it a thread to do its work in
+        # so we can fetch the next job without waiting.
+        Thread.new do
+          begin
+            # Raise a timeout error if the worker takes too long
+            Timeout::timeout(worker_class.timeout_seconds) { worker.handle(job) }
+            # acknowlege the job once we've handled it
+            broker.acknowledge(job_id)
+          rescue StandardError => exception
+            worker.log_exception(exception)
+            # TODO: Need to implement retry logic
+            #       Also should do more helpful logging around worker timeouts
+            #       (explain the error, log the job and maybe metadata)
+          end
+          # We're done working, so put the worker back in the pool
+          @worker_pool[worker_class].push(worker)
+
+        end
+
+
+      end
+    end
+
+  end
+end

data/lib/disque_jockey.rb

@@ -0,0 +1,26 @@
+require 'disque_jockey/version'
+require 'disque_jockey/broker'
+require 'disque_jockey/logger'
+require 'disque_jockey/supervisor'
+require 'disque_jockey/worker'
+require 'disque_jockey/configuration'
+require 'disque_jockey/worker_group'
+require 'timeout'
+
+
+module DisqueJockey
+  # raise exceptions in all threads so we don't fail silently
+  Thread.abort_on_exception = true
+
+  def self.configuration
+    @configuration ||= DisqueJockey::Configuration.new
+  end
+
+  def self.configure
+    yield(self.configuration)
+  end
+
+  def self.run!
+    DisqueJockey::Supervisor.work!
+  end
+end

data/spec/disque_jockey/broker_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module DisqueJockey
+  describe Broker do
+    # Note: You actually have to run a Disque server 
+    # locally for these tests to pass
+    before(:all) do
+      begin
+        @broker = Broker.new
+        @client = Disque.new(["127.0.0.1:7711"])
+      rescue ArgumentError => error
+        raise ArgumentError, "#{error}. You need to run a Disque server on 127.0.0.1:7711 for these test to pass."
+      end
+    end
+
+    # This will flush all queues -- potentially really dangerous.
+    # hopefully we can just flush test queues in the future.
+    after(:all) { @client.call('DEBUG', 'FLUSHALL') }
+
+    it "::new takes an array of hosts but provides a default" do
+      expect{ Broker.new }.to_not raise_error
+      expect{ Broker.new(["127.0.0.1:7711"]) }.to_not raise_error
+    end
+
+    it "::new passes on args to Disque client" do
+      expect(Disque).to receive(:new).with(['0.0.0.0'], auth: 'secret')
+      Broker.new(['0.0.0.0'], auth: 'secret')
+    end
+
+    it "#fetch_message_from delivers messages" do
+      @client.push("test_queue", "job", 1000)
+      result = @broker.fetch_message_from('test_queue')
+      expect(result).to be_kind_of(Array)
+      expect(result).to include('test_queue', 'job')
+    end
+
+    describe '#acknowledge' do
+      it "returns removes job from queue and returns true if it succeeds" do
+        @client.call('DEBUG', 'FLUSHALL')
+        job_id = @client.push('test_queue', 'test job', 1000)
+        expect(@client.call('QLEN', 'test_queue')).to eq 1
+        expect(@broker.acknowledge(job_id)).to eq true
+        expect(@client.call('QLEN', 'test_queue')).to eq 0
+      end
+
+      it "raises an error for a bad job id" do
+        expect{@broker.acknowledge('bad_id')}.to raise_error(RuntimeError)
+      end
+    end
+
+  end
+end

data/spec/disque_jockey/configuration_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe DisqueJockey::Configuration do
+  context 'development' do
+    before { ENV['DISQUE_JOCKEY_ENV'] = 'development' }
+    after {  ENV['DISQUE_JOCKEY_ENV'] = 'test' }
+    subject { DisqueJockey::Configuration.new }
+
+    it { expect(subject.daemonize?).to eq false }
+  end
+
+  it "defines a log path method" do
+    expect(DisqueJockey::Configuration.new).to respond_to(:log_path)
+    expect(DisqueJockey::Configuration.new).to respond_to(:log_path=)
+    config = DisqueJockey::Configuration.new
+    config.log_path = 'spec-path'
+    expect(config.log_path).to eq 'spec-path'
+  end
+end

data/spec/disque_jockey/disque_jockey_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe DisqueJockey do
+
+  it "sets Thread.abort_on_exception to true" do
+    expect(Thread.abort_on_exception).to eq true
+  end
+
+  it "::configuration returns a configuration object" do
+    expect(DisqueJockey.configuration.class).to eq DisqueJockey::Configuration
+  end
+
+  it "::configure method changes the configuration" do
+    expect do
+      DisqueJockey.configure { |config| config.worker_groups = 1 }
+    end.to_not raise_error
+    expect(DisqueJockey.configuration.worker_groups).to eq 1
+  end
+
+  it "::run! calls the Supervisor::work! method" do
+    expect(DisqueJockey::Supervisor).to receive(:work!)
+    DisqueJockey.run!
+  end
+end

data/spec/disque_jockey/logger_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe DisqueJockey::Logger do
+  subject { DisqueJockey::Logger }
+  it "defines instance methods" do
+    [:logger, :fatal, :error, :warn, :info, :debug].each do |method|
+      expect(subject.new('test')).to respond_to(method)
+    end
+  end
+end

data/spec/disque_jockey/supervisor_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe DisqueJockey::Supervisor do
+  subject { DisqueJockey::Supervisor }
+
+  after(:each) do
+    subject.instance_variable_set(:@worker_classes, [])
+  end
+
+  it "::register_worker adds a worker" do
+    stub_const("FakeWorker", '')
+    subject.register_worker(FakeWorker)
+    expect(subject.worker_classes).to eq [FakeWorker]
+  end
+
+  it "::logger provides a DisqueJockey::Logger object" do
+    expect(subject.logger.class).to eq DisqueJockey::Logger
+  end
+
+  it "::spawn_worker_groups spawns as many worker groups as the config says" do
+    group = double("WorkerGroup", work!: true)
+    expect(DisqueJockey::WorkerGroup).to receive(:new).twice.and_return(group)
+    allow(Process).to receive(:fork).and_yield
+    allow_any_instance_of(DisqueJockey::Configuration).to receive(:worker_groups).and_return 2
+    expect(group).to receive(:work!).twice
+    subject.send(:spawn_worker_groups)
+  end
+
+  it "::load_workers loads classes in a workers directory" do
+    expect(Object.const_defined?('FixtureWorker')).to eq false
+    subject.send(:load_workers)
+    expect(Object.const_defined?('FixtureWorker')).to eq true
+  end
+
+  it "::spawn_worker_group forks a process and creates a new worker group" do
+    group = double("WorkerGroup", work!: true)
+    expect(DisqueJockey::WorkerGroup).to receive(:new).and_return(group)
+    expect(Process).to receive(:fork).and_yield
+    subject.send(:spawn_worker_group)
+  end
+end

data/spec/disque_jockey/worker_group_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'disque_jockey/worker_shared_setup'
+module DisqueJockey
+  describe WorkerGroup do
+    include_context "worker setup"
+    subject { WorkerGroup }
+
+    describe "work!" do
+      before(:each) do
+        @worker_classes = [SpecWorker, SecondSpecWorker]
+        allow_any_instance_of(Broker).to receive(:acknowledge).and_return(true)
+        # stub out the method that loops forever so we can get on with our tests
+        allow_any_instance_of(subject).to receive(:work_until_signal) do
+          # We sleep here so that the job has time to run before we return from
+          # this method.  I'm sure there is a better way to do this.
+          sleep(0.01)
+        end
+      end
+
+      it "can be instantiated without errors" do
+        expect{subject.new([SpecWorker]).work!}.to_not raise_error
+      end
+
+      it "instantiates the correct number of workers" do
+        [SpecWorker, SecondSpecWorker].each do |worker_class|
+          allow(worker_class).to receive(:new).and_call_original
+          expect(worker_class).to receive(:new).exactly(worker_class.thread_count).times
+        end
+        subject.new(@worker_classes).work!
+      end
+
+
+      it "gives workers jobs to perform" do
+        allow_any_instance_of(Broker).to receive(:fetch_message_from).and_return(['dummy', 'test_id', 'test job'])
+        expect_any_instance_of(SecondSpecWorker).to receive(:handle).at_least(:once)
+        subject.new(@worker_classes).work!
+      end
+
+      describe "handling logic around jobs" do
+
+        it "times out workers that take too long" do
+          allow_any_instance_of(Broker).to receive(:fetch_message_from).and_return(['dummy', 'test_id', 'test job'])
+          allow_any_instance_of(subject).to receive(:work_until_signal) { sleep(0.2) }
+          expect_any_instance_of(SlowWorker).to receive(:log_exception).at_least(:once)
+          subject.new([SlowWorker]).work!
+        end
+
+        xit "acknowledges jobs if they are processed without errors" do
+          allow_any_instance_of(subject).to receive(:work_until_signal) { sleep(0.1) }
+          allow_any_instance_of(Broker).to receive(:fetch_message_from).and_return(['dummy', 'test_id', 'test job'])
+          expect_any_instance_of(Broker).to receive(:acknowledge).with('test_id').at_least(:once)
+          subject.new([SecondSpecWorker]).work!
+        end
+      end
+    end
+
+  end
+end

data/spec/disque_jockey/worker_shared_setup.rb

@@ -0,0 +1,25 @@
+shared_context "worker setup" do
+
+  before(:all) do
+
+    class SpecWorker < DisqueJockey::Worker
+      subscribe_to "test"
+      def handle(job); end
+    end
+    
+    class SecondSpecWorker < DisqueJockey::Worker
+      subscribe_to "other-test"
+      threads 1
+      timeout 1
+      def handle(job); end
+    end
+
+    class SlowWorker < DisqueJockey::Worker
+      subscribe_to "slow-test"
+      timeout 0.01
+      threads 1
+      def handle(job); sleep(0.1); end
+    end
+
+  end
+end

data/spec/disque_jockey/worker_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'disque_jockey'
+require 'disque_jockey/worker_shared_setup'
+
+describe DisqueJockey::Worker do
+  include_context "worker setup"
+
+  it "defines class methods" do
+    [ :queue_name, :thread_count, :timeout_seconds, 
+      :subscribe_to, :timeout, :threads
+    ].each do |method|
+      expect(DisqueJockey::Worker).to respond_to(method)
+    end
+  end
+
+  it "defines logger method" do
+     expect(DisqueJockey::Worker.instance_methods.include?(:logger)).to eq(true)
+  end
+
+  it "keeps track of classes that subclass it" do
+    initial_subclass_count = DisqueJockey::Supervisor.worker_classes.length
+    class ChildWorker < DisqueJockey::Worker; end
+    expect(DisqueJockey::Supervisor.worker_classes.length).to eq (initial_subclass_count + 1)
+  end
+
+  context "defaults" do
+    it "sets a default for timeout" do
+      expect(SpecWorker.timeout_seconds).to be(30)
+    end
+
+    it "sets a default for thread_count" do
+      expect(SpecWorker.thread_count).to be(2)
+    end
+  end
+
+  context "class methods"
+  context "overrides" do
+    it "allows overrides for timeout, and thread_count" do
+      expect(SecondSpecWorker.timeout_seconds).to be(1)
+      expect(SecondSpecWorker.thread_count).to be(1)
+    end
+  end
+  
+  context "instance methods"
+  describe "#initialize" do
+    before do 
+      @logger = double(:logger, info: true, error: true, warn: true)
+      allow(@logger).to receive(:new).and_return(@logger)
+    end
+
+    it "sets a logger" do
+      worker = SpecWorker.new(@logger)
+      expect(worker.logger).to_not be_nil
+    end
+  end
+end
+

data/spec/fixtures/workers/fixture_worker.rb

@@ -0,0 +1 @@
+class FixtureWorker < DisqueJockey::Worker; end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+ENV['DISQUE_JOCKEY_ENV'] = 'test'
+require 'disque_jockey'

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: disque_jockey
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Devin Riley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: disque
+  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: logging
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A framework for managing and running ruby background workers.
+email:
+- devinriley84+disque_jockey@gmail.com
+executables:
+- disque_jockey
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/disque_jockey
+- disque_jockey.gemspec
+- lib/disque_jockey.rb
+- lib/disque_jockey/broker.rb
+- lib/disque_jockey/configuration.rb
+- lib/disque_jockey/logger.rb
+- lib/disque_jockey/supervisor.rb
+- lib/disque_jockey/version.rb
+- lib/disque_jockey/worker.rb
+- lib/disque_jockey/worker_group.rb
+- spec/disque_jockey/broker_spec.rb
+- spec/disque_jockey/configuration_spec.rb
+- spec/disque_jockey/disque_jockey_spec.rb
+- spec/disque_jockey/logger_spec.rb
+- spec/disque_jockey/supervisor_spec.rb
+- spec/disque_jockey/worker_group_spec.rb
+- spec/disque_jockey/worker_shared_setup.rb
+- spec/disque_jockey/worker_spec.rb
+- spec/fixtures/workers/fixture_worker.rb
+- spec/log/.keep
+- spec/spec_helper.rb
+homepage: https://github.com/DevinRiley/disque_jockey
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A background job framework.
+test_files:
+- spec/disque_jockey/broker_spec.rb
+- spec/disque_jockey/configuration_spec.rb
+- spec/disque_jockey/disque_jockey_spec.rb
+- spec/disque_jockey/logger_spec.rb
+- spec/disque_jockey/supervisor_spec.rb
+- spec/disque_jockey/worker_group_spec.rb
+- spec/disque_jockey/worker_shared_setup.rb
+- spec/disque_jockey/worker_spec.rb
+- spec/fixtures/workers/fixture_worker.rb
+- spec/log/.keep
+- spec/spec_helper.rb