ace-eye 0.6.1

data/lib/eye/checker/children_count.rb

@@ -0,0 +1,44 @@
+class Eye::Checker::ChildrenCount < Eye::Checker::Measure
+
+  # check :children_count, :every => 30.seconds, :below => 10, :strategy => :kill_old
+  #   monitor_children should be enabled
+
+  param :strategy, Symbol, nil, :restart, [:restart, :kill_old, :kill_new]
+
+  def get_value
+    process.children.size
+  end
+
+  def fire
+    if strategy == :restart
+      super
+    else
+      pids = ordered_by_date_children_pids
+
+      pids = if strategy == :kill_old
+        pids[0...-below]
+      else
+        pids[below..-1]
+      end
+
+      kill_pids(pids)
+    end
+  end
+
+private
+
+  def kill_pids(pids)
+    info "killing pids: #{pids.inspect} for strategy: #{strategy}"
+    pids.each do |pid|
+      if child = process.children[pid]
+        child.schedule :stop, Eye::Reason.new("bounded #{check_name}")
+      end
+    end
+  end
+
+  def ordered_by_date_children_pids
+    children = process.children.values
+    children.sort_by { |ch| Eye::SystemResources.start_time(ch.pid).to_i }.map &:pid
+  end
+
+end

data/lib/eye/checker/children_memory.rb

@@ -0,0 +1,12 @@
+class Eye::Checker::ChildrenMemory < Eye::Checker::Measure
+
+  # check :children_memory, :every => 30.seconds, :below => 400.megabytes
+  #   monitor_children should be enabled
+
+  def get_value
+    process.children.values.inject(0) do |sum, ch|
+      sum + Eye::SystemResources.memory(ch.pid).to_i
+    end
+  end
+
+end

data/lib/eye/checker/cpu.rb

@@ -0,0 +1,17 @@
+class Eye::Checker::Cpu < Eye::Checker::Measure
+
+  # check :cpu, :every => 3.seconds, :below => 80, :times => [3,5]
+
+  def check_name
+    @check_name ||= "cpu(#{measure_str})"
+  end
+
+  def get_value
+    Eye::SystemResources.cpu(@pid).to_i # nil => 0
+  end
+
+  def human_value(value)
+    "#{value}%"
+  end
+
+end

data/lib/eye/checker/cputime.rb

@@ -0,0 +1,13 @@
+class Eye::Checker::Cputime < Eye::Checker::Measure
+
+  # check :cputime, :every => 1.minute, :below => 120.minutes
+
+  def get_value
+    Eye::SystemResources.cputime(@pid).to_f
+  end
+
+  def human_value(value)
+    "#{value / 60}m"
+  end
+
+end

data/lib/eye/checker/file_ctime.rb

@@ -0,0 +1,24 @@
+class Eye::Checker::FileCTime < Eye::Checker
+
+  # Check that file changes (log for example)
+  # check :ctime, :every => 5.seconds, :file => "/tmp/1.log", :times => [3,5]
+
+  param :file, [String], true
+
+  def get_value
+    File.ctime(file) rescue nil
+  end
+
+  def human_value(value)
+    if value == nil
+      'Err'
+    else
+      value.strftime('%H:%M')
+    end
+  end
+
+  def good?(value)
+    value.to_i > previous_value.to_i
+  end
+
+end

data/lib/eye/checker/file_size.rb

@@ -0,0 +1,34 @@
+class Eye::Checker::FileSize < Eye::Checker::Measure
+
+  # Check that file size changed (log for example)
+  # check :fsize, :every => 5.seconds, :file => "/tmp/1.log", :times => [3,5],
+  #      :below => 30.kilobytes, :above => 10.kilobytes
+
+  param :file, [String], true
+
+  def check_name
+    @check_name ||= "fsize(#{measure_str})"
+  end
+
+  def get_value
+    File.size(file) rescue nil
+  end
+
+  def human_value(value)
+    "#{value.to_i / 1024}Kb"
+  end
+
+  def good?(value)
+    return true unless previous_value
+
+    diff = value.to_i - previous_value.to_i
+
+    return true if diff < 0 # case when logger nulled
+
+    return false unless super(diff)
+    return false if diff == 0
+
+    true
+  end
+
+end

data/lib/eye/checker/file_touched.rb

@@ -0,0 +1,15 @@
+class Eye::Checker::FileTouched < Eye::Checker
+
+  param :file, [String], true
+  param :delete, [TrueClass, FalseClass]
+
+  def get_value
+    File.exists?(file)
+  end
+
+  def good?(value)
+    File.delete(file) if value && delete
+    !value
+  end
+
+end

data/lib/eye/checker/http.rb

@@ -0,0 +1,96 @@
+require 'net/http'
+
+class Eye::Checker::Http < Eye::Checker::Defer
+
+  # check :http, :every => 5.seconds, :times => 1,
+  #  :url => "http://127.0.0.1:3000/", :kind => :success, :pattern => /OK/, :timeout => 3.seconds
+
+  param :url,           String, true
+  param :pattern,       [String, Regexp]
+  param :kind,          [String, Fixnum, Symbol]
+  param :timeout,       [Fixnum, Float]
+  param :open_timeout,  [Fixnum, Float]
+  param :read_timeout,  [Fixnum, Float]
+
+  attr_reader :uri
+
+  def initialize(*args)
+    super
+
+    @uri = URI.parse(url)
+    @kind = case kind
+              when Fixnum then Net::HTTPResponse::CODE_TO_OBJ[kind]
+              when String, Symbol then Net.const_get("HTTP#{kind.to_s.camelize}") rescue Net::HTTPSuccess
+            else
+              Net::HTTPSuccess
+            end
+    @open_timeout = (open_timeout || 3).to_f
+    @read_timeout = (read_timeout || timeout || 15).to_f
+  end
+
+  def get_value
+    res = session.start{ |http| http.get(@uri.request_uri) }
+    {:result => res}
+
+  rescue Timeout::Error => ex
+    debug ex.inspect
+
+    if defined?(Net::OpenTimeout) # for ruby 2.0
+      mes = ex.class.is_a?(Net::OpenTimeout) ? "OpenTimeout<#{@open_timeout}>" : "ReadTimeout<#{@read_timeout}>"
+      {:exception => mes}
+    else
+      {:exception => "Timeout<#{@open_timeout},#{@read_timeout}>"}
+    end
+
+  rescue => ex
+    {:exception => "Error<#{ex.message}>"}
+  end
+
+  def good?(value)
+    return false unless value[:result]
+
+    unless value[:result].kind_of?(@kind)
+      return false
+    end
+
+    if pattern
+      matched = if pattern.is_a?(Regexp)
+        pattern === value[:result].body
+      else
+        value[:result].body.include?(pattern.to_s)
+      end
+      value[:notice] = "missing '#{pattern.to_s}'" unless matched
+      matched
+    else
+      true
+    end
+  end
+
+  def human_value(value)
+    if !value.is_a?(Hash)
+      '-'
+    elsif value[:exception]
+      value[:exception]
+    else
+      body_size = value[:result].body.size / 1024
+      msg = "#{value[:result].code}=#{body_size}Kb"
+      msg += "<#{value[:notice]}>" if value[:notice]
+      msg
+    end
+  end
+
+private
+
+  def session
+    Net::HTTP.new(@uri.host, @uri.port).tap do |session|
+      if @uri.scheme == 'https'
+        require 'net/https'
+        session.use_ssl = true
+        session.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      session.open_timeout = @open_timeout
+      session.read_timeout = @read_timeout
+    end
+  end
+
+end

data/lib/eye/checker/memory.rb

@@ -0,0 +1,17 @@
+class Eye::Checker::Memory < Eye::Checker::Measure
+
+  # check :memory, :every => 3.seconds, :below => 80.megabytes, :times => [3,5]
+
+  def check_name
+    @check_name ||= "memory(#{measure_str})"
+  end
+
+  def get_value
+    Eye::SystemResources.memory(@pid).to_i
+  end
+
+  def human_value(value)
+    "#{value.to_i / 1024 / 1024}Mb"
+  end
+
+end

data/lib/eye/checker/nop.rb

@@ -0,0 +1,6 @@
+class Eye::Checker::Nop < Eye::Checker
+
+  # check :nop, :every => 10.hours # means restart every 10 hours
+
+  def get_value; end
+end

data/lib/eye/checker/runtime.rb

@@ -0,0 +1,18 @@
+class Eye::Checker::Runtime < Eye::Checker::Measure
+
+  # check :runtime, :every => 1.minute, :below => 120.minutes
+
+  def get_value
+    st = Eye::SystemResources.start_time(@pid)
+    if st
+      Time.now.to_i - st.to_i
+    else
+      0
+    end
+  end
+
+  def human_value(value)
+    "#{value / 60}m"
+  end
+
+end

data/lib/eye/checker/socket.rb

@@ -0,0 +1,159 @@
+class Eye::Checker::Socket < Eye::Checker::Defer
+
+  # check :socket, :every => 5.seconds, :times => 1,
+  #  :addr => "unix:/var/run/daemon.sock", :timeout => 3.seconds,
+  #
+  # Available parameters:
+  # :addr          the socket addr to open. The format is tcp://<host>:<port> or unix:<path>
+  # :timeout       generic timeout for reading data from socket
+  # :open_timeout  override generic timeout for the connection
+  # :read_timeout  override generic timeout for data read/write
+  # :send_data     after connection send this data
+  # :expect_data   after sending :send_data expect this response. Can be a string, Regexp or a Proc
+  # :protocol      way of pack,unpack messages (default = socket default), example: :protocol => :em_object
+
+  param :addr,          String, true
+  param :timeout,       [Fixnum, Float]
+  param :open_timeout,  [Fixnum, Float]
+  param :read_timeout,  [Fixnum, Float]
+  param :send_data
+  param :expect_data,   [String, Regexp, Proc]
+  param :protocol,      [Symbol], nil, nil, [:default, :em_object, :raw]
+
+  def initialize(*args)
+    super
+    @open_timeout = (open_timeout || 1).to_f
+    @read_timeout = (read_timeout || timeout || 5).to_f
+
+    if addr =~ %r[\Atcp://(.*?):(.*?)\z]
+      @socket_family = :tcp
+      @socket_addr = $1
+      @socket_port = $2.to_i
+    elsif addr =~ %r[\Aunix:(.*)\z]
+      @socket_family = :unix
+      @socket_path = $1
+    end
+  end
+
+  def get_value
+    sock = begin
+      Timeout::timeout(@open_timeout){ open_socket }
+    rescue Timeout::Error
+      return { :exception => "OpenTimeout<#{@open_timeout}>" }
+    end
+
+    if send_data
+      begin
+        Timeout::timeout(@read_timeout) do
+          _write_data(sock, send_data)
+          result = _read_data(sock)
+
+          { :result => result }
+        end
+      rescue Timeout::Error
+        if protocol == :raw
+          return { :result => @buffer }
+        else
+          return { :exception => "ReadTimeout<#{@read_timeout}>" }
+        end
+      end
+    else
+      { :result => :listen }
+    end
+
+  rescue Exception => e
+    { :exception => "Error<#{e.message}>" }
+
+  ensure
+    sock.close if sock
+  end
+
+  def good?(value)
+    return false if !value[:result]
+
+    if expect_data
+      if expect_data.is_a?(Proc)
+        match = begin
+          !!expect_data[value[:result]]
+        rescue Timeout::Error, Exception => ex
+          mes = "proc match failed with '#{ex.message}'"
+          error(mes)
+          value[:notice] = mes
+          return false
+        end
+
+        unless match
+          warn "proc #{expect_data} not matched (#{value[:result].truncate(30)}) answer"
+          value[:notice] = 'missing proc validation'
+        end
+
+        return match
+      end
+
+      return true if expect_data.is_a?(Regexp) && expect_data.match(value[:result])
+      return true if value[:result].to_s == expect_data.to_s
+
+      warn "#{expect_data} not matched (#{value[:result].truncate(30)}) answer"
+      value[:notice] = "missing '#{expect_data.to_s}'"
+      return false
+    end
+
+    return true
+  end
+
+  def human_value(value)
+    if !value.is_a?(Hash)
+      '-'
+    elsif value[:exception]
+      value[:exception]
+    else
+      if value[:result] == :listen
+        'listen'
+      else
+        res = "#{value[:result].to_s.size}b"
+        res += "<#{value[:notice]}>" if value[:notice]
+        res
+      end
+    end
+  end
+
+private
+
+  def open_socket
+    if @socket_family == :tcp
+      TCPSocket.open(@socket_addr, @socket_port)
+    elsif @socket_family == :unix
+      UNIXSocket.open(@socket_path)
+    else
+      raise "Unknown socket addr #{addr}"
+    end
+  end
+
+  def _write_data(socket, data)
+    case protocol
+    when :em_object
+      data = Marshal.dump(data)
+      socket.write([data.bytesize, data].pack('Na*'))
+    else
+      socket.write(data.to_s)
+    end
+  end
+
+  def _read_data(socket)
+    case protocol
+    when :em_object
+      content = ''
+      msg_size = socket.recv(4).unpack('N')[0] rescue 0
+      content << socket.recv(msg_size - content.length) while content.length < msg_size
+      if content.present?
+        Marshal.load(content) rescue 'corrupted_marshal'
+      end
+    when :raw
+      @buffer = ''
+      loop { @buffer << socket.recv(1) }
+    else
+      socket.readline.chop
+    end
+  end
+
+end