good_job 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9604c74cf4073b178401ec0cb606e55732f087464058bebe968b666c31c242d4
-  data.tar.gz: f4af6118d55f231d15c3ffa2a3aac9f625911889a4f1adce5c14dcb2626af4d5
+  metadata.gz: 2c0fc31238c6d66b5b9ed3ddc0d4b9393a0a5a2cca85c7fcd0f2f24650892675
+  data.tar.gz: d6484d63b86eb7bc748b308cbfebe1ca7798fa1fa77d9542754dc99504f12244
 SHA512:
-  metadata.gz: 46e92a0efba3937d274942ea55371f65cc3aa0451bc625bff6856be09525446960d192473548820bf1c289713151ee82e5cf1bdef21252da6a0927baafe5cc9c
-  data.tar.gz: 9e1d108190398d5d698713e12ba981d63ee121f095185990f1f0963bee36e4f4760a22c9f64f8148624ba6be931a89943e48a601c4395ad825254d5d23c86c58
+  metadata.gz: 7e4d9fc5ae59750231906be49188aba712f1bdfbe2d66ed441f82c69ad267b0a056fed12998fe594c33c862f81d36d912a56d598c8e436e1e0ea225634abe66a
+  data.tar.gz: b02e2c08035b4a90713a0378e2b83173232baec7bf6b22ecbd56033d8fd38e78be0e3d992a7ca4e3339485014bc97fac62efd3d3fd94df195fceb9248703f004

data/README.md

@@ -2,14 +2,34 @@
 
 GoodJob is a multithreaded, Postgres-based ActiveJob backend for Ruby on Rails.
 
+Inspired by [Delayed::Job](https://github.com/collectiveidea/delayed_job) and [Que](https://github.com/que-rb/que), GoodJob’s design principles are:
+
+- Stand on the shoulders of ActiveJob. For example, [exception](https://edgeguides.rubyonrails.org/active_job_basics.html#exceptions) and [retry](https://edgeguides.rubyonrails.org/active_job_basics.html#retrying-or-discarding-failed-jobs) behavior. 
+- Stand on the shoulders of Ruby on Rails. For example, ActiveRecord ORM, connection pools, and [multithreaded support](https://guides.rubyonrails.org/threading_and_code_execution.html) with [Concurrent-Ruby](https://github.com/ruby-concurrency/concurrent-ruby).
+- Stand on the shoulders of Postgres. For example, Advisory Locks.
+- Convention over simplicity over performance. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'good_job', github: 'bensheldon/good_job'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
 ## Usage
 
 1. Create a database migration:
     ```bash
-    bin/rails g migration CreateGoodJobs
+    $ bin/rails g migration CreateGoodJobs
     ```
 
-    And then add to the newly created file:
+    Add to the newly created migration file:
 
     ```ruby
     class CreateGoodJobs < ActiveRecord::Migration[6.0]
@@ -27,6 +47,13 @@ GoodJob is a multithreaded, Postgres-based ActiveJob backend for Ruby on Rails.
       end
     end
     ```
+    
+    Run the migration:
+    
+    ```bash
+    $ bin/rails db:migrate
+    ```
+    
 1. Configure the ActiveJob adapter:
     ```ruby
     # config/environments/production.rb
@@ -41,18 +68,6 @@ GoodJob is a multithreaded, Postgres-based ActiveJob backend for Ruby on Rails.
     $ bundle exec good_job
     ```
 
-## Installation
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'good_job', github: 'bensheldon/good_job'
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
 ## Development
 
 To run tests:
@@ -80,8 +95,31 @@ $ bundle install
 # => Using good_job 0.1.0 from https://github.com/bensheldon/good_job.git (at /Users/You/Projects/good_job@dc57fb0)
 ```
 
+## Releasing
+
+Package maintainers can release this gem with the following [gem-release](https://github.com/svenfuchs/gem-release) command:
+
+```bash
+# Sign into rubygems
+$ gem signin
+
+# Increase the version number
+$ gem bump -v minor --no-commit
+
+# Update the changelog
+$ bundle exec changelog
+
+# Commit the version and changelog to git
+$ bundle commit_version
+
+# Push to rubygems.org
+$ gem release
+```
+
 ## Contributing
+
 Contribution directions go here.
 
 ## License
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/good_job/adapter.rb

@@ -22,7 +22,14 @@ module GoodJob
       params[:scheduled_at] = Time.at(timestamp) if timestamp
 
       good_job = GoodJob::Job.create(params)
-      @scheduler.enqueue(good_job) if inline?
+      job.provider_job_id = good_job.id
+
+      GoodJob.tag_logger do
+        ActiveSupport::Notifications.instrument("create.good_job", { good_job: good_job, job: job })
+        @scheduler.enqueue(good_job) if inline?
+      end
+
+      good_job
     end
 
     def shutdown(wait: true)

data/lib/good_job/logging.rb

@@ -0,0 +1,60 @@
+module GoodJob::Logging
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+    def self.tag_logger(*tags)
+      if logger.respond_to?(:tagged)
+        tags.unshift "GoodJob" unless logger.formatter.current_tags.include?("GoodJob")
+        logger.tagged(*tags) { yield }
+      else
+        yield
+      end
+    end
+  end
+
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def create(event)
+      good_job = event.payload[:good_job]
+
+      info do
+        "Created GoodJob resource with id #{good_job.id}"
+      end
+    end
+
+    def timer_task_finished(event)
+      result = event.payload[:result]
+      exception = event.payload[:error]
+
+      if exception
+        error do
+          "ERROR: #{exception}\n #{exception.backtrace}"
+        end
+      end
+    end
+
+    def job_finished(event)
+      result = event.payload[:result]
+      exception = event.payload[:error]
+
+      if exception
+        error do
+          "ERROR: #{exception}\n #{exception.backtrace}"
+        end
+      end
+    end
+
+    private
+
+    def logger
+      GoodJob.logger
+    end
+
+    def thread_name
+      Thread.current.name || Thread.current.object_id
+    end
+  end
+end
+
+GoodJob::Logging::LogSubscriber.attach_to :good_job

data/lib/good_job/railtie.rb

@@ -1,4 +1,7 @@
 module GoodJob
   class Railtie < ::Rails::Railtie
+    initializer "good_job.logger" do
+      ActiveSupport.on_load(:good_job) { self.logger = ::Rails.logger }
+    end
   end
 end

data/lib/good_job/scheduler.rb

@@ -4,7 +4,7 @@ require "concurrent/utility/processor_counter"
 
 module GoodJob
   class Scheduler
-    MINIMUM_EXECUTION_INTERVAL = 0.1
+    MAX_THREADS = Concurrent.processor_count
 
     DEFAULT_TIMER_OPTIONS = {
       execution_interval: 1,
@@ -12,16 +12,14 @@ module GoodJob
       run_now: true
     }.freeze
 
-    MAX_THREADS = Concurrent.processor_count
-
     DEFAULT_POOL_OPTIONS = {
-      name:            'good_job',
-      min_threads:     0,
-      max_threads:     MAX_THREADS,
-      auto_terminate:  true,
-      idletime:        0,
-      max_queue:       0,
-      fallback_policy:  :abort # shouldn't matter -- 0 max queue
+      name: 'good_job',
+      min_threads: 0,
+      max_threads: MAX_THREADS,
+      auto_terminate: true,
+      idletime: 0,
+      max_queue: 0,
+      fallback_policy: :abort # shouldn't matter -- 0 max queue
     }.freeze
 
     def initialize(query = GoodJob::Job.all, **options)
@@ -30,13 +28,16 @@ module GoodJob
       @pool = Concurrent::ThreadPoolExecutor.new(DEFAULT_POOL_OPTIONS)
       @timer = Concurrent::TimerTask.new(DEFAULT_TIMER_OPTIONS) do
         idle_threads = @pool.max_length - @pool.length
-        puts "There are idle_threads: #{idle_threads}"
         create_thread if idle_threads.positive?
-        true
       end
+      @timer.add_observer(TimerObserver.new)
       @timer.execute
     end
 
+    def ordered_query
+      @query.where("scheduled_at < ?", Time.current).or(@query.where(scheduled_at: nil)).order(priority: :desc)
+    end
+
     def execute
     end
 
@@ -53,36 +54,31 @@ module GoodJob
     end
 
     def create_thread
-      future = Concurrent::Future.new(args: [@query], executor: @pool) do |query|
+      future = Concurrent::Future.new(args: [ordered_query], executor: @pool) do |query|
         Rails.application.executor.wrap do
-          thread_name = Thread.current.name || Thread.current.object_id
-          while job = query.with_advisory_lock.first
-            puts "Executing job #{job.id} in thread #{thread_name}"
+          while good_job = query.with_advisory_lock.first
+            ActiveSupport::Notifications.instrument("job_started.good_job", { good_job: good_job })
 
-            JobWrapper.new(job).perform
+            JobWrapper.new(good_job).perform
 
-            job.advisory_unlock
+            good_job.advisory_unlock
           end
-          true
         end
+        true
       end
-      future.add_observer(TaskObserver.new(self))
+      future.add_observer(TaskObserver.new)
       future.execute
     end
 
-    class TaskObserver
-      def initialize(scheduler)
-        @scheduler = scheduler
+    class TimerObserver
+      def update(time, result, error)
+        ActiveSupport::Notifications.instrument("timer_task_finished.good_job", { result: result, error: error, time: time })
       end
+    end
 
-      def update(time, result, ex)
-        if result
-          puts "(#{time}) Execution successfully returned #{result}\n"
-        elsif ex.is_a?(Concurrent::TimeoutError)
-          puts "(#{time}) Execution timed out\n"
-        else
-          puts "(#{time}) Execution failed with error #{result} #{ex}\n"
-        end
+    class TaskObserver
+      def update(time, result, error)
+        ActiveSupport::Notifications.instrument("job_finished.good_job", { result: result, error: error, time: time })
       end
     end
   end

data/lib/good_job/version.rb

@@ -1,3 +1,3 @@
 module GoodJob
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/good_job.rb

@@ -1,5 +1,7 @@
 require "rails"
+require 'good_job/railtie'
 
+require 'good_job/logging'
 require 'good_job/lockable'
 require 'good_job/job'
 require 'good_job/inline_scheduler'
@@ -8,5 +10,7 @@ require "good_job/job_wrapper"
 require 'good_job/adapter'
 
 module GoodJob
-  # Your code goes here...
+  include Logging
+
+  ActiveSupport.run_load_hooks(:good_job, self)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-03 00:00:00.000000000 Z
+date: 2020-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: github_changelog_generator
+  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: pg
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +140,7 @@ files:
 - lib/good_job/job.rb
 - lib/good_job/job_wrapper.rb
 - lib/good_job/lockable.rb
+- lib/good_job/logging.rb
 - lib/good_job/railtie.rb
 - lib/good_job/scheduler.rb
 - lib/good_job/version.rb