cognizant 0.0.2 → 0.0.3

data/README.md

@@ -1,221 +0,0 @@
-# Cognizant: system utility to supervise your processes
-
-Let us say that you have a program that is critical for your application. Any
-downtime for the processes of this program would hurt your business. You want
-to make sure these processes are always up and working. If anything unexpected
-happens to their state, you want to be notified about it.
-
-Enter Cognizant. Cognizant is a system utility that supervises your processes,
-monitoring and ensuring their state based on a flexible criteria.
-
-In simpler terms, it keeps your processes up and running. It ensures
-that something productive (like restart) is done when the process being
-monitored matches a certain condition (like RAM, CPU usage or a custom
-condition).
-
-And if it matters, cognizant means "having knowledge or being aware of",
-according to Apple's Dictionary.
-
-Cognizant can be used to monitor any long running process, including the
-following:
-
-- Web servers (Nginx, Apache httpd, WebSocket, etc.)
-- Databases (Redis, MongoDB, MySQL, PostgreSQL, etc.)
-- Job workers (Resque, Sidekiq, Qless, etc.)
-- Message queue applications (RabbitMQ, Beanstalkd, etc.)
-- Logs collection daemons
-- Or any other program that needs to keep running
-
-### Monitoring
-
-Cognizant can be used to monitor an application process' state so that it
-is running at all times. When cognizant is instructed to monitor a process,
-by default, the process will automatically be started. These processes are
-automatically monitored for their state. i.e. a process is automatically
-started again if it stops unexpectedly.
-
-### Conditions
-
-Conditions provide a way to monitor and act on more than just the state of a
-process. For example, conditions can monitor the resource utilization (RAM,
-CPU, etc.) of the application process and restart it if it matches a
-condition.
-
-See examples for conditions usage.
-
-### Notifications
-
-PS: Notifications currently need work.
-
-Notifications provide a way to alert system administrator of unexpected events
-happening with the process. Notifications can use multiple gateways, including
-email and twitter [direct message].
-
-## Getting started
-
-Cognizant is written in the Ruby programming language, and hence depends on
-it. Ensure that you have Ruby 1.9+ installed and run:
-
-    $ gem install cognizant
-
-## Architecture overview
-
-                                                          _____
-                                                 ___________   |
-     ____________          ____________         |           |  |
-    |            |        |            | -----> | Process A |  |
-    | Admin      |        | Monitoring |        |___________|  |
-    | Utility    | -----> | Daemon     |         ___________   | -- Managed Processes
-    | >_         |        |            |        |           |  |
-    |____________|        |____________| -----> | Process B |  |
-                                                |___________|  |
-                                                          _____|
-
-Since cognizant administration and process monitoring are two separate concerns, they are serviced by separate applications, `cognizant` and `cognizantd`, respectively.
-
-## Starting the monitoring daemon
-
-Cognizant runs the monitoring essentials through the `cognizantd` daemon application, which also maintains a server for accepting commands from the `cognizant` administration utility.
-
-The daemon, with it's default options, requires superuser access to certain system directories for storing logs and pid files. It can be started as follows:
-
-    $ sudo cognizantd    # ubuntu, debian, os x, etc.
-    $ su -c 'cognizantd' # amazon linux, centos, rhel, etc.
-
-To start without superuser access, specify these file and directory config variables to where the user starting it has write access:
-
-    $ cognizantd ./examples/cognizantd.yml
-    
-    # assuming that:
-    
-    $ cat ~/.examples/cognizantd.yml # find this file in source code for latest version
-    ---
-    socket:   ~/.cognizant/cognizantd.sock
-    pidfile:  ~/.cognizant/cognizantd.pid
-    logfile:  ~/.cognizant/cognizantd.log
-    pids_dir: ~/.cognizant/pids/
-    logs_dir: ~/.cognizant/logs/
-    
-    monitor: {
-      redis-server-1: {
-        group: redis,
-        start_command: /usr/local/bin/redis-server -,
-        start_with_input: "daemonize no\nport 6666",
-        ping_command: redis-cli -p 6666 PING,
-        stop_signals: [TERM, INT]
-      },
-      redis-server-2: {
-        group: redis,
-        start_command: /usr/local/bin/redis-server -,
-        start_with_input: "daemonize no\nport 7777",
-        ping_command: redis-cli -p 7777 PING,
-        stop_command: redis-cli -p 7777 SHUTDOWN
-      },
-      sleep: {
-        start_command: sleep 3,
-        checks: {
-          flapping: {
-            times: 4,
-            within: 15, # Seconds.
-            retry_after: 30 # Seconds.
-          }
-        }
-      }
-    }
-
-or
-
-    # pass config directly into the daemon's STDIN
-    $ echo <<EOF | cognizantd -
-    ---
-    socket:   ~/.cognizant/cognizantd.sock
-    ...
-    monitor: {
-      ...
-      ...
-    }
-    EOF
-
-Process information can also be provided via Ruby code. See `load` command below.
-
-## Using the administration utility
-
-Cognizant can be administered using the `cognizant` command line utility. This is an application for performing administration tasks like monitoring, starting, stopping processes or loading configuration and processes' information.
-
-Here are some basic operational commands:
-
-    $ cognizant monitor redis # by group name
-    $ cognizant restart redis-server-1 # by process name
-
-To get cognizant to ignore a particular process' state:
-
-    $ cognizant unmonitor sleep-10
-
-Now check status of all managed processes:
-
-    $ cognizant status
-    +----------------+-------+--------------------------------------+
-    | Process        | Group | State                                |
-    +----------------+-------+--------------------------------------+
-    | redis-server-1 | redis | running since 1 minute               |
-    +----------------+-------+--------------------------------------+
-    | redis-server-2 | redis | running since 2 minutes              |
-    +----------------+-------+--------------------------------------+
-    | sleep-10       |       | unmonitored since less than a minute |
-    +----------------+-------+--------------------------------------+
-    2012-11-23 01:16:18 +0530
-
-Here's how you tell cognizant to start monitoring new processes:
-
-    $ cognizant load ./examples/redis-server.rb # find this file in source code
-
-All of the available commands are:
-
-- `help`               - Shows a list of commands or help for one command
-- `status    [name]`   - Display status of managed process(es) or group(s)
-- `load      ./cog.rb` - Loads the process information from specified Ruby file
-- `monitor   name`     - Monitor the specified process or group
-- `unmonitor name`     - Unmonitor the specified process or group
-- `start     name`     - Start the specified process or group
-- `stop      name`     - Stop the specified process or group
-- `restart   name`     - Restart the specified process or group
-- `shutdown`           - Stop the monitoring daemon without affecting processes
-
-See `cognizant help` for options.
-
-## Contributing
-
-Contributions are definitely welcome. To contribute, just follow the usual
-workflow:
-
-1. Fork Cognizant
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Github pull request
-
-## Compatibility
-
-Cognizant was developed and tested under Ruby 1.9.2-p290.
-
-## Similar programs
-
-- Monit
-- God (Ruby)
-- Bluepill (Ruby)
-- Supervisord (Python)
-- Upstart
-- SysV Init
-- Systemd
-- Launchd
-
-### Links
-
-- Documentation: http://rubydoc.info/github/Gurpartap/cognizant/frames
-- Source: https://github.com/Gurpartap/cognizant
-- Rubygems: https://rubygems.org/gems/cognizant
-
-## About
-
-Cognizant is a project of [Gurpartap Singh](http://gurpartap.com/). Feel free
-to get in touch.

data/examples/redis-server.rb

@@ -1,28 +0,0 @@
-# 2 slave instances to master at port 6000.
-3.times do |i|
-  Cognizant.monitor("redis-server-600#{i}") do |process|
-    process.group         = "redis"
-    # process.uid           = "redis"
-    # process.gid           = "redis"
-    process.start_command = "redis-server -"
-    process.ping_command  = "redis-cli -p 600#{i} PING"
-
-    slaveof = i == 0 ? "" : "slaveof 127.0.0.1 6000"
-    process.start_with_input = <<-heredoc
-      daemonize no
-      port 600#{i}
-      #{slaveof}
-    heredoc
-
-    # process.on :always_true, :every => 2.seconds, :times => 3 do |p|
-    #   `say "Boom!"`
-    # end
-
-    process.check(:flapping, :times => 2, :within => 30.seconds, :retry_after => 7.seconds)
-    process.check(:cpu_usage, :every => 3.seconds, :above => 60, :times => 3, :do => :restart)
-
-    process.check(:memory_usage, :every => 5.seconds, :above => 100.megabytes, :times => [3, 5]) do |p|
-      p.restart # Restart is the default anyways.
-    end
-  end
-end

data/examples/resque.rb

@@ -1,10 +0,0 @@
-5.times do |i|
-  Cognizant.monitor "resque-worker-#{i}" do |process|
-    process.group         = "resque"
-    process.uid           = "deploy"
-    process.gid           = "deploy"
-    process.chdir         = "/apps/example/current/"
-    process.env           = { "QUEUE" => "*", "RACK_ENV" => "production" }
-    process.start_command = "bundle exec rake resque:work"
-  end
-end

data/lib/cognizant/logging.rb

@@ -1,33 +0,0 @@
-require "logger"
-
-module Cognizant
-  module Logging
-    extend self
-
-    def add_log_adapter(file)
-      @files ||= Array.new
-      @files << file unless @files.include?(file)
-      @logger = nil
-    end
-
-    def log
-      @files ||= Array.new($stdout)
-      @logger ||= Logger.new(Files.new(*@files))
-    end
-    alias :logger :log
-
-    class Files
-      def initialize(*files)
-        @files = files
-      end
-
-      def write(*args)
-        @files.each { |t| t.write(*args) }
-      end
-
-      def close
-        @files.each(&:close)
-      end
-    end
-  end
-end

data/lib/cognizant/process/conditions/flapping.rb

@@ -1,57 +0,0 @@
-require "cognizant/util/rotational_array"
-
-module Cognizant
-  class Process
-    module Conditions
-      class Flapping < TriggerCondition
-        TRIGGER_STATES = [:starting, :restarting]
-
-        attr_accessor :times, :within, :retry_after
-        attr_reader :timeline
-
-        def initialize(process, options = {})
-          options = { :times => 5, :within => 1, :retry_after => 5 }.merge(options)
-
-          options.each_pair do |name, value|
-            self.send("#{name}=", value) if self.respond_to?("#{name}=")
-          end
-
-          @timeline = Util::RotationalArray.new(@times)
-          super
-        end
-
-        def notify(transition)
-          if TRIGGER_STATES.include?(transition.to_name)
-            self.timeline << Time.now.to_i
-            self.check_flapping
-          end
-        end
-
-        def reset!
-          @timeline.clear
-          super
-        end
-
-        def check_flapping
-          # The process has not flapped if we haven't encountered enough incidents.
-          return unless (@timeline.compact.length == self.times)
-
-          # Check if the incident happend within the timeframe.
-          duration = (@timeline.last - @timeline.first) <= self.within
-
-          if duration
-            puts "Flapping detected: retrying in #{self.retry_after} seconds"
-
-            self.schedule_event(:start, self.retry_after) unless self.retry_after == 0 # retry_after zero means "do not retry, ever".
-            self.schedule_event(:unmonitor, 0)
-
-            @timeline.clear
-
-            # This will prevent a transition from happening in the process state_machine.
-            throw :halt
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cognizant/process/conditions/trigger_condition.rb

@@ -1,52 +0,0 @@
-module Cognizant
-  class Process
-    module Conditions
-      class TriggerCondition
-        attr_accessor :process, :mutex, :scheduled_events
-
-        def initialize(process, options = {})
-          self.process = process
-          self.mutex = Mutex.new
-          self.scheduled_events = []
-        end
-
-        def reset!
-          self.cancel_all_events
-        end
-
-        def notify(transition)
-          raise "Implement in subclass"
-        end
-
-        def dispatch!(event)
-          self.process.dispatch!(event, self.class.name.split("::").last)
-        end
-
-        def schedule_event(event, delay)
-          # TODO: Maybe wrap this in a ScheduledEvent class with methods like cancel.
-          thread = Thread.new(self) do |trigger|
-            begin
-              sleep delay.to_f
-              trigger.dispatch!(event)
-              trigger.mutex.synchronize do
-                trigger.scheduled_events.delete_if { |_, thread| thread == Thread.current }
-              end
-            rescue StandardError => e
-              puts(e)
-              puts(e.backtrace.join("\n"))
-            end
-          end
-
-          self.scheduled_events.push([event, thread])
-        end
-
-        def cancel_all_events
-          puts "Canceling all scheduled events"
-          self.mutex.synchronize do
-            self.scheduled_events.each {|_, thread| thread.kill}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cognizant/server.rb

@@ -1,14 +0,0 @@
-require "cognizant/server/daemon"
-
-module Cognizant
-  module Server
-    def self.start(options = {})
-      @daemon = Cognizant::Server::Daemon.new(options)
-      @daemon.bootup
-    end
-
-    def self.daemon
-      @daemon
-    end
-  end
-end

data/lib/cognizant/server/commands.rb

@@ -1,80 +0,0 @@
-require "json"
-require "cognizant/system"
-
-module Cognizant
-  module Server
-    module Commands
-      def self.load(config_file)
-        Cognizant::Server.daemon.load(config_file)
-        # yield("OK")
-      end
-
-      def self.status(*args)
-        output_processes = []
-        if args.size > 0
-          Cognizant::Server.daemon.processes.values.each do |process|
-            output_processes << process if args.include?(process.name) or args.include?(process.group)
-          end
-          if output_processes.size == 0
-            raise("ERROR: No such process")
-            # yield("OK")
-          end
-        else
-          output_processes = Cognizant::Server.daemon.processes.values
-        end
-        
-        output = []
-        output_processes.each do |process|
-          pid = process.read_pid
-          output << {
-            "Process" => process.name,
-            "PID"     => pid,
-            "Group"   => process.group,
-            "State"   => process.state,
-            "Since"   => process.last_transition_time,
-            "% CPU"   => System.cpu_usage(pid).to_f,
-            "Memory"  => System.memory_usage(pid).to_f # in KBs.
-          }
-        end
-        yield(output.to_json)
-        # yield("OK")
-      end
-
-      %w(monitor start stop restart unmonitor).each do |action|
-        class_eval <<-END
-          def self.#{action}(*args)
-            unless args.size > 0
-              raise("ERROR: Missing process name")
-              return # yield("OK")
-            end
-            output_processes = []
-            Cognizant::Server.daemon.processes.values.each do |process|
-              if args.include?(process.name) or args.include?(process.group)
-                output_processes << process
-              end
-            end
-
-            if output_processes.size == 0
-              raise("ERROR: No such process")
-              # yield("OK")
-            else
-              output_processes.each do |process|
-                process.handle_user_command(:#{action})
-              end
-            end
-          end
-        END
-      end
-
-      def self.shutdown
-        Cognizant::Server.daemon.shutdown
-        # yield("OK")
-      end
-
-      def self.method_missing(command, *args)
-        raise("ERROR: Unknown command '#{command}'")
-        # yield("OK")
-      end
-    end
-  end
-end