bluepill 0.0.70 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca369ae6619f45191580eb53378cf3e05c6c9611
-  data.tar.gz: 31f9694d4caa9f1479b6ea2da3d327b7367cfaef
+  metadata.gz: 9c7760cf13b7c5d2f991f644fe1f762eca7853d3
+  data.tar.gz: 28dc84d8bf94f0e2c5318f9397190fd35f6b626e
 SHA512:
-  metadata.gz: 82a4ac380dbebf046006a4942e5bad1d9c9ce3213afd9480f04b85f749bf9f180e079b06cf581a03b6c8cbabcdcc64c68a9426b6e07be7df49bc0b80e85a2094
-  data.tar.gz: c42f5bcdb3436b435c2a1fc98ae84db35dcfe8c052b5808665a27fd29ceff39172dcdf66ec4f9e14e5611ff041a0d6ad171c979bb62bd24753dee8c69050570b
+  metadata.gz: 76da9cf314f0a7bb9f4181d895e321f9851bc801955e8bde47b10ec9b1ad6f41f8f0d58e9ef3c5f2d1144258272d772579e1fb3204d883cd71ed6ad9dcc076ee
+  data.tar.gz: e25c6b9194bcc135e1a08339b58584c2962e9bc81129c019a91e5d162f52d8eeea73f63bb8195a77cef9191bdc423270725da0a6b1fee39ba7dd9045ef0b5daa

data/README.md

@@ -33,24 +33,24 @@ Bluepill organizes processes into 3 levels: application -> group -> process. Eac
 The minimum config file looks something like this:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+  end
+end
 ```
 
 Note that since we specified a PID file and start command, bluepill assumes the process will daemonize itself. If we wanted bluepill to daemonize it for us, we can do (note we still need to specify a PID file):
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.daemonize = true
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.daemonize = true
+  end
+end
 ```
 
 If you don't specify a stop command, a TERM signal will be sent by default. Similarly, the default restart action is to issue stop and then start.
@@ -58,14 +58,13 @@ If you don't specify a stop command, a TERM signal will be sent by default.
 Now if we want to do something more meaningful, like actually monitor the process, we do:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-
-        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.checks :cpu_usage, every: 10.seconds, below: 5, times: 3
+  end
+end
 ```
 
 We added a line that checks every 10 seconds to make sure the cpu usage of this process is below 5 percent; 3 failed checks results in a restart. We can specify a two-element array for the _times_ option to say that it 3 out of 5 failed attempts results in a restart.
@@ -73,163 +72,155 @@ We added a line that checks every 10 seconds to make sure the cpu usage of this
 To watch memory usage, we just add one more line:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-
-        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
-        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.checks :cpu_usage, every: 10.seconds, below: 5, times: 3
+    process.checks :mem_usage, every: 10.seconds, below: 100.megabytes, times: [3,5]
+  end
+end
  ```
 
 To watch the modification time of a file, e.g. a log file to ensure the process is actually working add one more line:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-
-        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
-        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
-        process.checks :file_time, :every => 60.seconds, :below => 3.minutes, :filename => "/tmp/some_file.log", :times => 2
-      end
-    end
- ```
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.checks :cpu_usage, every: 10.seconds, below: 5, times: 3
+    process.checks :mem_usage, every: 10.seconds, below: 100.megabytes, times: [3,5]
+    process.checks :file_time, every: 60.seconds, below: 3.minutes, filename: "/tmp/some_file.log", times: 2
+  end
+end
+```
 
 To restart process if it's running too long:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-
-        process.checks :running_time, :every => 10.minutes, :below => 24.hours
-      end
-    end
- ```
-
-
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.checks :running_time, every: 10.minutes, below: 24.hours
+  end
+end
+```
 
 We can tell bluepill to give a process some grace time to start/stop/restart before resuming monitoring:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.start_grace_time = 3.seconds
-        process.stop_grace_time = 5.seconds
-        process.restart_grace_time = 8.seconds
-
-        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
-        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.start_grace_time = 3.seconds
+    process.stop_grace_time = 5.seconds
+    process.restart_grace_time = 8.seconds
+    process.checks :cpu_usage, every: 10.seconds, below: 5, times: 3
+    process.checks :mem_usage, every: 10.seconds, below: 100.megabytes, times: [3,5]
+  end
+end
 ```
 
 We can group processes by name:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      5.times do |i|
-        app.process("process_name_#{i}") do |process|
-          process.group = "mongrels"
-          process.start_command = "/usr/bin/some_start_command"
-          process.pid_file = "/tmp/some_pid_file.pid"
-        end
-      end
+Bluepill.application("app_name") do |app|
+  5.times do |i|
+    app.process("process_name_#{i}") do |process|
+      process.group = "mongrels"
+      process.start_command = "/usr/bin/some_start_command"
+      process.pid_file = "/tmp/some_pid_file.pid"
     end
+  end
+end
 ```
 
 If you want to run the process as someone other than root:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.uid = "deploy"
-        process.gid = "deploy"
-
-        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
-        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.uid = "deploy"
+    process.gid = "deploy"
+    process.checks :cpu_usage, every: 10.seconds, below: 5, times: 3
+    process.checks :mem_usage, every: 10.seconds, below: 100.megabytes, times: [3,5]
+  end
+end
 ```
 
 If you want to include one or more supplementary groups:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.uid = "deploy"
-        process.gid = "deploy"
-        process.supplementary_groups = ['rvm']
-
-        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
-        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.uid = "deploy"
+    process.gid = "deploy"
+    process.supplementary_groups = ['rvm']
+    process.checks :cpu_usage, every: 10.seconds, below: 5, times: 3
+    process.checks :mem_usage, every: 10.seconds, below: 100.megabytes, times: [3,5]
+  end
+end
 ```
 
 You can also set an app-wide uid/gid:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.uid = "deploy"
-      app.gid = "deploy"
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.uid = "deploy"
+  app.gid = "deploy"
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+  end
+end
 ```
 
-To track resources of child processes, use :include_children:
+To track resources of child processes, use `:include_children`:
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.checks :mem_usage, :every => 1.seconds, :below => 5.megabytes, :times => [3,5], :include_children => true
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.checks :mem_usage, every: 1.seconds, below: 5.megabytes, times: [3,5], include_children: true
+  end
+end
 ```
 
 To check for flapping:
 
 ```ruby
-    process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+process.checks :flapping, times: 2, within: 30.seconds, retry_in: 7.seconds
 ```
 
-To set the working directory to _cd_ into when starting the command:
+To set the working directory to `cd` into when starting the command:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.working_dir = "/path/to/some_directory"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.working_dir = "/path/to/some_directory"
+  end
+end
 ```
 
 You can also have an app-wide working directory:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.working_dir = "/path/to/some_directory"
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.working_dir = "/path/to/some_directory"
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+  end
+end
 ```
 
 Note: We also set the PWD in the environment to the working dir you specify. This is useful for when the working dir is a symlink. Unicorn in particular will cd into the environment variable in PWD when it re-execs to deal with a change in the symlink.
@@ -238,25 +229,25 @@ By default, bluepill will send a SIGTERM to your process when stopping.
 To change the stop command:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.stop_command = "/user/bin/some_stop_command"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.stop_command = "/user/bin/some_stop_command"
+  end
+end
 ```
 
 If you'd like to send a signal or signals to your process to stop it:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/some_start_command"
-        process.pid_file = "/tmp/some_pid_file.pid"
-        process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/some_start_command"
+    process.pid_file = "/tmp/some_pid_file.pid"
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+  end
+end
 ```
 
 We added a line that will send a SIGQUIT, wait 30 seconds and check to
@@ -266,42 +257,39 @@ to see if the process is still up, and finally send a SIGKILL.
 And lastly, to monitor child processes:
 
 ```ruby
-    process.monitor_children do |child_process|
-      child_process.checks :cpu_usage, :every => 10, :below => 5, :times => 3
-      child_process.checks :mem_usage, :every => 10, :below => 100.megabytes, :times => [3, 5]
-
-      child_process.stop_command = "kill -QUIT {{PID}}"
-    end
+process.monitor_children do |child_process|
+  child_process.checks :cpu_usage, every: 10, below: 5, times: 3
+  child_process.checks :mem_usage, every: 10, below: 100.megabytes, times: [3, 5]
+  child_process.stop_command = "kill -QUIT {{PID}}"
+end
 ```
 
 Note {{PID}} will be substituted for the pid of process in both the stop and restart commands.
 
 ### A Note About Output Redirection
 
-While you can specify shell tricks like the following in the start_command of a process:
+While you can specify shell tricks like the following in the `start_command` of a process:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "cd /tmp/some_dir && SOME_VAR=1 /usr/bin/some_start_command > /tmp/server.log 2>&1"
-        process.pid_file = "/tmp/some_pid_file.pid"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "cd /tmp/some_dir && SOME_VAR=1 /usr/bin/some_start_command > /tmp/server.log 2>&1"
+    process.pid_file = "/tmp/some_pid_file.pid"
+  end
+end
 ```
 
 We recommend that you _not_ do that and instead use the config options to capture output from your daemons. Like so:
 
 ```ruby
-    Bluepill.application("app_name") do |app|
-      app.process("process_name") do |process|
-        process.start_command = "/usr/bin/env SOME_VAR=1 /usr/bin/some_start_command"
-
-        process.working_dir = "/tmp/some_dir"
-        process.stdout = process.stderr = "/tmp/server.log"
-
-        process.pid_file = "/tmp/some_pid_file.pid"
-      end
-    end
+Bluepill.application("app_name") do |app|
+  app.process("process_name") do |process|
+    process.start_command = "/usr/bin/env SOME_VAR=1 /usr/bin/some_start_command"
+    process.working_dir = "/tmp/some_dir"
+    process.stdout = process.stderr = "/tmp/server.log"
+    process.pid_file = "/tmp/some_pid_file.pid"
+  end
+end
 ```
 
 The main benefit of using the config options is that Bluepill will be able to monitor the correct process instead of just watching the shell that spawned your actual server.
@@ -347,9 +335,9 @@ To quit the bluepill daemon for an application:
 By default, bluepill uses syslog local6 facility as described in the installation section. But if for any reason you don't want to use syslog, you can use a log file. You can do this by setting the :log\_file option in the config:
 
 ```ruby
-    Bluepill.application("app_name", :log_file => "/path/to/bluepill.log") do |app|
-      # ...
-    end
+Bluepill.application("app_name", log_file: "/path/to/bluepill.log") do |app|
+  # ...
+end
 ```
 
 Keep in mind that you still need to set up log rotation (described in the installation section) to keep the log file from growing huge.
@@ -358,9 +346,9 @@ Keep in mind that you still need to set up log rotation (described in the instal
 You can run bluepill in the foreground:
 
 ```ruby
-    Bluepill.application("app_name", :foreground => true) do |app|
-      # ...
-    end
+Bluepill.application("app_name", foreground: true) do |app|
+  # ...
+end
 ```
 
 Note that You must define only one application per config when using foreground mode.
@@ -377,7 +365,6 @@ Note that You must define only one application per config when using foreground
 This library aims to support and is [tested against][travis] the following Ruby
 implementations:
 
-* Ruby 1.8.7
 * Ruby 1.9.3
 * Ruby 2.0.0
 * Ruby 2.1

data/bin/bluepill

@@ -11,11 +11,11 @@ RbConfig = Config unless Object.const_defined?(:RbConfig)
 
 # Default options
 options = {
-  :log_file => '/var/log/bluepill.log',
-  :base_dir => ENV['BLUEPILL_BASE_DIR'] || (::Process.euid != 0 ? File.join(ENV['HOME'], '.bluepill') : '/var/run/bluepill'),
-  :privileged => true,
-  :timeout => 10,
-  :attempts => 1,
+  log_file: '/var/log/bluepill.log',
+  base_dir: ENV['BLUEPILL_BASE_DIR'] || (::Process.euid != 0 ? File.join(ENV['HOME'], '.bluepill') : '/var/run/bluepill'),
+  privileged: true,
+  timeout: 10,
+  attempts: 1,
 }
 
 OptionParser.new do |opts|

data/bluepill.gemspec

@@ -2,23 +2,25 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'bluepill/version'
 
-Gem::Specification.new do |s|
-  s.name        = 'bluepill'
-  s.version     = Bluepill::Version
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Arya Asemanfar', 'Gary Tsang', 'Rohith Ravi']
-  s.email       = ['entombedvirus@gmail.com']
-  s.homepage    = 'http://github.com/bluepill-rb/bluepill'
-  s.summary     = 'A process monitor written in Ruby with stability and minimalism in mind.'
-  s.description = "Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave."
-  s.license     = 'MIT'
+Gem::Specification.new do |spec|
+  spec.name        = 'bluepill'
+  spec.version     = Bluepill::Version
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ['Arya Asemanfar', 'Gary Tsang', 'Rohith Ravi']
+  spec.email       = ['entombedvirus@gmail.com']
+  spec.homepage    = 'http://github.com/bluepill-rb/bluepill'
+  spec.summary     = 'A process monitor written in Ruby with stability and minimalism in mind.'
+  spec.description = "Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave."
+  spec.license     = 'MIT'
 
-  s.add_dependency 'activesupport', ['>= 3.2', '< 5']
-  s.add_dependency 'blue-daemons', '~> 1.1'
-  s.add_dependency 'state_machine', '~> 1.1'
-  s.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_dependency 'activesupport', ['>= 3.2', '< 5']
+  spec.add_dependency 'blue-daemons', '~> 1.1'
+  spec.add_dependency 'state_machine', '~> 1.1'
+  spec.add_development_dependency 'bundler', '~> 1.3'
 
-  s.files            = %w(CONTRIBUTING.md DESIGN.md LICENSE README.md bluepill.gemspec) + Dir['bin/*'] + Dir['lib/**/*.rb']
-  s.executables      = Dir['bin/*'].collect { |f| File.basename(f) }
-  s.require_paths    = ['lib']
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.files            = %w(CONTRIBUTING.md DESIGN.md LICENSE README.md bluepill.gemspec) + Dir['bin/*'] + Dir['lib/**/*.rb']
+  spec.executables      = Dir['bin/*'].collect { |f| File.basename(f) }
+  spec.require_paths    = ['lib']
 end

data/lib/bluepill/application.rb

@@ -24,7 +24,7 @@ module Bluepill
 
       self.groups = {}
 
-      self.logger = ProcessJournal.logger = Bluepill::Logger.new(:log_file => log_file, :stdout => foreground?).prefix_with(self.name)
+      self.logger = ProcessJournal.logger = Bluepill::Logger.new(log_file: log_file, stdout: foreground?).prefix_with(self.name)
 
       setup_signal_traps
       setup_pids_dir
@@ -60,7 +60,7 @@ module Bluepill
     def add_process(process, group_name = nil)
       group_name = group_name.to_s if group_name
 
-      groups[group_name] ||= Group.new(group_name, :logger => logger.prefix_with(group_name))
+      groups[group_name] ||= Group.new(group_name, logger: logger.prefix_with(group_name))
       groups[group_name].add_process(process)
     end
 

data/lib/bluepill/condition_watch.rb

@@ -12,7 +12,7 @@ module Bluepill
       @fires  = options.key?(:fires) ? Array(options.delete(:fires)) : [:restart]
       @every  = options.delete(:every)
       @times  = options.delete(:times) || [1, 1]
-      @times  = [@times, @times] unless @times.is_a?(Array) # handles :times => 5
+      @times  = [@times, @times] unless @times.is_a?(Array) # handles times: 5
       @include_children = options.delete(:include_children) || false
 
       self.clear_history!

data/lib/bluepill/logger.rb

@@ -28,7 +28,7 @@ module Bluepill
     end
 
     def prefix_with(prefix)
-      @prefixes[prefix] ||= self.class.new(:logger => self, :prefix => prefix)
+      @prefixes[prefix] ||= self.class.new(logger: self, prefix: prefix)
     end
 
     def reopen
@@ -52,7 +52,7 @@ module Bluepill
 
     class LoggerAdapter < ::Logger
       LOGGER_EQUIVALENTS =
-        {:debug => :debug, :err => :error, :warning => :warn, :info => :info, :emerg => :fatal, :alert => :warn, :crit => :fatal, :notice => :info}
+        {debug: :debug, err: :error, warning: :warn, info: :info, emerg: :fatal, alert: :warn, crit: :fatal, notice: :info}
 
       LOG_METHODS.each do |method|
         next if method == LOGGER_EQUIVALENTS[method]

data/lib/bluepill/process.rb

@@ -55,7 +55,7 @@ module Bluepill
     attr_accessor(*CONFIGURABLE_ATTRIBUTES)
     attr_reader :children, :statistics
 
-    state_machine :initial => :unmonitored do
+    state_machine initial: :unmonitored do
       # These are the idle states, i.e. only an event (either external or internal) will trigger a transition.
       # The distinction between down and unmonitored is that down
       # means we know it is not running and unmonitored is that we don't care if it's running.
@@ -65,22 +65,22 @@ module Bluepill
       state :starting, :stopping, :restarting
 
       event :tick do
-        transition :starting => :up, :if => :process_running?
-        transition :starting => :down, :unless => :process_running?
+        transition starting: :up, if: :process_running?
+        transition starting: :down, unless: :process_running?
 
-        transition :up => :up, :if => :process_running?
-        transition :up => :down, :unless => :process_running?
+        transition up: :up, if: :process_running?
+        transition up: :down, unless: :process_running?
 
         # The process failed to die after entering the stopping state. Change the state to reflect
         # reality.
-        transition :stopping => :up, :if => :process_running?
-        transition :stopping => :down, :unless => :process_running?
+        transition stopping: :up, if: :process_running?
+        transition stopping: :down, unless: :process_running?
 
-        transition :down => :up, :if => :process_running?
-        transition :down => :starting, :unless => :process_running?
+        transition down: :up, if: :process_running?
+        transition down: :starting, unless: :process_running?
 
-        transition :restarting => :up, :if => :process_running?
-        transition :restarting => :down, :unless => :process_running?
+        transition restarting: :up, if: :process_running?
+        transition restarting: :down, unless: :process_running?
       end
 
       event :start do
@@ -88,7 +88,7 @@ module Bluepill
       end
 
       event :stop do
-        transition :up => :stopping
+        transition up: :stopping
       end
 
       event :unmonitor do
@@ -99,14 +99,14 @@ module Bluepill
         transition [:up, :down] => :restarting
       end
 
-      before_transition any => any, :do => :notify_triggers
-      before_transition :stopping => any, :do => :clean_threads
+      before_transition any => any, do: :notify_triggers
+      before_transition stopping: any, do: :clean_threads
 
-      after_transition any => :starting, :do => :start_process
-      after_transition any => :stopping, :do => :stop_process
-      after_transition any => :restarting, :do => :restart_process
+      after_transition any => :starting, do: :start_process
+      after_transition any => :stopping, do: :stop_process
+      after_transition any => :restarting, do: :restart_process
 
-      after_transition any => any, :do => :record_transition
+      after_transition any => any, do: :record_transition
     end
 
     def initialize(process_name, checks, options = {})
@@ -207,11 +207,11 @@ module Bluepill
 
     # Watch related methods
     def add_watch(name, options = {})
-      watches << ConditionWatch.new(name, options.merge(:logger => logger))
+      watches << ConditionWatch.new(name, options.merge(logger: logger))
     end
 
     def add_trigger(name, options = {})
-      triggers << Trigger[name].new(self, options.merge(:logger => logger))
+      triggers << Trigger[name].new(self, options.merge(logger: logger))
     end
 
     def run_watches
@@ -223,15 +223,13 @@ module Bluepill
 
       @transitioned = false
 
-      threads.inject([]) do |events, (watch, thread)|
+      threads.each_with_object([]) do |(watch, thread), events|
         thread.join
-        if thread[:events].size > 0
-          logger.info "#{watch.name} dispatched: #{thread[:events].join(',')}"
-          thread[:events].each do |event|
-            events << [event, watch.to_s]
-          end
+        next if thread[:events].size.zero?
+        logger.info "#{watch.name} dispatched: #{thread[:events].join(',')}"
+        thread[:events].each do |event|
+          events << [event, watch.to_s]
         end
-        events
       end.each do |event, reason| # rubocop:disable Style/MultilineBlockChain
         break if @transitioned
         self.dispatch!(event, reason)
@@ -493,16 +491,16 @@ module Bluepill
 
     def system_command_options
       {
-        :uid => uid,
-        :gid => gid,
-        :working_dir => working_dir,
-        :environment => environment,
-        :pid_file => pid_file,
-        :logger => logger,
-        :stdin => stdin,
-        :stdout => stdout,
-        :stderr => stderr,
-        :supplementary_groups => supplementary_groups,
+        uid: uid,
+        gid: gid,
+        working_dir: working_dir,
+        environment: environment,
+        pid_file: pid_file,
+        logger: logger,
+        stdin: stdin,
+        stdout: stdout,
+        stderr: stderr,
+        supplementary_groups: supplementary_groups,
       }
     end
 

data/lib/bluepill/process_conditions/zombie_process.rb

@@ -2,7 +2,7 @@ module Bluepill
   module ProcessConditions
     # Process must have cache_actual_pid set to false to function correctly:
     #
-    # process.checks :zombie_process, :every => 5.seconds
+    # process.checks :zombie_process, every: 5.seconds
     # process.cache_actual_pid = false
 
     class ZombieProcess < ProcessCondition

data/lib/bluepill/system.rb

@@ -11,12 +11,12 @@ module Bluepill
 
     # The position of each field in ps output
     IDX_MAP = {
-      :pid => 0,
-      :ppid => 1,
-      :pcpu => 2,
-      :rss => 3,
-      :etime => 4,
-      :command => 5,
+      pid: 0,
+      ppid: 1,
+      pcpu: 2,
+      rss: 3,
+      etime: 4,
+      command: 5,
     }
 
     def pid_alive?(pid)
@@ -142,7 +142,7 @@ module Bluepill
 
         ::Process.waitpid(child)
 
-        cmd_status.strip != '' ? Marshal.load(cmd_status) : {:exit_code => 0, :stdout => '', :stderr => ''}
+        cmd_status.strip != '' ? Marshal.load(cmd_status) : {exit_code: 0, stdout: '', stderr: ''}
       else
         # child
         rd.close
@@ -195,9 +195,9 @@ module Bluepill
 
         # collect stdout, stderr and exitcode
         result = {
-          :stdout => cmd_out_read.read,
-          :stderr => cmd_err_read.read,
-          :exit_code => $CHILD_STATUS.exitstatus,
+          stdout: cmd_out_read.read,
+          stderr: cmd_err_read.read,
+          exit_code: $CHILD_STATUS.exitstatus,
         }
 
         # We're done with these ends of the pipes as well
@@ -226,14 +226,13 @@ module Bluepill
         # BSD style ps invocation
         lines = `ps axo pid,ppid,pcpu,rss,etime,command`.split("\n")
 
-        lines.inject({}) do |mem, line|
+        lines.each_with_object({}) do |line, mem|
           chunks = line.split(/\s+/)
           chunks.delete_if { |c| c.strip.empty? }
           pid = chunks[IDX_MAP[:pid]].strip.to_i
           command = chunks.slice!(IDX_MAP[:command], chunks.length).join ' '
           chunks[IDX_MAP[:command]] = command
           mem[pid] = chunks.flatten
-          mem
         end
       end
     end

data/lib/bluepill/triggers/flapping.rb

@@ -9,7 +9,7 @@ module Bluepill
       attr_reader :timeline
 
       def initialize(process, options = {})
-        options.reverse_merge!(:times => 5, :within => 1, :retry_in => 5)
+        options.reverse_merge!(times: 5, within: 1, retry_in: 5)
 
         options.each_pair do |name, val|
           instance_variable_set("@#{name}", val) if PARAMS.include?(name)

data/lib/bluepill/version.rb

@@ -9,12 +9,12 @@ module Bluepill
 
     # @return [Integer]
     def minor
-      0
+      1
     end
 
     # @return [Integer]
     def patch
-      70
+      1
     end
 
     # @return [Integer, NilClass]
@@ -25,10 +25,10 @@ module Bluepill
     # @return [Hash]
     def to_h
       {
-        :major => major,
-        :minor => minor,
-        :patch => patch,
-        :pre => pre,
+        major: major,
+        minor: minor,
+        patch: patch,
+        pre: pre,
       }
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bluepill
 version: !ruby/object:Gem::Version
-  version: 0.0.70
+  version: 0.1.1
 platform: ruby
 authors:
 - Arya Asemanfar
@@ -137,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="