malevich 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1b68e4d209f800c0c2a08ce6166a01fe4c3f9dd
+  data.tar.gz: 0a28fab3e6992d1a6f29b2cc88c4bb3d020fd566
+SHA512:
+  metadata.gz: d724ea316def8f81ea864a15a240dce95eb0adc2bcf3498317d8eab48b0cdafc7b0ac0da99500a0754875e37e4e07c452924ef8296bb05f155812fc09c7eb696
+  data.tar.gz: 04f3e20dcc6334742a56494c9618c331d0c2b91337dece4ddf29af2d0981d3987888abb63c4146c3c53d67660f7f8e03736691350fbe5894e765f8f53cd1a838

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+vendor
+.bundle

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Vasiliev Dmitry
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Malevich
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'malevich'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install malevich
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/malevich

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'malevich'
+require 'trollop'
+
+cmd = Trollop::options do
+  version "Malevich #{Malevich::VERSION}"
+  banner <<-EOS
+Malevich is tool for monitoring.
+
+Usage:
+       malevich [options]
+where [options] are:
+  EOS
+
+  opt :config, 'Config file', :default => '/etc/malevich/config.yml'
+  opt :'log-level', 'Log level', :default => 'DEBUG'
+  opt :'riemann-host', 'Riemann server', :short => '-r', :default => '127.0.0.1:5555', :multi => true
+  opt :'riemann-tcp', 'Use tcp to connect riemann', :default => true
+  opt :tags, 'Set tags', :short => '-t', :multi => true
+  opt :plugins, 'Directory for plugins', :short => '-d', :default => '/usr/share/malevich/plugins', :multi => true
+  opt :'http-responder', 'Bind http api', :short => '-h', :default => '0.0.0.0:55755'
+  opt :'udp-responder', 'Bind udp api', :short => '-u', :default => '127.0.0.1:55955'
+  opt :'test', 'Test plugin file', :type => :string
+end
+
+malevich.cmd.deep_merge!(cmd)
+#malevich.cmd[:pwd] = Dir.pwd
+malevich.log_level = cmd[:'log-level']
+malevich.test_plugin(cmd[:'test'])
+malevich.load_plugins(cmd[:'plugins'], cmd[:'config'])
+malevich.load_responders
+malevich.monitor.run!
+

data/example/cpu.rb

@@ -0,0 +1,31 @@
+always_start true
+interval 60
+warning 70
+critical 85
+
+settings :per_process, false
+
+collect "linux" do
+  @old_cpu ||= {}
+  File.read('/proc/stat').each_line do |cpu_line|
+    cpu_number = cpu_line.scan(/cpu(\d+|\s)\s+/)
+    next if cpu_number.empty?
+    cpu_number = cpu_number[0][0] == ' ' ? '_total' : cpu_number[0][0]
+    cpu_line[/cpu(\d+|\s)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/]
+    _, u2, n2, s2, i2 = [$1, $2, $3, $4, $5].map { |e| e.to_i }
+    unless @old_cpu[cpu_number].nil?
+      u1, n1, s1, i1 = @old_cpu[cpu_number]
+      used           = (u2+n2+s2) - (u1+n1+s1)
+      total          = used + i2-i1
+      fraction       = used.to_f / total
+    end
+    @old_cpu[cpu_number] = [u2, n2, s2, i2]
+    service              = "cpu usage cpu#{cpu_number}"
+    description          = "Cpu#{cpu_number} usage"
+    if cpu_number == '_total'
+      event(:service => service, :metric => fraction, :description => description)
+    else
+      event(:service => service, :metric => fraction, :description => description, :state => 'ok')
+    end
+  end
+end

data/example/disk.rb

@@ -0,0 +1,59 @@
+require 'sys/filesystem'
+
+always_start true
+interval 60
+
+warning 70
+critical 85
+
+settings :not_monit_fs_4_size, %w(sysfs nfs devpts squashfs proc devtmpfs)
+settings :monit_fs_4_fstab, %w(ext2 ext3 ext4 xfs tmpfs)
+settings :not_monit_device_4_fstab, %w(none)
+settings :not_monit_point_4_fstab, %w(/lib/init/rw /dev/shm /dev)
+settings :check_fstab, true
+
+collect "linux" do
+
+  def get_monit_points_for_size
+    monit_points = []
+    File.open('/proc/mounts', 'r') do |file|
+      while line = file.gets
+        mtab = line.split(/\s+/)
+        monit_points << mtab[1] unless settings.not_monit_fs_4_size.include? mtab[2]
+      end
+    end
+    monit_points
+  end
+
+  def get_monit_points_for_fstab
+    monit_points = []
+    File.open('/proc/mounts', 'r') do |file|
+      while line = file.gets
+        mtab = line.split(/\s+/)
+        if settings.monit_fs_4_fstab.include?(mtab[2]) &&
+            !settings.not_monit_point_4_fstab.include?(mtab[1]) &&
+            !settings.not_monit_device_4_fstab.include?(mtab[0])
+          monit_points << mtab[1]
+        end
+      end
+    end
+    monit_points
+  end
+
+  get_monit_points_for_size.each do |point|
+    point_stat  = Sys::Filesystem.stat(point)
+    human_point = point == '/' ? '/root' : point
+    human_point = human_point.gsub(/^\//, '').gsub(/\//, '_')
+    event(:service => "disk #{human_point} % block", :description => "Disk usage #{point}, %", :metric => (1- point_stat.blocks_available.to_f/point_stat.blocks).round(2) * 100) unless point_stat.blocks == 0
+    event(:service => "disk #{human_point} % inode", :description => "Disk usage #{point}, inodes %", :metric => (1 - point_stat.files_available.to_f/point_stat.files).round(2) * 100) unless point_stat.files == 0
+    event(:service => "disk #{human_point} abs free", :description => "Disk free #{point}, B", :metric => point_stat.blocks_free * point_stat.block_size, :state => 'ok')
+    event(:service => "disk #{human_point} abs total", :description => "Disk space #{point}, B", :metric => point_stat.blocks * point_stat.block_size, :state => 'ok')
+  end
+
+  fstab = File.read('/etc/fstab').split("\n").delete_if { |x| x.strip.match(/^#/) }
+  fstab = fstab.join("\n")
+  get_monit_points_for_fstab.each do |point|
+    event(:service => "disk #{point} fstab entry", :description => "Mount point #{point} not matched in /etc/fstab", :state => 'critical') unless fstab.match(/#{point}(\s|\/\s)/)
+  end if settings.check_fstab
+
+end

data/example/disk_stat.rb

@@ -0,0 +1,28 @@
+always_start true
+interval 60
+
+settings :words, %w( 'reads reqs', 'reads merged', 'reads sector', 'reads time',
+                     'writes reqs', 'writes merged', 'writes sector', 'writes time',
+                     'io reqs', 'io time', 'io weighted' )
+
+settings :filter, %w('reads reqs', 'writes reqs')
+
+run_if "linux" do
+  File.exists? '/proc/diskstats'
+end
+
+collect "linux" do
+  f = File.read('/proc/diskstats')
+  f.split("\n").reject { |d| d =~ /(ram|loop)/ }.inject({}) do |_, line|
+    if line =~ /^(?:\s+\d+){2}\s+([\w\d]+) (.*)$/
+      dev    = $1
+      values = $2.split(/\s+/).map { |str| str.to_i }
+      next if !!(dev.match /\d+$/ || !(dev.match =~ /^xvd/))
+      settings.filter.each do |filter|
+        event(:service => "diskstat #{dev} #{filter}", :metric => values[settings.words.index(filter)].to_f/interval, :diff => true)
+      end
+      iops = values[settings.words.index('reads reqs')].to_i + values[settings.words.index('writes reqs')].to_i
+      event(:service => "diskstat #{dev} iops", :metric => iops.to_f/interval, :diff => true)
+    end
+  end
+end

data/example/dns_check.rb

@@ -0,0 +1,7 @@
+interval 60
+
+collect "linux", "mac_os_x" do
+  event(
+    :state => Resolv::DNS.new.getresources(ohai[:fqdn], Resolv::DNS::Resource::IN::A).count == 1, 
+    :description => "Check resolv self FQDN")
+end

data/example/exim.rb

@@ -0,0 +1,15 @@
+always_start true
+interval 60
+
+warning 5
+critical 20
+settings :exim, '/usr/sbin/exim'
+
+run_if do
+  File.exists? settings.exim
+end
+
+collect do
+  event(:service     => 'exim', :metric => shell(settings.exim, ' -bpc').to_i,
+        :description => 'Exim: count frozen mails')
+end

data/example/find_files.rb

@@ -0,0 +1,21 @@
+interval 60
+
+warning 5
+
+settings :file_mask, '.*'
+settings :dir, '/tmp/dir'
+settings :age, 24 * 60 * 60
+
+collect do
+  if File.directory?(settings.dir)
+    count_files = 0
+    file_mask   = Regexp.new(settings.file_mask)
+    Find.find(settings.dir).each do |file|
+      next unless File.file? file
+      next unless file_mask.match file
+      next unless Time.now.to_i - settings.age > File.new(file).mtime.to_i
+      count_files += 1
+    end
+    event(:service => "find files #{settings.dir}", :metric => count_files, :description => "Count files in #{settings.dir}")
+  end
+end

data/example/http.rb

@@ -0,0 +1,25 @@
+interval 60
+
+settings :http_code, 200
+settings :http_method, 'GET'
+settings :connect_timeout, 5
+settings :retry, 0
+settings :retry_delay, 0
+settings :max_time, 10
+settings :insecure, false
+settings :url, 'http://127.0.0.1:80'
+settings :service, 'http check'
+
+collect "linux", "mac_os_x" do
+
+  @cmd ||= begin
+    "curl -X#{settings.http_method} -s --connect-timeout #{settings.connect_timeout}" +
+      " #{'--insecure' if settings.insecure} " +
+      " -w '%{http_code}\\n' --retry #{settings.retry} --retry-delay #{settings.retry_delay}" +
+      " --max-time #{settings.max_time} --fail #{settings.url} -o /dev/null"
+  end
+
+  out = shell_out(@cmd).stdout.to_i
+  event(:service => settings.service, :metric => out, :description => "http code: #{out}", :state => out == settings.http_code)
+
+end

data/example/iptables.rb

@@ -0,0 +1,27 @@
+interval 60
+settings :rule_file, '/etc/network/iptables'
+always_start true
+
+run_if "linux" do
+  File.exists? settings.rule_file
+end
+
+collect "linux" do
+
+  def delete_counters(str)
+    str.gsub(/\[\d+\:\d+\]/, '').strip
+  end
+
+  current_rules = shell_out!('iptables-save').stdout.split("\n").map do |x|
+    x[0] == '#' ? nil : delete_counters(x)
+  end.compact.join("\n")
+  saved_rules = File.read(settings.rules_file).split("\n").map do |x|
+    x[0] == '#' ? nil : delete_counters(x) # delete counters and comments
+  end.compact.join("\n")
+
+  event(
+    :service     => "iptables #{settings.rule_file}",
+    :state       => current_rules == saved_rules,
+    :description => "iptables rules different between file: #{settings.rule_file} and iptables-save"
+  )
+end

data/example/la.rb

@@ -0,0 +1,21 @@
+always_start true
+interval 60
+
+state :warning, 4
+state :critical, 50
+
+collect "mac_os_x" do
+  event(
+    :metric      => shell("sysctl -n vm.loadavg | awk '{print $2}'").to_f,
+    :description => 'LA averaged over 1 minute',
+    :service     => 'la la_1'
+  )
+end
+
+collect "linux" do
+  event(
+    :metric      => File.read('/proc/loadavg').scan(/[\d\.]+/)[0].to_f,
+    :description => 'LA averaged over 1 minute',
+    :service     => 'la la_1'
+  )
+end

data/example/mdadm.rb

@@ -0,0 +1,44 @@
+interval 60
+critical 1
+
+run_if "linux" do
+  File.exists? '/proc/mdstat'
+end
+
+collect "linux" do
+
+  def rm_bracket(text)
+    text.gsub('[', '').gsub(']', '')
+  end
+
+  def status_well?(text)
+    text.gsub(/U/, '').empty?
+  end
+
+  def get_failed_parts (device)
+    begin
+      failed_parts = []
+      Dir["/sys/block/#{device}/md/dev-*"].each do |p|
+        state = File.read("#{p}/state").strip
+        next unless state != 'in_sync'
+        p.gsub!(/.+\/dev-/, '')
+        failed_parts << "#{p} (#{state})"
+      end
+      failed_parts.join(', ')
+    rescue
+      nil
+    end
+  end
+
+
+  mdstat = File.read('/proc/mdstat').split("\n")
+  mdstat.each_with_index do |line, index|
+    next unless line.include?('blocks')
+    device   = file[index-1].split(':')[0].strip
+    mdstatus = rm_bracket(line.split(' ').last) # UUU
+    next if status_well?(mdstatus) # пропускаем все збс
+    next if mdstatus == settings.states.send(device).to_s # disabled in config
+    event(:service => "mdadm #{device}", :metric => 1, :description => "mdadm failed device #{device}: #{get_failed_parts(device)}")
+  end
+
+end

data/example/megacli.rb

@@ -0,0 +1,13 @@
+interval 180
+always_start true
+
+critical 1
+settings :cmd, 'megacli -AdpAllInfo -aAll -NoLog | awk -F": " \'/Virtual Drives/ { getline; print $2; }\''
+
+run_if "linux" do
+  File.exists? '/usr/bin/megacli'
+end
+
+collect "linux" do
+  event(:metric => shell!(settings.cmd).to_i, :description => 'MegaCli status')
+end

data/example/memory.rb

@@ -0,0 +1,31 @@
+interval 60
+always_start true
+
+critical 70
+warning 85
+
+collect "linux" do
+  m = File.read('/proc/meminfo').split(/\n/).inject({}) do |info, line|
+    x          = line.split(/:?\s+/)
+    info[x[0]] = x[1].to_i
+    info
+  end
+
+  free          = m['MemFree'].to_i * 1024
+  cached        = m['Cached'].to_i * 1024
+  buffers       = m['Buffers'].to_i * 1024
+  total         = m['MemTotal'].to_i * 1024
+  used          = total - free
+  free_bc       = free + buffers + cached
+  fraction      = 1 - (free_bc.to_f / total)
+  swap_fraction = m['SwapTotal'] == 0 ? 0 : 1 - m['SwapFree'].to_f/m['SwapTotal']
+
+  event(:service => 'memory % free', :description => 'Memory usage, %', :metric => fraction.round(2) * 100)
+  event(:service => 'memory % swap', :description => 'Swap usage, %', :metric => swap_fraction.round(2) * 100)
+  event(:service => 'memory abs free', :description => 'Memory free (kB)', :metric => free, :state => 'ok')
+  event(:service => 'memory abs total', :description => 'Memory total (kB)', :metric => total, :state => 'ok')
+  event(:service => 'memory abs cached', :description => 'Memory usage, cached (kB)', :metric => cached, :state => 'ok')
+  event(:service => 'memory abs buffers', :description => 'Memory usage, buffers (kB)', :metric => buffers, :state => 'ok')
+  event(:service => 'memory abs used', :description => 'Memory usage, used (kB)', :metric => used, :state => 'ok')
+  event(:service => 'memory abs free_bc', :description => 'Memory usage with cache and buffers (kB)', :metric => free_bc, :state => 'ok')
+end