bluepill 0.0.50 → 0.0.51

data/README.md

@@ -9,7 +9,7 @@ It's hosted on [rubygems.org][rubygems].
 In order to take advantage of logging with syslog, you also need to setup your syslog to log the local6 facility. Edit the appropriate config file for your syslogger (/etc/syslog.conf for syslog) and add a line for local6:
 
     local6.*          /var/log/bluepill.log
-    
+
 You'll also want to add _/var/log/bluepill.log_ to _/etc/logrotate.d/syslog_ so that it gets rotated.
 
 Lastly, create the _/var/bluepill_ directory for bluepill to store its pid and sock files.
@@ -20,15 +20,18 @@ 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
-    
+```
+
 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"
@@ -36,11 +39,13 @@ Note that since we specified a PID file and start command, bluepill assumes the
         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.
 
 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"
@@ -49,11 +54,13 @@ Now if we want to do something more meaningful, like actually monitor the proces
         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.
 
 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"
@@ -63,9 +70,11 @@ To watch memory usage, we just add one more line:
         process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
       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"
@@ -78,9 +87,11 @@ We can tell bluepill to give a process some grace time to start/stop/restart bef
         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|
@@ -90,9 +101,11 @@ We can group processes by name:
         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"
@@ -104,9 +117,11 @@ If you want to run the process as someone other than root:
         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"
@@ -115,13 +130,17 @@ You can also set an app-wide uid/gid:
         process.pid_file = "/tmp/some_pid_file.pid"
       end
     end
-    
+```
+
 To check for flapping:
 
+```ruby
     process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
-    
+```
+
 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"
@@ -129,10 +148,11 @@ To set the working directory to _cd_ into when starting the command:
         process.working_dir = "/path/to/some_directory"
       end
     end
-    
-You can also have an app-wide working directory:
+```
 
+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|
@@ -140,34 +160,39 @@ You can also have an app-wide working directory:
         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.
+```
 
+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.
 
 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
-    
+```
+
 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:
-    
+
+```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
-    
+```
+
 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"
@@ -178,18 +203,19 @@ We recommend that you _not_ do that and instead use the config options to captur
         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.
 
 ### CLI
 To start a bluepill process and load a config:
 
     sudo bluepill load /path/to/production.pill
-    
+
 To act on a process or group:
 
     sudo bluepill <start|stop|restart|unmonitor> <process_or_group_name>
-    
+
 To view process statuses:
 
     sudo bluepill status
@@ -205,18 +231,22 @@ To quit bluepill:
 ### Logging  
 By default, bluepill uses syslog local6 facility as described in the installation section. But if for any reason you don&apos;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
+```
 
 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.
     
 ### Extra options
 You can run bluepill in the foreground:
 
+```ruby
     Bluepill.application("app_name", :foreground => true) do |app|
       # ...
     end
+```
 
 Note that You must define only one application per config when using foreground mode.
 

data/lib/bluepill/process_statistics.rb

@@ -13,8 +13,8 @@ module Bluepill
     end
 
     def to_s
-      str = @events.reverse.collect do |(event, reason, time)|
-        str << "  #{event} at #{time.strftime(STRFTIME)} - #{reason || "unspecified"}"
+      str = @events.reverse.map do |(event, reason, time)|
+        "  #{event} at #{time.strftime(STRFTIME)} - #{reason || "unspecified"}"
       end.join("\n")
 
       "event history:\n#{str}"

data/lib/bluepill/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding: utf-8 -*-
 module Bluepill
-  VERSION = "0.0.50".freeze
+  VERSION = "0.0.51".freeze
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bluepill
 version: !ruby/object:Gem::Version 
-  hash: 123
+  hash: 121
   prerelease: 
   segments: 
   - 0
   - 0
-  - 50
-  version: 0.0.50
+  - 51
+  version: 0.0.51
 platform: ruby
 authors: 
 - Arya Asemanfar