chore-core 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd6b4ede9ed3d138dde2225105cb0bb1d28e5411
-  data.tar.gz: 1aee13a468b20323eefa1b854469c867ce676895
+  metadata.gz: e8debf965223bd61c1b247c0c275c3a4f758085f
+  data.tar.gz: 51b646120ff568753112859186b6714a3846a819
 SHA512:
-  metadata.gz: c76ac25d8026e1a61fb3169bbefaf4151be6a586c60161624031b48761c83f4690a2e0e6d60ec6a8541d008323e7a64f64aa902114e899430682e5521c802a11
-  data.tar.gz: fa19122b3e452507848b6670fbe98b008e52439cabc427a57f96a850c30c45843eddee4bf230b5cd85875896f7ac89d6591fb2cd4bab1976e99091362720f677
+  metadata.gz: 6b2b1f4e194ea2704734b212255135f32c504937b4152e6bc490a25401861d34da64f38e0a8e2ca2f8c7b0be5a5f1a45dd8553fbcbcf7aa0a86028c569ac5b00
+  data.tar.gz: 264df2f96cc45d6a83a48688b602c96ee4bb2df19ad23b3d2a26c2476276ee8545798ece8e94bda0edf1a6d338e35d10fe9718d72e1ca03ff3ecfe970cb0b85a

data/README.md

@@ -52,11 +52,32 @@ Note that you can use one or the other but not both. Chore will quit and make fu
 
 ### Tips for configuring Chore
 
+For Rails, it can be necessary to add the directory you store your jobs in to the eager loading path,
+found in application.rb. You likely need a similar approach for most apps using jobs, unless you places
+them into a directory that is already eager loaded by default. One example of this might be:
+
+```ruby
+config.eager_load_paths += File.join(config.root, "app", "jobs")
+```
+
+However, due to the way eager_load_paths works in Rails, this may only solve the issue
+in your production environment. You might also find it useful for other environments
+to throw soemthing like this in an config/initializers/chore.rb file, although you
+can choose to load the job files in any way you like:
+
+```ruby
+Dir["#{Rails.root}/app/jobs/**/*"].each do |file|
+  require file unless File.directory?(file)
+end unless Rails.env.production?
+```
+
+### Producing and Consuming Jobs
+
 When it comes to configuring Chore, you have 2 main use cases - as a producer of messages, or as a consumer of messages (the consumer is also able to produce messages if need be, but is running as it's own isolated instance of your application).
 
 For producers, you must do all of your Chore configuration in an intializer.
 
-For consumers, you need to either Chorefile or Chorefile + an initializer.
+For consumers, you need to either use a Chorefile or Chorefile + an initializer.
 
 Because you are likely to use the same app as the basis for both producing and consuming messages, you'll already have a considerable amount of configuration in your Producer - it makes sense to use Chorefile to simply provide the `require` option, and stick to the initializer for the rest of the configuration to keep things DRY.
 
@@ -206,7 +227,7 @@ class TestJob
   def perform(args={})
     # Do something cool
   end
-  
+
   def before_perform_log(message)
     Chore.logger.debug "About to do something cool with: #{message.inspect}"
   end
@@ -281,6 +302,72 @@ Chore has several plugin gems available, which extend it's core functionality
 
 [Airbrake](https://github.com/Tapjoy/chore-airbrake) - Integrating Chore with Airbrake
 
+## Managing Chore processes
+
+### Sample Upstart
+
+There are lots of ways to create upstart scripts, so it's difficult to give a prescriptive
+example of the "right" way to do it. However, here are some ideas from how we run it in production
+at Tapjoy:
+
+You should have a specific user that the process runs under, for security reasons. Swap to
+this user at the beginning of your exec line
+
+```bash
+su - $USER --command '...'
+```
+
+For the command to run Chore itself keeping all of the necessary environment variables in an env
+file that your upstart can source on it's exec line, to prevent having to mix changing environment
+variables with having to change the upstart script itself
+
+```bash
+source $PATHTOENVVARS ;
+```
+
+After that, you'll want to make sure you're running Chore under the right ruby version. Additionally,
+we like to redirect STDOUT and STDERR to logger, with an app name. This makes it easy to find
+information in syslog later on. Putting that all together looks like:
+
+```bash
+rvm use $RUBYVERSION do  bundle exec chore -c Chorefile  2>&1 | logger -t $APPNAME
+```
+
+There are many other ways you could manage the Upstart file, but these are a few of the ways we
+prefer to do it. Putting it all together, it looks something like:
+
+```bash
+exec su - special_user --command 'source /the/path/to/env ; rvm use ruby-1.9.3-p484 do bundle exec chore -c Chorefile 2>&1 | logger chore-app'
+```
+
+### Locating Processes
+
+As Chore does not keep a PIDfile, and has both a master and a potential number of workers,
+you may find it difficult to isolate the exact PID for the master process.
+
+To find Chore master processes via ```ps```, you can run the following:
+
+```bash
+ps aux | grep bin/chore
+```
+
+or
+
+```bash
+pgrep -f bin/chore
+```
+
+To find a list of only Chore worker processes:
+
+```bash
+ps aux | grep chore-
+```
+
+or
+
+```bash
+pgrep -f chore-
+```
 ## Copyright
 
 Copyright (c) 2013 - 2015 Tapjoy. See LICENSE.txt for

data/lib/chore/hooks.rb

@@ -15,7 +15,13 @@ module Chore
 
   private
     def hooks_for(event)
-      (self.methods - Object.methods).grep(/^#{event}/).sort
+      candidate_methods.grep(/^#{event}/).sort
+    end
+
+    # NOTE: Any hook methods defined after this is first referenced (i.e.,
+    # after chore begins processing jobs) will not be called.
+    def candidate_methods
+      @_chore_hooks_candidate_methods ||= (self.methods - Object.methods)
     end
 
     def global_hooks_for(event)

data/lib/chore/unit_of_work.rb

@@ -8,10 +8,10 @@ module Chore
   # * +:previous_attempts+ The number of times the work has been attempted previously.
   # * +:consumer+ The consumer instance used to fetch this message. Most queue implementations won't need access to this, but some (RabbitMQ) will. So we
   # make sure to pass it along with each message. This instance will be used by the Worker for things like <tt>complete</tt> and </tt>reject</tt>.
-  class UnitOfWork < Struct.new(:id,:queue_name,:queue_timeout,:message,:previous_attempts,:consumer)
+  class UnitOfWork < Struct.new(:id,:queue_name,:queue_timeout,:message,:previous_attempts,:consumer,:decoded_message, :klass)
     # The current attempt number for the worker processing this message.
     def current_attempt
       previous_attempts + 1
     end
   end
-end
+end

data/lib/chore/version.rb

@@ -2,7 +2,7 @@ module Chore
   module Version #:nodoc:
     MAJOR = 1
     MINOR = 8
-    PATCH = 0
+    PATCH = 1
 
     STRING = [ MAJOR, MINOR, PATCH ].join('.')
   end

data/lib/chore/worker.rb

@@ -56,6 +56,8 @@ module Chore
       @work.each do |item|
         return if @stopping
         begin
+          item.decoded_message = options[:payload_handler].decode(item.message)
+          item.klass = options[:payload_handler].payload_class(item.decoded_message)
           start_item(item)
         rescue => e
           Chore.logger.error { "Failed to run job for #{item.message} with error: #{e.message} #{e.backtrace * "\n"}" }
@@ -76,9 +78,9 @@ module Chore
 
   private
     def start_item(item)
-      message = options[:payload_handler].decode(item.message)
-      klass = options[:payload_handler].payload_class(message)
-      return unless klass.run_hooks_for(:before_perform,message)
+      klass = item.klass
+      message = item.decoded_message
+      return unless klass.run_hooks_for(:before_perform, message)
 
       begin
         Chore.logger.info { "Running job #{klass} with params #{message}"}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chore-core
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.1
 platform: ruby
 authors:
 - Tapjoy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-15 00:00:00.000000000 Z
+date: 2016-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json