god 0.13.4 → 0.13.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4e92e64f9fc2eaea16ace1b200c266186acbfe80
+  data.tar.gz: 3f1a94de8fa67f06e41b96e1176faf71e02ee7ab
+SHA512:
+  metadata.gz: 97bc476662014ecdd34126fc2a1e1fa0352e477c5e7770eca6440b63770fed590d97f1e0e0326b00f8715b9b6db4ab7771b35cfe00583b6ea0f8aa86b9d8bc5c
+  data.tar.gz: 8f36cbb7934ee98a1b2c78af71740ed2a502ccd08479b0a01f15d233224873d7ff15cdf7874282713e99a4aa2b02e02bf70b4a630f4d5a3e0518179dfdf2c54f

data/History.txt

@@ -1,3 +1,16 @@
+== 0.13.5 / 2015-01-09
+  * Minor Enhancements
+    * statsd notifier (#144)
+    * Slack notifier (#172)
+  * Bug fixes
+    * Add support for Ruby 2.2.0 (#206)
+    * Fix tests for Ruby 2.0 (#205)
+    * Make group assignment more like login (#159)
+    * Flush file descriptors to prevent too many processes from being started (#141)
+    * Allow SSL URLs (#168)
+  * Documentation fixes
+    * Clarify Hipchat privilege requirements (#176)
+
 == 0.13.4 / 2014-03-05
   * Minor Enhancements
     * Hipchat reporter (#162)

data/doc/god.asciidoc

@@ -436,8 +436,8 @@ A `watch` represents a single process that has concrete start, stop, and/or
 restart operations. You can define as many watches as you like. In the example
 above, I've got some Rails instances running in Mongrels that I need to keep
 alive. Every watch must have a unique `name` so that it can be identified
-later on. The `start` and `stop` attributes specify the commands to start 
-and stop the process. If no `restart` attribute is set, restart will be 
+later on. The `start` and `stop` attributes specify the commands to start
+and stop the process. If no `restart` attribute is set, restart will be
 represented by a call to stop followed by a call to start. The
 optional `grace` attribute sets the amount of time following a
 start/stop/restart command to wait before resuming normal monitoring
@@ -575,7 +575,7 @@ Watching Non-Daemon Processes
 Need to watch a script that doesn't have built in daemonization? No problem!
 God will daemonize and keep track of your process for you. If you don't
 specify a `pid_file` attribute for a watch, it will be auto-daemonized and a
-PID file will be stored for it in `/var/run/god`. 
+PID file will be stored for it in `/var/run/god`.
 
 
 ```ruby
@@ -585,9 +585,9 @@ God.pid_file_directory = '/home/tom/pids'
 God.watch do |w|
   w.name = 'mongrel'
   w.pid_file = w.pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
-  
+
   w.start = "mongrel_rails start -P #{RAILS_ROOT}/log/mongrel.pid  -d"
-  
+
   # ...
 end
 
@@ -595,15 +595,15 @@ end
 God.watch do |w|
   w.name = 'worker'
   # w.pid_file = is not set
-  
+
   w.start = "rake resque:worker"
-  
+
   # ...
 end
 ```
 
 
-If you'd rather have the PID file stored in a different location, you can 
+If you'd rather have the PID file stored in a different location, you can
 set it at the top of your config:
 
 ```ruby
@@ -1022,6 +1022,8 @@ ssl       - A Boolean determining whether or not to use SSL
 from      - The String representing who the message should be sent as.
 ```
 
+NOTE: in Hipchat you must have a token with 'admin' privileges.  'Notification' privileges will not be enough.
+
 Email
 ~~~~~
 
@@ -1243,6 +1245,46 @@ end
 apikey - The String API key.
 ```
 
+Slack
+~~~~~
+
+Send a message to a channel in Slack (https://slack.com/).
+
+First, set up an Incoming Webhook in your Slack account.
+
+Then, in your God configuration, set the defaults:
+
+```ruby
+God::Contacts::Slack.defaults do |d|
+  d.account = "foo"
+  d.token = "abc123abc123abc123"
+  c.notify_channel = true
+  c.format = '%{host} alert: %{message}'
+end
+```
+
+`account` is the name of your Slack account; if you view slack at
+"foo.slack.com", then your account is "foo". `token` is from your
+newly-created webhook, and will be a string of unintelligible
+characters.
+
+The `notify_channel` and `format` settings are optional. The first
+controls whether the message includes `@channel` (sending notifications
+to everyone in the channel); the second controls how the message is
+formatted. Acceptable values within the format are `priority`, `host`,
+`message`, `category`, and `time`.
+
+Once you've set the defaults, create contacts for the channels that you
+want to notify. You can create as many as you like, and they'll look
+something like this:
+
+```ruby
+God.contact(:slack) do |c|
+  c.name = '#ops'
+  c.channel = '#ops'
+end
+```
+
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 

data/ext/god/extconf.rb

@@ -9,6 +9,7 @@ def create_dummy_makefile
   end
 end
 
+have_func('rb_wait_for_single_fd')
 case RUBY_PLATFORM
 when /bsd/i, /darwin/i
   unless have_header('sys/event.h')

data/ext/god/kqueue_handler.c

@@ -5,6 +5,10 @@
 #include <sys/time.h>
 #include <errno.h>
 
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  #include <ruby/io.h>
+#endif
+
 static VALUE mGod;
 static VALUE cKQueueHandler;
 static VALUE cEventHandler;
@@ -63,6 +67,10 @@ kqh_handle_events()
 {
   int nevents, i, num_to_fetch;
   struct kevent *events;
+
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  rb_wait_for_single_fd(kq, RB_WAITFD_IN, NULL);
+#else
   fd_set read_set;
 
   FD_ZERO(&read_set);
@@ -70,7 +78,7 @@ kqh_handle_events()
 
   // Don't actually run this method until we've got an event
   rb_thread_select(kq + 1, &read_set, NULL, NULL, NULL);
-
+#endif
   // Grabbing num_events once for thread safety
   num_to_fetch = num_events;
   events = (struct kevent*)malloc(num_to_fetch * sizeof(struct kevent));

data/ext/god/netlink_handler.c

@@ -1,6 +1,12 @@
 #ifdef __linux__ /* only build on linux */
 
 #include <ruby.h>
+
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  #include <ruby/io.h>
+#endif
+
+
 #include <sys/types.h>
 #include <unistd.h>
 #include <sys/socket.h>
@@ -31,6 +37,16 @@ nlh_handle_events()
 
   VALUE extra_data;
 
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  int ret;
+  if((ret = rb_wait_for_single_fd(nl_sock, RB_WAITFD_IN, NULL)) < 0){
+    rb_raise(rb_eStandardError, "%s", strerror(errno));
+  }
+  /* If there were no events detected, return */
+  if(!(ret & RB_WAITFD_IN)){
+    return INT2FIX(0);
+  }
+#else
   fd_set fds;
 
   FD_ZERO(&fds);
@@ -44,6 +60,7 @@ nlh_handle_events()
   if (! FD_ISSET(nl_sock, &fds)) {
     return INT2FIX(0);
   }
+#endif
 
   /* if there are events, make calls */
   if (-1 == recv(nl_sock, buff, sizeof(buff), 0)) {

data/god.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'god'
-  s.version = '0.13.4'
-  s.date = '2014-03-05'
+  s.version = '0.13.5'
+  s.date = '2015-01-09'
 
   s.summary = "Process monitoring framework."
   s.description = "An easy to configure, easy to extend monitoring framework written in Ruby."
@@ -25,18 +25,23 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency('json', '~> 1.6')
   s.add_development_dependency('rake')
+  s.add_development_dependency('minitest')
   s.add_development_dependency('rdoc', '~> 3.10')
   s.add_development_dependency('twitter', '~> 4.0')
   s.add_development_dependency('prowly', '~> 0.3')
   s.add_development_dependency('xmpp4r', '~> 0.5')
   s.add_development_dependency('dike', '~> 0.0.3')
-  s.add_development_dependency('rcov', '~> 0.9')
+ # s.add_development_dependency('rcov', '~> 0.9')
   s.add_development_dependency('daemons', '~> 1.1')
   s.add_development_dependency('mocha', '~> 0.10')
   s.add_development_dependency('gollum', '~> 1.3.1')
+  #the last version to support 1.8.7 is 0.99.6
+  s.add_development_dependency('mustache', ['~> 0.99.0', '< 0.99.7'])
   s.add_development_dependency('airbrake', '~> 3.1.7')
   s.add_development_dependency('nokogiri', '~> 1.5.0')
   s.add_development_dependency('activesupport', [ '>= 2.3.10', '< 4.0.0' ])
+  s.add_development_dependency('statsd-ruby')
+  s.add_development_dependency('i18n', '< 0.7.0')
   # = MANIFEST =
   s.files = %w[
     Announce.txt
@@ -87,6 +92,8 @@ Gem::Specification.new do |s|
     lib/god/contacts/jabber.rb
     lib/god/contacts/prowl.rb
     lib/god/contacts/scout.rb
+    lib/god/contacts/slack.rb
+    lib/god/contacts/statsd.rb
     lib/god/contacts/twitter.rb
     lib/god/contacts/webhook.rb
     lib/god/driver.rb
@@ -162,7 +169,9 @@ Gem::Specification.new do |s|
     test/test_process.rb
     test/test_prowl.rb
     test/test_registry.rb
+    test/test_slack.rb
     test/test_socket.rb
+    test/test_statsd.rb
     test/test_sugar.rb
     test/test_system_portable_poller.rb
     test/test_system_process.rb

data/lib/god.rb

@@ -90,9 +90,11 @@ load_contact(:email)
 load_contact(:jabber)
 load_contact(:prowl)
 load_contact(:scout)
+load_contact(:statsd)
 load_contact(:twitter)
 load_contact(:webhook)
 load_contact(:airbrake)
+load_contact(:slack)
 
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
 
@@ -158,7 +160,7 @@ end
 
 module God
   # The String version number for this package.
-  VERSION = '0.13.4'
+  VERSION = '0.13.5'
 
   # The Integer number of lines of backlog to keep for the logger.
   LOG_BUFFER_SIZE_DEFAULT = 100

data/lib/god/contacts/slack.rb

@@ -0,0 +1,100 @@
+# Send a message to a Slack channel
+#
+# account        - The name of your Slack account (visible in URL, e.g. foo.slack.com)
+# token          - The token of the webhook created in Slack
+# channel        - The name of the channel to send the message to, prefixed with #
+# notify_channel - Whether to send an "@channel" in the message, to alert everyone in the channel
+# format         - An optional format string to change how the alert is displayed
+
+require 'net/http'
+require 'uri'
+
+CONTACT_DEPS[:slack] = ['json']
+CONTACT_DEPS[:slack].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+
+    class Slack < Contact
+      class << self
+        attr_accessor :account, :token, :channel, :notify_channel, :format, :username, :emoji
+      end
+
+      self.channel        = "#general"
+      self.notify_channel = false
+      self.format         = "%{priority} alert on %{host}: %{message} (%{category}, %{time})"
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'account' must be specified", self) unless arg(:account)
+        valid &= complain("Attribute 'token' must be specified", self) unless arg(:token)
+        valid
+      end
+
+      attr_accessor :account, :token, :channel, :notify_channel, :format, :username, :emoji
+
+      def text(data)
+        text = ""
+        text << "<!channel> " if arg(:notify_channel)
+
+        if RUBY_VERSION =~ /^1\.8/
+          text << arg(:format).gsub(/%\{(\w+)\}/) do |match|
+            data[$1.to_sym]
+          end
+        else
+          text << arg(:format) % data
+        end
+
+        text
+      end
+
+      def notify(message, time, priority, category, host)
+        text = text({
+          :message => message,
+          :time => time,
+          :priority => priority,
+          :category => category,
+          :host => host
+        })
+
+        request(text)
+      end
+
+      def api_url
+        URI.parse("https://#{arg(:account)}.slack.com/services/hooks/incoming-webhook?token=#{arg(:token)}")
+      end
+
+      def request(text)
+        http = Net::HTTP.new(api_url.host, api_url.port)
+        http.use_ssl = true
+
+        req = Net::HTTP::Post.new(api_url.request_uri)
+        req.body = {
+          :link_names => 1,
+          :text => text,
+          :channel => arg(:channel)
+        }.tap { |payload|
+          payload[:username] = arg(:username) if arg(:username)
+          payload[:icon_emoji] = arg(:emoji) if arg(:emoji)
+        }.to_json
+
+        res = http.request(req)
+
+        case res
+          when Net::HTTPSuccess
+            self.info = "successfully notified slack on channel #{arg(:channel)}"
+          else
+            self.info = "failed to send webhook to #{arg(:url)}: #{res.error!}"
+        end
+      rescue Object => e
+        applog(nil, :info, "failed to send webhook to #{arg(:url)}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+
+    end
+
+  end
+end
+

data/lib/god/contacts/statsd.rb

@@ -0,0 +1,46 @@
+# Send a notice to statsd
+#
+# host - statsd host
+# port - statsd port (optional)
+
+require 'statsd-ruby'
+
+module God
+  module Contacts
+
+    class Statsd < Contact
+      class << self
+        attr_accessor :host, :port
+      end
+
+      attr_accessor :host, :port
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'statsd_host' must be specified", self) unless arg(:host)
+        valid
+      end
+
+      def notify(message, time, priority, category, hostname)
+        statsd = ::Statsd.new host, (port ? port.to_i : 8125) # 8125 is the default statsd port
+
+        hostname.gsub! /\./, '_'
+        app = message.gsub /([^\s]*).*/, '\1'
+
+        [
+            'cpu out of bounds',
+            'memory out of bounds',
+            'process is flapping'
+        ].each do |event_type|
+          statsd.increment "god.#{event_type.gsub(/\s/, '_')}.#{hostname}.#{app}" if message.include? event_type
+        end
+
+        self.info = 'sent statsd alert'
+      rescue => e
+        applog(nil, :info, "failed to send statsd alert: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+    end
+
+  end
+end

data/lib/god/contacts/webhook.rb

@@ -41,6 +41,7 @@ module God
 
         uri = URI.parse(arg(:url))
         http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == "https"
 
         req = nil
         res = nil

data/lib/god/process.rb

@@ -32,16 +32,18 @@ module God
         begin
           uid_num = Etc.getpwnam(self.uid).uid if self.uid
           gid_num = Etc.getgrnam(self.gid).gid if self.gid
+          gid_num = Etc.getpwnam(self.uid).gid if self.gid.nil? && self.uid
 
           ::Dir.chroot(self.chroot) if self.chroot
-          ::Process.groups = [gid_num] if self.gid
-          ::Process::Sys.setgid(gid_num) if self.gid
+          ::Process.groups = [gid_num] if gid_num
+          ::Process.initgroups(self.uid, gid_num) if self.uid && gid_num
+          ::Process::Sys.setgid(gid_num) if gid_num
           ::Process::Sys.setuid(uid_num) if self.uid
         rescue ArgumentError, Errno::EPERM, Errno::ENOENT
           exit(1)
         end
 
-        File.writable?(file_in_chroot(file)) ? exit(0) : exit(1)
+        File.writable?(file_in_chroot(file)) ? exit!(0) : exit!(1)
       end
 
       wpid, status = ::Process.waitpid2(pid)
@@ -246,6 +248,7 @@ module God
               r.close
               pid = self.spawn(command)
               puts pid.to_s # send pid back to forker
+              exit!(0)
             end
 
             ::Process.waitpid(opid, 0)
@@ -295,11 +298,13 @@ module God
         File.umask self.umask if self.umask
         uid_num = Etc.getpwnam(self.uid).uid if self.uid
         gid_num = Etc.getgrnam(self.gid).gid if self.gid
+        gid_num = Etc.getpwnam(self.uid).gid if self.gid.nil? && self.uid
 
         ::Dir.chroot(self.chroot) if self.chroot
         ::Process.setsid
-        ::Process.groups = [gid_num] if self.gid
-        ::Process::Sys.setgid(gid_num) if self.gid
+        ::Process.groups = [gid_num] if gid_num
+        ::Process.initgroups(self.uid, gid_num) if self.uid && gid_num
+        ::Process::Sys.setgid(gid_num) if gid_num
         ::Process::Sys.setuid(uid_num) if self.uid
         self.dir ||= '/'
         Dir.chdir self.dir