rufus-scheduler 3.6.0 → 3.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 02a3bef52f292ce97e4918c53add3f0f6ba7a10c
-  data.tar.gz: '059fec2bf86103a66eb30be091fcd96f4b21abaf'
+SHA256:
+  metadata.gz: 9fbe0f73068129b96196031b141f480f830e3110e35d3c5eaa2206530b1ae536
+  data.tar.gz: bec310a43820928b8d342b5b3602edf8cb27aaca8995e0a18073d70dfd3839f8
 SHA512:
-  metadata.gz: 8282e8998f735291b30a5dfd8fc0b03ce5b2a5f19a38d747b197ae46b2b8324076af6583eb3c29a49273a066899871d2edd61f1628d6b9df583144a969095afd
-  data.tar.gz: 0d272804d8de32ba93f96b25e9d7be1a6493166c33865a9bfe6ca38ea848db43a89266818d9c0fec3cc37e4a8e83623f88c56566bdb59f2afd85f6c484b0dea6
+  metadata.gz: 3e8edfd4df2ddbb0f8026ffa13fff69f9f4bd045da1638fe5ac38610992e0f7d173b20a27ad1833760d6fee62d41b5b160978e107dbc55a1b9d07dfaa62444ad
+  data.tar.gz: 412bb7e80546c5cd13bf8875f928ce6920a9e62774d296db83935adbfee56069cbb2729bb4640962351297cd55b8b5cfb92facfec38e7cb92b3ef9f7446c7283

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 # CHANGELOG.md
 
 
+### rufus-scheduler 3.8.2 - released 2022-07-12
+
+* Prevent error in shutdown when @thread is current Thread, gh-337
+* Rescue errors on the scheduling thread, gh-335
+
+
+### rufus-scheduler 3.8.1 - released 2022-01-11
+
+* Suppress warning about @resume_discard_past
+* Suppress warning about unused variable, solackerman gh-332
+
+
+### rufus-scheduler 3.8.0 - released 2021-07-14
+
+* Add #source_location to Job, gh-322
+
+
+### rufus-scheduler 3.7.0 - released 2020-12-31
+
+* Implement Job name:/n: #name and #name=, gh-309
+* Add Job #has_key?, #value, and #entries
+* Add #locals access to Job
+* Implement Scheduler#around_trigger, @jjb, gh-310
+* Accept max_worker_threads: for max_work_threads:
+* Clean up Scheduler#shutdwon, thanks @itsaphel and @jjb, gh-304, gh-315
+
+* f59df40 Bring in discard_past: for every jobs, gh-290
+* 7613277 Introduce :discard_past = false for cron, gh-305
+
+
 ### rufus-scheduler 3.6.0 - released 2019-04-22
 
 * Let Scheduler#cron fail if the cron string is invalid, gh-289

data/CREDITS.md

@@ -4,6 +4,14 @@
 
 ## Contributors
 
+* Bence Monus https://github.com/cromega gh-337 on_error and friends
+* Talia Wong https://github.com/blowfishpro gh-335 on_error and friends
+* Konstantin https://github.com/fa11enangel gh-334 nodejitsu link
+* Olle Jonsson https://github.com/olleolleolle gh-333
+* Sol Ackerman https://github.com/solarckerman gh-332
+* John Bachir https://github.com/jjb gh-310 gh-327
+* Daniel Berger https://github.com/djberg96 gh-300
+* Ceyhun Onur https://github.com/ceyonur parse_cron no_error: true
 * Darwin Wu https://github.com/dwaxe Rails initializer vs tests change
 * Mike Karolow https://github.com/mike-yesware update Travis target Rubies
 * Jack-Nie https://github.com/jack-nie gh-285 fix broken comment link
@@ -64,6 +72,8 @@
 
 ## Feedback
 
+* aphel (https://github.com/itsaphel) #shutdown vs current thread, gh-304
+* aesyondu (https://github.com/aesyondu) Rails console 4.2.x, gh-186
 * Sasha Hoellger (https://github.com/mitnal) parse_cron and readme, gh-270
 * Gian (https://github.com/snmgian) cron vs :first clarification, gh-266
 * Vito Laurenza (https://github.com/veetow) help debugging tz issues, gh-240

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2005-2019, John Mettraux, jmettraux@gmail.com
+Copyright (c) 2005-2022, John Mettraux, jmettraux@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Makefile

@@ -23,5 +23,5 @@ build: gemspec_validate
 	mv $(NAME)-$(VERSION).gem pkg/
 
 push: build
-	gem push pkg/$(NAME)-$(VERSION).gem
+	gem push --otp "$(OTP)" pkg/$(NAME)-$(VERSION).gem
 

data/README.md

@@ -1,7 +1,7 @@
 
 # rufus-scheduler
 
-[![Build Status](https://secure.travis-ci.org/jmettraux/rufus-scheduler.svg)](https://travis-ci.org/jmettraux/rufus-scheduler)
+[![tests](https://github.com/jmettraux/rufus-scheduler/workflows/test/badge.svg)](https://github.com/jmettraux/rufus-scheduler/actions)
 [![Gem Version](https://badge.fury.io/rb/rufus-scheduler.svg)](https://badge.fury.io/rb/rufus-scheduler)
 [![Join the chat at https://gitter.im/floraison/fugit](https://badges.gitter.im/floraison/fugit.svg)](https://gitter.im/floraison/fugit?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -24,7 +24,11 @@ scheduler.in '3s' do
 end
 
 scheduler.join
+  #
   # let the current thread join the scheduler thread
+  #
+  # (please note that this join should be removed when scheduling
+  # in a web application (Rails and friends) initializer)
 ```
 (run with `ruby quickstart.rb`)
 
@@ -73,6 +77,7 @@ A rufus-scheduler instance will go on scheduling while it is present among the o
 ## related and similar gems
 
 * [Whenever](https://github.com/javan/whenever) - let cron call back your Ruby code, trusted and reliable cron drives your schedule
+* [ruby-clock](https://github.com/jjb/ruby-clock) - a clock process / job scheduler for Ruby
 * [Clockwork](https://github.com/Rykian/clockwork) - rufus-scheduler inspired gem
 * [Crono](https://github.com/plashchynski/crono) - an in-Rails cron scheduler
 * [PerfectSched](https://github.com/treasure-data/perfectsched) - highly available distributed cron built on [Sequel](https://sequel.jeremyevans.net) and more
@@ -100,8 +105,8 @@ I'll drive you right to the [tracks](#so-rails).
 * The error_handler is [#on_error](#rufusscheduleron_errorjob-error) (instead of #on_exception), by default it now prints the details of the error to $stderr (used to be $stdout)
 * Rufus::Scheduler::TimeOutError renamed to Rufus::Scheduler::TimeoutError
 * Introduction of "interval" jobs. Whereas "every" jobs are like "every 10 minutes, do this", interval jobs are like "do that, then wait for 10 minutes, then do that again, and so on"
-* Introduction of a :lockfile => true/filename mechanism to prevent multiple schedulers from executing
-* "discard_past" is on by default. If the scheduler (its host) sleeps for 1 hour and a ```every '10m'``` job is on, it will trigger once at wakeup, not 6 times (discard_past was false by default in rufus-scheduler 2.x). No intention to re-introduce ```:discard_past => false``` in 3.0 for now.
+* Introduction of a lockfile: true/filename mechanism to prevent multiple schedulers from executing
+* "discard_past" is on by default. If the scheduler (its host) sleeps for 1 hour and a `every '10m'` job is on, it will trigger once at wakeup, not 6 times (discard_past was false by default in rufus-scheduler 2.x). No intention to re-introduce `discard_past: false` in 3.0 for now.
 * Introduction of Scheduler #on_pre_trigger and #on_post_trigger callback points
 
 
@@ -128,7 +133,7 @@ Yes, issues can be reported in [rufus-scheduler issues](https://github.com/jmett
 ### faq
 
 * [It doesn't work...](https://www.chiark.greenend.org.uk/~sgtatham/bugs.html)
-* [I want a refund](https://blog.nodejitsu.com/getting-refunds-on-open-source-projects)
+* [I want a refund](https://web.archive.org/web/20160425034214/http://blog.nodejitsu.com/getting-refunds-on-open-source-projects/)
 * [Passenger and rufus-scheduler](https://stackoverflow.com/questions/18108719/debugging-rufus-scheduler/18156180#18156180)
 * [Passenger and rufus-scheduler (2)](https://stackoverflow.com/questions/21861387/rufus-cron-job-not-working-in-apache-passenger#answer-21868555)
 * [Passenger in-depth spawn methods](https://www.phusionpassenger.com/library/indepth/ruby/spawn_methods/)
@@ -218,7 +223,7 @@ job =
 # also
 
 job =
-  scheduler.in '10d', :job => true do
+  scheduler.in '10d', job: true do
     # ...
   end
 ```
@@ -373,23 +378,40 @@ While paused, the scheduler still accepts schedules, but no schedule will get tr
 
 ## job options
 
-### :blocking => true
+### name: string
+
+Sets the name of the job.
+
+```ruby
+scheduler.cron '*/15 8 * * *', name: 'Robert' do |job|
+  puts "A, it's #{Time.now} and my name is #{job.name}"
+end
+
+job1 =
+  scheduler.schedule_cron '*/30 9 * * *', n: 'temporary' do |job|
+    puts "B, it's #{Time.now} and my name is #{job.name}"
+  end
+# ...
+job1.name = 'Beowulf'
+```
+
+### blocking: true
 
-By default, jobs are triggered in their own, new threads. When `:blocking => true`, the job is triggered in the scheduler thread (a new thread is not created). Yes, while a blocking job is running, the scheduler is not scheduling.
+By default, jobs are triggered in their own, new threads. When `blocking: true`, the job is triggered in the scheduler thread (a new thread is not created). Yes, while a blocking job is running, the scheduler is not scheduling.
 
-### :overlap => false
+### overlap: false
 
 Since, by default, jobs are triggered in their own new threads, job instances might overlap. For example, a job that takes 10 minutes and is scheduled every 7 minutes will have overlaps.
 
-To prevent overlap, one can set `:overlap => false`. Such a job will not trigger if one of its instances is already running.
+To prevent overlap, one can set `overlap: false`. Such a job will not trigger if one of its instances is already running.
 
 The `:overlap` option is considered before the `:mutex` option when the scheduler is reviewing jobs for triggering.
 
-### :mutex => mutex_instance / mutex_name / array of mutexes
+### mutex: mutex_instance / mutex_name / array of mutexes
 
 When a job with a mutex triggers, the job's block is executed with the mutex around it, preventing other jobs with the same mutex from entering (it makes the other jobs wait until it exits the mutex).
 
-This is different from `:overlap => false`, which is, first, limited to instances of the same job, and, second, doesn't make the incoming job instance block/wait but give up.
+This is different from `overlap: false`, which is, first, limited to instances of the same job, and, second, doesn't make the incoming job instance block/wait but give up.
 
 `:mutex` accepts a mutex instance or a mutex name (String). It also accept an array of mutex names / mutex instances. It allows for complex relations between jobs.
 
@@ -399,12 +421,12 @@ Note: creating lots of different mutexes is OK. Rufus-scheduler will place them
 
 The `:overlap` option is considered before the `:mutex` option when the scheduler is reviewing jobs for triggering.
 
-### :timeout => duration or point in time
+### timeout: duration or point in time
 
 It's OK to specify a timeout when scheduling some work. After the time specified, it gets interrupted via a Rufus::Scheduler::TimeoutError.
 
 ```ruby
-scheduler.in '10d', :timeout => '1d' do
+scheduler.in '10d', timeout: '1d' do
   begin
     # ... do something
   rescue Rufus::Scheduler::TimeoutError
@@ -425,15 +447,15 @@ In the case of an "every" job, this will be the first time (modulo the scheduler
 For a "cron" job as well, the :first will point to the first time the job has to trigger, the following trigger times are then determined by the cron string.
 
 ```ruby
-scheduler.every '2d', :first_at => Time.now + 10 * 3600 do
+scheduler.every '2d', first_at: Time.now + 10 * 3600 do
   # ... every two days, but start in 10 hours
 end
 
-scheduler.every '2d', :first_in => '10h' do
+scheduler.every '2d', first_in: '10h' do
   # ... every two days, but start in 10 hours
 end
 
-scheduler.cron '00 14 * * *', :first_in => '3d' do
+scheduler.cron '00 14 * * *', first_in: '3d' do
   # ... every day at 14h00, but start after 3 * 24 hours
 end
 ```
@@ -455,12 +477,11 @@ s = Rufus::Scheduler.new
 
 n = Time.now; p [ :scheduled_at, n, n.to_f ]
 
-s.every '3s', :first => :now do
+s.every '3s', first: :now do
   n = Time.now; p [ :in, n, n.to_f ]
 end
 
 s.join
-
 ```
 
 that'll output something like:
@@ -481,15 +502,15 @@ This option is for repeat jobs (cron / every) only.
 It indicates the point in time after which the job should unschedule itself.
 
 ```ruby
-scheduler.cron '5 23 * * *', :last_in => '10d' do
+scheduler.cron '5 23 * * *', last_in: '10d' do
   # ... do something every evening at 23:05 for 10 days
 end
 
-scheduler.every '10m', :last_at => Time.now + 10 * 3600 do
+scheduler.every '10m', last_at: Time.now + 10 * 3600 do
   # ... do something every 10 minutes for 10 hours
 end
 
-scheduler.every '10m', :last_in => 10 * 3600 do
+scheduler.every '10m', last_in: 10 * 3600 do
   # ... do something every 10 minutes for 10 hours
 end
 ```
@@ -504,16 +525,16 @@ job.last_at = Rufus::Scheduler.parse('2029-12-12')
   # set the last bound
 ```
 
-### :times => nb of times (before auto-unscheduling)
+### times: nb of times (before auto-unscheduling)
 
 One can tell how many times a repeat job (CronJob or EveryJob) is to execute before unscheduling by itself.
 
 ```ruby
-scheduler.every '2d', :times => 10 do
+scheduler.every '2d', times: 10 do
   # ... do something every two days, but not more than 10 times
 end
 
-scheduler.cron '0 23 * * *', :times => 31 do
+scheduler.cron '0 23 * * *', times: 31 do
   # ... do something every day at 23:00 but do it no more than 31 times
 end
 ```
@@ -521,7 +542,7 @@ end
 It's OK to assign nil to :times to make sure the repeat job is not limited. It's useful when the :times is determined at scheduling time.
 
 ```ruby
-scheduler.cron '0 23 * * *', :times => nolimit ? nil : 10 do
+scheduler.cron '0 23 * * *', times: (nolimit ? nil : 10) do
   # ...
 end
 ```
@@ -543,7 +564,7 @@ job.times = 10
 
 ## Job methods
 
-When calling a schedule method, the id (String) of the job is returned. Longer schedule methods return Job instances directly. Calling the shorter schedule methods with the :job => true also returns Job instances instead of Job ids (Strings).
+When calling a schedule method, the id (String) of the job is returned. Longer schedule methods return Job instances directly. Calling the shorter schedule methods with the `job: true` also returns Job instances instead of Job ids (Strings).
 
 ```ruby
   require 'rufus-scheduler'
@@ -561,7 +582,7 @@ When calling a schedule method, the id (String) of the job is returned. Longer s
     end
 
   job =
-    scheduler.in '1w', :job => true do
+    scheduler.in '1w', job: true do
       # ...
     end
 ```
@@ -587,7 +608,7 @@ Returns the scheduler instance itself.
 Returns the options passed at the Job creation.
 
 ```ruby
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.opts
   # => { :tag => 'hello' }
 ```
@@ -597,7 +618,7 @@ job.opts
 Returns the original schedule.
 
 ```ruby
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.original
   # => '10d'
 ```
@@ -644,12 +665,30 @@ job.callable
   # => #<MyHandler:0x0000000163ae88 @counter=0>
 ```
 
+### source_location
+
+Added to rufus-scheduler 3.8.0.
+
+Returns the array `[ 'path/to/file.rb', 123 ]` like `Proc#source_location` does.
+
+```ruby
+require 'rufus-scheduler'
+
+scheduler = Rufus::Scheduler.new
+
+job = scheduler.schedule_every('2h') { p Time.now }
+
+p job.source_location
+  # ==> [ '/home/jmettraux/rufus-scheduler/test.rb', 6 ]
+
+```
+
 ### scheduled_at
 
 Returns the Time instance when the job got created.
 
 ```ruby
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.scheduled_at
   # => 2013-07-17 23:48:54 +0900
 ```
@@ -752,14 +791,14 @@ job = scheduler.schedule_in('10d') do; end
 job.tags
   # => []
 
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.tags
   # => [ 'hello' ]
 ```
 
-### []=, [], key? and keys
+### []=, [], key?, has_key?, keys, values, and entries
 
-Threads have thread-local variables. Rufus-scheduler jobs have job-local variables.
+Threads have thread-local variables, similarly Rufus-scheduler jobs have job-local variables. Those are more like a dict with thread-safe access.
 
 ```ruby
 job =
@@ -774,13 +813,29 @@ sleep 3.6
 job[:counter]
   # => 3
 
-job.key?(:timestamp)
-  # => true
-job.keys
-  # => [ :timestamp, :counter ]
+job.key?(:timestamp) # => true
+job.has_key?(:timestamp) # => true
+job.keys # => [ :timestamp, :counter ]
 ```
 
-Job-local variables are thread-safe.
+Locals can be set at schedule time:
+```ruby
+job0 =
+  @scheduler.schedule_cron '*/15 12 * * *', locals: { a: 0 } do
+    # ...
+  end
+job1 =
+  @scheduler.schedule_cron '*/15 13 * * *', l: { a: 1 } do
+    # ...
+  end
+```
+
+One can fetch the Hash directly with `Job#locals`. Of course, direct manipulation is not thread-safe.
+```ruby
+job.locals.entries do |k, v|
+  p "#{k}: #{v}"
+end
+```
 
 ### call
 
@@ -805,7 +860,11 @@ require 'rufus-scheduler'
 s = Rufus::Scheduler.new
 
 def s.on_error(job, err)
-  p [ 'error in scheduled job', job.class, job.original, err.message ]
+  if job
+    p [ 'error in scheduled job', job.class, job.original, err.message ]
+  else
+    p [ 'error while scheduling', err.message ]
+  end
 rescue
   p $!
 end
@@ -921,24 +980,24 @@ Here is an example:
   scheduler.at_jobs.each(&:unschedule)
 ```
 
-### Scheduler#jobs(:tag / :tags => x)
+### Scheduler#jobs(tag: / tags: x)
 
 When scheduling a job, one can specify one or more tags attached to the job. These can be used to look up the job later on.
 
 ```ruby
-  scheduler.in '10d', :tag => 'main_process' do
+  scheduler.in '10d', tag: 'main_process' do
     # ...
   end
-  scheduler.in '10d', :tags => [ 'main_process', 'side_dish' ] do
+  scheduler.in '10d', tags: [ 'main_process', 'side_dish' ] do
     # ...
   end
 
   # ...
 
-  jobs = scheduler.jobs(:tag => 'main_process')
+  jobs = scheduler.jobs(tag: 'main_process')
     # find all the jobs with the 'main_process' tag
 
-  jobs = scheduler.jobs(:tags => [ 'main_process', 'side_dish' ]
+  jobs = scheduler.jobs(tags: [ 'main_process', 'side_dish' ]
     # find all the jobs with the 'main_process' AND 'side_dish' tags
 ```
 
@@ -963,6 +1022,10 @@ Shuts down the scheduler, ceases any scheduler/triggering activity.
 
 Shuts down the scheduler, waits (blocks) until all the jobs cease running.
 
+### Scheduler#shutdown(wait: n)
+
+Shuts down the scheduler, waits (blocks) at most n seconds until all the jobs cease running. (Jobs are killed after n seconds have elapsed).
+
 ### Scheduler#shutdown(:kill)
 
 Kills all the job (threads) and then shuts the scheduler down. Radical.
@@ -985,6 +1048,8 @@ Returns since the count of seconds for which the scheduler has been running.
 
 Lets the current thread join the scheduling thread in rufus-scheduler. The thread comes back when the scheduler gets shut down.
 
+`#join` is mostly used in standalone scheduling script (or tiny one file examples). Calling `#join` from a web application initializer will probably hijack the main thread and prevent the web application from being served. Do not put a `#join` in such a web application initializer file.
+
 ### Scheduler#threads
 
 Returns all the threads associated with the scheduler, including the scheduler thread itself.
@@ -997,7 +1062,7 @@ Lists the work threads associated with the scheduler. The query option defaults
 * :active : all the work threads currently running a Job
 * :vacant : all the work threads currently not running a Job
 
-Note that the main schedule thread will be returned if it is currently running a Job (ie one of those :blocking => true jobs).
+Note that the main schedule thread will be returned if it is currently running a Job (ie one of those `blocking: true` jobs).
 
 ### Scheduler#scheduled?(job_or_job_id)
 
@@ -1005,7 +1070,7 @@ Returns true if the arg is a currently scheduled job (see Job#scheduled?).
 
 ### Scheduler#occurrences(time0, time1)
 
-Returns a hash ```{ job => [ t0, t1, ... ] }``` mapping jobs to their potential trigger time within the ```[ time0, time1 ]``` span.
+Returns a hash `{ job => [ t0, t1, ... ] }` mapping jobs to their potential trigger time within the `[ time0, time1 ]` span.
 
 Please note that, for interval jobs, the ```#mean_work_time``` is used, so the result is only a prediction.
 
@@ -1097,7 +1162,9 @@ def scheduler.on_error(job, error)
 end
 ```
 
-## Rufus::Scheduler #on_pre_trigger and #on_post_trigger callbacks
+## Callbacks
+
+### Rufus::Scheduler #on_pre_trigger and #on_post_trigger callbacks
 
 One can bind callbacks before and after jobs trigger:
 
@@ -1121,6 +1188,21 @@ The ```trigger_time``` is the time at which the job triggers. It might be a bit
 
 Warning: these two callbacks are executed in the scheduler thread, not in the work threads (the threads where the job execution really happens).
 
+### Rufus::Scheduler#around_trigger
+
+One can create an around callback which will wrap a job:
+
+```ruby
+def s.around_trigger(job)
+  t = Time.now
+  puts "Starting job #{job.id}..."
+  yield
+  puts "job #{job.id} finished in #{Time.now-t} seconds."
+end
+```
+
+The around callback is executed in the thread.
+
 ### Rufus::Scheduler#on_pre_trigger as a guard
 
 Returning ```false``` in on_pre_trigger will prevent the job from triggering. Returning anything else (nil, -1, true, ...) will let the job trigger.
@@ -1145,23 +1227,23 @@ By default, rufus-scheduler sleeps 0.300 second between every step. At each step
 The :frequency option lets you change that 0.300 second to something else.
 
 ```ruby
-scheduler = Rufus::Scheduler.new(:frequency => 5)
+scheduler = Rufus::Scheduler.new(frequency: 5)
 ```
 
 It's OK to use a time string to specify the frequency.
 
 ```ruby
-scheduler = Rufus::Scheduler.new(:frequency => '2h10m')
+scheduler = Rufus::Scheduler.new(frequency: '2h10m')
   # this scheduler will sleep 2 hours and 10 minutes between every "step"
 ```
 
 Use with care.
 
-### :lockfile => "mylockfile.txt"
+### lockfile: "mylockfile.txt"
 
 This feature only works on OSes that support the flock (man 2 flock) call.
 
-Starting the scheduler with ```:lockfile => ".rufus-scheduler.lock"``` will make the scheduler attempt to create and lock the file ```.rufus-scheduler.lock``` in the current working directory. If that fails, the scheduler will not start.
+Starting the scheduler with ```lockfile: '.rufus-scheduler.lock'``` will make the scheduler attempt to create and lock the file ```.rufus-scheduler.lock``` in the current working directory. If that fails, the scheduler will not start.
 
 The idea is to guarantee only one scheduler (in a group of schedulers sharing the same lockfile) is running.
 
@@ -1190,7 +1272,7 @@ class HostLock
 end
 
 scheduler =
-  Rufus::Scheduler.new(:scheduler_lock => HostLock.new('coffee.example.com'))
+  Rufus::Scheduler.new(scheduler_lock: HostLock.new('coffee.example.com'))
 ```
 
 By default, the scheduler_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that returns true.
@@ -1213,7 +1295,7 @@ class PingLock
 end
 
 scheduler =
-  Rufus::Scheduler.new(:trigger_lock => PingLock.new('main.example.com'))
+  Rufus::Scheduler.new(trigger_lock: PingLock.new('main.example.com'))
 ```
 
 By default, the trigger_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that always returns true.
@@ -1227,7 +1309,7 @@ In rufus-scheduler 2.x, by default, each job triggering received its own, brand
 One can set this maximum value when starting the scheduler.
 
 ```ruby
-scheduler = Rufus::Scheduler.new(:max_work_threads => 77)
+scheduler = Rufus::Scheduler.new(max_work_threads: 77)
 ```
 
 It's OK to increase the :max_work_threads of a running scheduler.
@@ -1249,8 +1331,8 @@ Rufus::Scheduler.singleton.every '10s' { puts "hello, world!" }
 It's OK to pass initialization arguments (like :frequency or :max_work_threads) but they will only be taken into account the first time ```.singleton``` is called.
 
 ```ruby
-Rufus::Scheduler.singleton(:max_work_threads => 77)
-Rufus::Scheduler.singleton(:max_work_threads => 277) # no effect
+Rufus::Scheduler.singleton(max_work_threads: 77)
+Rufus::Scheduler.singleton(max_work_threads: 277) # no effect
 ```
 
 The ```.s``` is a shortcut for ```.singleton```.
@@ -1367,7 +1449,7 @@ Rufus::Scheduler.to_duration_hash(60)
 Rufus::Scheduler.to_duration_hash(62.127)
   # => { :m => 1, :s => 2, :ms => 127 }
 
-Rufus::Scheduler.to_duration_hash(62.127, :drop_seconds => true)
+Rufus::Scheduler.to_duration_hash(62.127, drop_seconds: true)
   # => { :m => 1 }
 ```
 
@@ -1550,7 +1632,7 @@ class ScheController < ApplicationController
         Rails.logger.info "time flies, it's now #{Time.now}"
       end
 
-    render :text => "scheduled job #{job_id}"
+    render text: "scheduled job #{job_id}"
   end
 end
 ```
@@ -1571,12 +1653,16 @@ If you don't want rufus-scheduler to trigger anything while running the Ruby on
 
 require 'rufus-scheduler'
 
-s = Rufus::Scheduler.singleton
+return if defined?(Rails::Console) || Rails.env.test? || File.split($PROGRAM_NAME).last == 'rake'
+  #
+  # do not schedule when Rails is run from its console, for a test/spec, or
+  # from a Rake task
 
-return if defined?(Rails::Console) || Rails.env.test? || File.split($0).last == 'rake'
+# return if $PROGRAM_NAME.include?('spring')
+  #
+  # see https://github.com/jmettraux/rufus-scheduler/issues/186
 
-# do not schedule when Rails is run from its console, for a test/spec, or
-# from a Rake task
+s = Rufus::Scheduler.singleton
 
 s.every '1m' do
   Rails.logger.info "hello, it's #{Time.now}"
@@ -1584,6 +1670,8 @@ s.every '1m' do
 end
 ```
 
+(Beware later version of Rails where Spring takes care pre-running the initializers. Running `spring stop` or disabling Spring might be necessary in some cases to see changes to initializers being taken into account.)
+
 
 ### rails server -d
 
@@ -1600,6 +1688,9 @@ These are two well crafted articles on process daemonization, please read them:
 
 If, anyway, you need something like `rails server -d`, why not try `bundle exec unicorn -D` instead? In my (limited) experience, it worked out of the box (well, had to add `gem 'unicorn'` to `Gemfile` first).
 
+### executor / reloader
+
+You might benefit from wraping your scheduled code in the executor or reloader. Read more here: https://guides.rubyonrails.org/threading_and_code_execution.html
 
 ## support