employer 0.2 → 0.3

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+script: rspec

data/README.md

@@ -1,4 +1,4 @@
-# Employer
+# Employer [![Build Status](https://travis-ci.org/mkremer/employer.png)](https://travis-ci.org/mkremer/employer)
 
 There comes a time in the life of an application that async job processing
 becomes a requirement. If you want something flexible that you can easily adapt
@@ -140,13 +140,13 @@ forking_employees 4
 The comments in the file pretty much explain how you should edit it.
 
 When setup properly you can start processing jobs by running `employer` (or
-`employer -c /path/to/employer\_config.rb`, likely prepended with `bundle exec`)
+`employer -c /path/to/employer_config.rb`, likely prepended with `bundle exec`)
 
 In your application code you can obtain a pipeline to enqueue jobs with like so:
 
 ```ruby
 # Obtain the pipeline
-pipeline = Employer::Workshop.enqueue("/path/to/employer\_config.rb")
+pipeline = Employer::Workshop.enqueue("/path/to/employer_config.rb")
 
 # Enqueue a job
 job = NamePutsJob.new

data/employer.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.version       = Employer::VERSION
   gem.authors       = ["Mark Kremer"]
   gem.email         = ["mark@without-brains.net"]
-  gem.summary       = %q{Job processing made easy}
+  gem.summary       = %q{Job processing with pluggable backends made easy}
   gem.homepage      = "https://github.com/mkremer/employer"
   gem.license       = "MIT"
 
@@ -19,6 +19,7 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency "thor", "~> 0.17"
 
+  gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "pry"
 end

data/lib/employer.rb

@@ -1,5 +1,6 @@
 require "employer/version"
 require "employer/errors"
+require "employer/logger"
 require "employer/pipeline"
 require "employer/job"
 require "employer/employees"

data/lib/employer/boss.rb

@@ -2,16 +2,17 @@ require_relative "errors"
 
 module Employer
   class Boss
-    attr_reader :pipeline, :employees, :keep_going, :sleep_time
+    attr_reader :pipeline, :logger, :employees, :keep_going, :sleep_time
 
-    def initialize
-      @pipeline = nil
+    def initialize(logger)
+      @logger = logger
+      @pipeline = Employer::Pipeline.new(logger)
       @employees = []
       @sleep_time_index = 0
     end
 
-    def pipeline=(pipeline)
-      @pipeline = pipeline
+    def pipeline_backend=(backend)
+      pipeline.backend = backend
     end
 
     def allocate_employee(employee)
@@ -92,6 +93,7 @@ module Employer
 
     def delegate_job(job)
       raise Employer::Errors::NoEmployeeFree unless employee = free_employee
+      logger.info("Delegating job #{job.id} to employee #{employee.object_id}")
       employee.work(job)
     end
 

data/lib/employer/cli.rb

@@ -1,5 +1,6 @@
 require "thor"
 require "fileutils"
+require "logger"
 
 module Employer
   class CLI < Thor
@@ -14,7 +15,8 @@ module Employer
       end
 
       int_count = 0
-      workshop = Employer::Workshop.setup(File.read(options[:config]))
+      workshop = Employer::Workshop.new(File.read(options[:config]))
+      workshop.log_to(::Logger.new(STDOUT))
 
       Signal.trap("INT") do
         int_count += 1

data/lib/employer/employees/abstract_employee.rb

@@ -3,7 +3,11 @@ require_relative "../errors"
 module Employer
   module Employees
     class AbstractEmployee
-      attr_reader :job
+      attr_reader :job, :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
 
       def work(job)
         raise Employer::Errors::EmployeeBusy unless free?
@@ -11,7 +15,9 @@ module Employer
       end
 
       def perform_job
+        logger.debug("Employee #{self.object_id} is now performing job #{job.id}")
         job.perform
+        logger.debug("Employee #{self.object_id} has now completed #{job.id}")
       end
 
       def wait_for_completion

data/lib/employer/logger.rb

@@ -0,0 +1,47 @@
+module Employer
+  class Logger
+    attr_reader :loggers
+
+    def initialize
+      @loggers = []
+    end
+
+    def append_to(logger)
+      loggers << logger
+    end
+
+    def debug(message = nil, &block)
+      log(:debug, message, &block)
+    end
+
+    def error(message = nil, &block)
+      log(:error, message, &block)
+    end
+
+    def warn(message = nil, &block)
+      log(:warn, message, &block)
+    end
+
+    def info(message = nil, &block)
+      log(:info, message, &block)
+    end
+
+    def fatal(message = nil, &block)
+      log(:fatal, message, &block)
+    end
+
+    private
+
+    def log(level, message = nil, &block)
+      loggers.each do |logger|
+        next unless logger.respond_to?(level)
+
+        if message
+          logger.public_send(level, message)
+        elsif block
+          logger.public_send(level, &block)
+        end
+      end
+    end
+  end
+end

data/lib/employer/pipeline.rb

@@ -2,6 +2,12 @@ require_relative "errors"
 
 module Employer
   class Pipeline
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
     def backend=(backend)
       @backend = backend
     end
@@ -26,21 +32,25 @@ module Employer
 
     def clear
       raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      logger.info("Clearing pipeline of all jobs!")
       backend.clear
     end
 
     def complete(job)
       raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      logger.info("Marking job #{job.id} as complete")
       backend.complete(job)
     end
 
     def reset(job)
       raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      logger.info("Resetting job #{job.id}")
       backend.reset(job)
     end
 
     def fail(job)
       raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      logger.info("Marking job #{job.id} as failed")
       backend.fail(job)
     end
 

data/lib/employer/version.rb

@@ -1,3 +1,3 @@
 module Employer
-  VERSION = "0.2"
+  VERSION = "0.3"
 end

data/lib/employer/workshop.rb

@@ -2,16 +2,29 @@ require_relative "errors"
 
 module Employer
   class Workshop
-    def self.setup(config_code, skip_employees = false)
-      boss = Employer::Boss.new
-      pipeline = Employer::Pipeline.new
-      boss.pipeline = pipeline
-      workshop = new(boss, config_code, skip_employees)
-    end
+    attr_reader :logger
 
     def self.pipeline(filename)
-      workshop = setup(File.read(filename), true)
-      workshop.pipeline
+      new(File.read(filename), true).pipeline
+    end
+
+    def initialize(config_code, skip_employees = false)
+      @logger = Employer::Logger.new
+      @boss = Employer::Boss.new(logger)
+      @forking_employees = 0
+      @threading_employees = 0
+
+      instance_eval(config_code)
+
+      unless skip_employees
+        @forking_employees.times do
+          @boss.allocate_employee(Employer::Employees::ForkingEmployee.new(logger))
+        end
+
+        @threading_employees.times do
+          @boss.allocate_employee(Employer::Employees::ThreadingEmployee.new(logger))
+        end
+      end
     end
 
     def run
@@ -31,6 +44,10 @@ module Employer
       @boss.pipeline
     end
 
+    def log_to(log_to_logger)
+      logger.append_to(log_to_logger)
+    end
+
     private
 
     def forking_employees(number)
@@ -42,25 +59,7 @@ module Employer
     end
 
     def pipeline_backend(backend)
-      @boss.pipeline.backend = backend
-    end
-
-    def initialize(boss, config_code, skip_employees)
-      @boss = boss
-      @forking_employees = 0
-      @threading_employees = 0
-
-      instance_eval(config_code)
-
-      unless skip_employees
-        @forking_employees.times do
-          @boss.allocate_employee(Employer::Employees::ForkingEmployee.new)
-        end
-
-        @threading_employees.times do
-          @boss.allocate_employee(Employer::Employees::ThreadingEmployee.new)
-        end
-      end
+      @boss.pipeline_backend = backend
     end
   end
 end

data/spec/employer/boss_spec.rb

@@ -1,23 +1,49 @@
 require "employer/boss"
 
 describe Employer::Boss do
+  before(:each) do
+    stub_const("Employer::Pipeline", Class.new)
+    Employer::Pipeline.stub(:new).and_return(pipeline)
+  end
+
   let(:pipeline) { double("Pipeline") }
   let(:employee) { double("Employee") }
   let(:free_employee) { double("Free employee", free?: true) }
   let(:busy_employee) { double("Busy employee", free?: false) }
-  let(:boss) { Employer::Boss.new }
+  let(:logger) { double("Logger").as_null_object }
+  let(:boss) { Employer::Boss.new(logger) }
 
-  it "can be given a pipeline" do
-    boss.pipeline = pipeline
-    boss.pipeline.should eq(pipeline)
+  describe "#initialize" do
+    let(:logger) { double("Logger") }
+
+    it "sets the logger" do
+      boss = Employer::Boss.new(logger)
+      boss.logger.should eq(logger)
+    end
+
+    it "sets a pipeline with the logger" do
+      Employer::Pipeline.should_receive(:new).with(logger).and_return(pipeline)
+      boss = Employer::Boss.new(logger)
+      boss.pipeline.should eq(pipeline)
+    end
   end
 
-  it "can be given employees" do
-    john = double
-    jane = double
-    boss.allocate_employee(john)
-    boss.allocate_employee(jane)
-    boss.employees.should eq([john, jane])
+  describe "#pipeline_backend=" do
+    it "sets the pipeline backend" do
+      backend = double("Backend")
+      boss.pipeline.should_receive(:backend=).with(backend)
+      boss.pipeline_backend = backend
+    end
+  end
+
+  describe "#allocate_employee" do
+    it "can be given employees" do
+      john = double
+      jane = double
+      boss.allocate_employee(john)
+      boss.allocate_employee(jane)
+      boss.employees.should eq([john, jane])
+    end
   end
 
   describe "#manage" do
@@ -47,7 +73,6 @@ describe Employer::Boss do
 
     before(:each) do
       boss.stub(:get_work).and_return(job1, job2, nil, nil)
-      boss.pipeline = pipeline
     end
 
     it "puts free employees to work while work is available" do
@@ -85,7 +110,6 @@ describe Employer::Boss do
   describe "#get_work" do
     before(:each) do
       pipeline.stub(:dequeue).and_return(nil)
-      boss.pipeline = pipeline
     end
 
     it "increases sleep time each time it gets no job" do
@@ -116,10 +140,6 @@ describe Employer::Boss do
   end
 
   describe "#update_job_status" do
-    before(:each) do
-      boss.pipeline = pipeline
-    end
-
     let(:job) { double("Job") }
     let(:employee) { employee = double("Employee", job: job) }
 

data/spec/employer/logger_spec.rb

@@ -0,0 +1,95 @@
+require "employer/logger"
+
+describe Employer::Logger do
+  let(:logger) { Employer::Logger.new }
+  let(:stdout_logger) { double("STDOUT Logger") }
+  let(:file_logger) { double("File Logger") }
+  let(:message) { "log me, please" }
+  let(:block) { lambda { "log me please" } }
+
+  describe "#append_to" do
+    it "accepts other loggers to write to" do
+      logger.append_to(stdout_logger)
+      logger.append_to(file_logger)
+      logger.loggers.should include(stdout_logger)
+      logger.loggers.should include(file_logger)
+    end
+  end
+
+  context "with loggers assigned" do
+    before(:each) do
+      logger.append_to(stdout_logger)
+      logger.append_to(file_logger)
+    end
+
+    describe "#debug" do
+      it "passes string messages to its loggers" do
+        stdout_logger.should_receive(:debug).with(message)
+        file_logger.should_receive(:debug).with(message)
+        logger.debug(message)
+      end
+
+      it "passes block messages to its loggers" do
+        stdout_logger.should_receive(:debug).with(&block)
+        file_logger.should_receive(:debug).with(&block)
+        logger.debug(&block)
+      end
+    end
+
+    describe "#error" do
+      it "passes string messages to its loggers" do
+        stdout_logger.should_receive(:error).with(message)
+        file_logger.should_receive(:error).with(message)
+        logger.error(message)
+      end
+
+      it "passes block messages to its loggers" do
+        stdout_logger.should_receive(:error).with(&block)
+        file_logger.should_receive(:error).with(&block)
+        logger.error(&block)
+      end
+    end
+
+    describe "#warn" do
+      it "passes string messages to its loggers" do
+        stdout_logger.should_receive(:warn).with(message)
+        file_logger.should_receive(:warn).with(message)
+        logger.warn(message)
+      end
+
+      it "passes block messages to its loggers" do
+        stdout_logger.should_receive(:warn).with(&block)
+        file_logger.should_receive(:warn).with(&block)
+        logger.warn(&block)
+      end
+    end
+
+    describe "#info" do
+      it "passes string messages to its loggers" do
+        stdout_logger.should_receive(:info).with(message)
+        file_logger.should_receive(:info).with(message)
+        logger.info(message)
+      end
+
+      it "passes block messages to its loggers" do
+        stdout_logger.should_receive(:info).with(&block)
+        file_logger.should_receive(:info).with(&block)
+        logger.info(&block)
+      end
+    end
+
+    describe "#fatal" do
+      it "passes string messages to its loggers" do
+        stdout_logger.should_receive(:fatal).with(message)
+        file_logger.should_receive(:fatal).with(message)
+        logger.fatal(message)
+      end
+
+      it "passes block messages to its loggers" do
+        stdout_logger.should_receive(:fatal).with(&block)
+        file_logger.should_receive(:fatal).with(&block)
+        logger.fatal(&block)
+      end
+    end
+  end
+end

data/spec/employer/pipeline_spec.rb

@@ -1,10 +1,20 @@
 require "employer/pipeline"
 
 describe Employer::Pipeline do
-  let(:pipeline) { Employer::Pipeline.new }
+  let(:logger) { double("Logger").as_null_object }
+  let(:pipeline) { Employer::Pipeline.new(logger) }
   let(:backend) { double("Pipeline backend") }
   let(:job) { double("Job") }
 
+  describe "#initialize" do
+    let(:logger) { double("Logger") }
+
+    it "sets the logger" do
+      pipeline = Employer::Pipeline.new(logger)
+      pipeline.logger.should eq(logger)
+    end
+  end
+
   it "has a pluggable backend" do
     pipeline.backend = backend
     pipeline.backend.should eq(backend)

data/spec/employer/workshop_spec.rb

@@ -1,105 +1,132 @@
-require "employer/workshop"
+require "employer"
 
 describe Employer::Workshop do
   before(:each) do
-    stub_const("Employer::Boss", Class.new)
-    stub_const("Employer::Pipeline", Class.new)
-    stub_const("Employer::Employees::ForkingEmployee", Class.new)
-    stub_const("Employer::Employees::ThreadingEmployee", Class.new)
     stub_const("TestPipelineBackend", Class.new)
   end
 
-  let(:boss) { double("Boss").as_null_object }
-  let(:config_code) do
-    <<CONFIG
-    pipeline_backend TestPipelineBackend.new
-    forking_employees 2
-CONFIG
-  end
-  let(:workshop) do
-    Employer::Boss.should_receive(:new).and_return(boss)
-    Employer::Workshop.setup(config_code)
-  end
+  let(:config_code) { "pipeline_backend TestPipelineBackend.new" }
 
-  describe ".setup" do
-    it "sets up a workshop" do
-      pipeline_backend = double("Pipeline backend")
-      TestPipelineBackend.should_receive(:new).and_return(pipeline_backend)
-      boss = double("Boss")
-      pipeline = double("Pipeline")
-      forking_employee1 = double("Forking Employee 1")
-      forking_employee2 = double("Forking Employee 2")
-      forking_employee3 = double("Forking Employee 3")
-      threading_employee1 = double("Threading Employee 1")
-      threading_employee2 = double("Threading Employee 2")
+  describe "#initialize" do
+    let(:workshop) { Employer::Workshop.new(config_code) }
+
+    after(:each) do
+      workshop
+    end
+
+    it "sets up a logger" do
+      workshop.logger.should be_instance_of(Employer::Logger)
+    end
+
+    it "sets up a boss" do
+      logger = double("Logger")
+      Employer::Logger.should_receive(:new).and_return(logger)
+      Employer::Boss.should_receive(:new).with(logger).and_call_original
+    end
 
+    it "sets the defined pipeline backend" do
+      boss = double("Boss")
       Employer::Boss.should_receive(:new).and_return(boss)
-      Employer::Pipeline.should_receive(:new).and_return(pipeline)
-      boss.should_receive(:pipeline=).with(pipeline)
-      boss.should_receive(:pipeline).and_return(pipeline)
-      pipeline.should_receive(:backend=).with(pipeline_backend)
-      Employer::Employees::ForkingEmployee.should_receive(:new).and_return(forking_employee1, forking_employee2, forking_employee3)
-      Employer::Employees::ThreadingEmployee.should_receive(:new).and_return(threading_employee1, threading_employee2)
-      boss.should_receive(:allocate_employee).with(forking_employee1)
-      boss.should_receive(:allocate_employee).with(forking_employee2)
-      boss.should_receive(:allocate_employee).with(forking_employee3)
-      boss.should_receive(:allocate_employee).with(threading_employee1)
-      boss.should_receive(:allocate_employee).with(threading_employee2)
-
-      config_code = <<CONFIG
-      pipeline_backend TestPipelineBackend.new
-      forking_employees 3
-      threading_employees 2
-CONFIG
-
-      workshop = Employer::Workshop.setup(config_code)
-      workshop.should be_instance_of(Employer::Workshop)
+      boss.should_receive(:pipeline_backend=).with(instance_of(TestPipelineBackend))
+    end
+
+    context "with loggers" do
+      before(:each) do
+        stub_const("MyFirstLogger", Class.new)
+        stub_const("MySecondLogger", Class.new)
+      end
+
+      let(:config_code) { "log_to MyFirstLogger.new\nlog_to MySecondLogger.new" }
+
+      it "tells the logger to append to the given logger" do
+        workshop_logger = double("Logger")
+        Employer::Logger.should_receive(:new).and_return(workshop_logger)
+        workshop_logger.should_receive(:append_to).with(instance_of(MyFirstLogger))
+        workshop_logger.should_receive(:append_to).with(instance_of(MySecondLogger))
+      end
+    end
+
+    context "with only forking employees" do
+      let(:config_code) { "forking_employees 3" }
+
+      it "allocates forking employees" do
+        Employer::Employees::ForkingEmployee.should_receive(:new).with(instance_of(Employer::Logger)).exactly(3).times.and_call_original
+        Employer::Boss.any_instance.should_receive(:allocate_employee).with(instance_of(Employer::Employees::ForkingEmployee)).exactly(3).times
+      end
+
+      it "does not instantiate threading employees" do
+        Employer::Employees::ThreadingEmployee.should_receive(:new).never
+      end
+    end
+
+    context "with only threading employees" do
+      let(:config_code) { "threading_employees 2" }
+
+      it "allocates threading employees" do
+        Employer::Employees::ThreadingEmployee.should_receive(:new).with(instance_of(Employer::Logger)).exactly(2).times.and_call_original
+        Employer::Boss.any_instance.should_receive(:allocate_employee).with(instance_of(Employer::Employees::ThreadingEmployee)).exactly(2).times
+      end
+
+      it "does not instantiate forking employees" do
+        Employer::Employees::ForkingEmployee.should_receive(:new).never
+      end
     end
   end
 
   describe ".pipeline" do
-    it "sets up a pipeline to feed the workshop" do
-      boss = double("Boss").as_null_object
-      Employer::Boss.should_receive(:new).and_return(boss)
-      pipeline = double("Pipeline").as_null_object
-      boss.stub(:pipeline).and_return(pipeline)
-      Employer::Pipeline.should_receive(:new).and_return(pipeline)
-      pipeline_backend = double("Pipeline backend")
-      TestPipelineBackend.should_receive(:new).and_return(pipeline_backend)
+    it "returns a pipeline to feed the workshop" do
+      Employer::Pipeline.should_receive(:new).and_call_original
+      Employer::Pipeline.any_instance.should_receive(:backend=).with(instance_of(TestPipelineBackend)).and_call_original
       File.should_receive(:read).with("config/employee.rb").and_return(config_code)
-
       workshop_pipeline = Employer::Workshop.pipeline("config/employee.rb")
-      workshop_pipeline.should eq(pipeline)
+      workshop_pipeline.should be_instance_of(Employer::Pipeline)
     end
   end
 
-  describe "#run" do
-    it "should call manage on the boss" do
-      boss.should_receive(:manage)
-      workshop.run
+  context "with initialized workshop" do
+    let(:workshop) { Employer::Workshop.new(config_code) }
+    let(:boss) { Employer::Boss.any_instance }
+
+    describe "#logger" do
+      it "returns the logger" do
+        workshop.logger.should be_instance_of(Employer::Logger)
+      end
     end
-  end
 
-  describe "#stop" do
-    it "should call stop_managing on the boss" do
-      boss.should_receive(:stop_managing)
-      workshop.stop
+    describe "#run" do
+      it "should call manage on the boss" do
+        boss.should_receive(:manage)
+        workshop.run
+      end
     end
-  end
 
-  describe "#stop_now" do
-    it "should call stop_managing and stop_employees on the boss" do
-      boss.should_receive(:stop_managing)
-      boss.should_receive(:stop_employees)
-      workshop.stop_now
+    describe "#stop" do
+      it "should call stop_managing on the boss" do
+        boss.should_receive(:stop_managing)
+        workshop.stop
+      end
+    end
+
+    describe "#stop_now" do
+      it "should call stop_managing and stop_employees on the boss" do
+        boss.should_receive(:stop_managing)
+        boss.should_receive(:stop_employees)
+        workshop.stop_now
+      end
+    end
+
+    describe "#pipeline" do
+      it "returns the pipeline" do
+        workshop.pipeline.should be_instance_of(Employer::Pipeline)
+      end
     end
-  end
 
-  describe "#pipeline" do
-    it "returns the pipeline" do
-      pipeline = double("Pipeline").as_null_object
-      boss.stub(:pipeline).and_return(pipeline)
-      workshop.pipeline.should eq(pipeline)
+    describe "#log_to" do
+      it "adds a logger to the workshop logger" do
+        logger = double("Logger")
+        workshop.logger.should_receive(:append_to).with(logger)
+        workshop.log_to(logger)
+      end
     end
   end
 end

data/spec/support/shared_examples/employee.rb

@@ -1,5 +1,6 @@
 shared_examples "an employee" do
-  let(:employee) { described_class.new }
+  let(:logger) { double("Logger").as_null_object }
+  let(:employee) { described_class.new(logger) }
   let(:completing_job_class) do
     Class.new do
       def perform
@@ -19,6 +20,13 @@ shared_examples "an employee" do
   let(:failing_job) { failing_job_class.new}
   let(:job) { double("Job") }
 
+  describe "#initialize" do
+    it "sets the logger" do
+      employee = described_class.new(logger)
+      employee.logger.should eq(logger)
+    end
+  end
+
   describe "#work" do
     it "rejects a job while its already working on one" do
       employee.should_receive(:free?).and_return(false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: employer
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-02 00:00:00.000000000 Z
+date: 2013-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -27,6 +27,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +86,7 @@ files:
 - .gitignore
 - .pryrc
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -90,6 +107,7 @@ files:
 - lib/employer/errors/no_employee_free.rb
 - lib/employer/errors/pipeline_backend_required.rb
 - lib/employer/job.rb
+- lib/employer/logger.rb
 - lib/employer/pipeline.rb
 - lib/employer/version.rb
 - lib/employer/workshop.rb
@@ -97,6 +115,7 @@ files:
 - spec/employer/employees/forking_employee_spec.rb
 - spec/employer/employees/threading_employee_spec.rb
 - spec/employer/job_spec.rb
+- spec/employer/logger_spec.rb
 - spec/employer/pipeline_spec.rb
 - spec/employer/workshop_spec.rb
 - spec/spec_helper.rb
@@ -114,23 +133,30 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2766441661319471233
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2766441661319471233
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Job processing made easy
+summary: Job processing with pluggable backends made easy
 test_files:
 - spec/employer/boss_spec.rb
 - spec/employer/employees/forking_employee_spec.rb
 - spec/employer/employees/threading_employee_spec.rb
 - spec/employer/job_spec.rb
+- spec/employer/logger_spec.rb
 - spec/employer/pipeline_spec.rb
 - spec/employer/workshop_spec.rb
 - spec/spec_helper.rb