kurchatov 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37b3d24113a19c945cc3871050111cce3ebc8d96
+  data.tar.gz: 6a1ac341e371c41671f14081e2cee4f61ae2ec3b
+SHA512:
+  metadata.gz: e106b36d33622926e71b9bc9ec1c757cef4c71221c75582001a84faeacccd7c0acb80754935b3f20c8234fed66a39ef90a2d799524599d229941a84bdd0ea918
+  data.tar.gz: 04d7c0362e7e7836ff88b4da38a12780615c1ff1e99c932ede53d603dd1ac1d2310d88642d802a0b5fd67ce042ce0ad8f8cb2276de26abd2d76b38860f739c3c

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: 
+  - 'ruby'
+rvm: 
+  - '1.9.3'
+script: "./tests/run.sh"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kurchatov.gemspec
+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,111 @@
+[![Build Status](https://travis-ci.org/vadv/kurchatov.png)](https://travis-ci.org/vadv/kurchatov)
+
+# Kurchatov
+
+Перед вами гем для мониторинга с помощью [riemann](http://riemann.io).
+Я люблю [chef](http://www.getchef.com) и [ohai](http://docs.opscode.com/ohai.html),
+поэтому здесь есть немного первого и немного второго.
+
+Юзкейз таков: 
+ * Kurchatov попадает в среду (окружение, приложения) которую не знает, и изучает ее с помощью ohai
+ * Решает какие плагины запускать
+ * Отсылает сообщения на riemann-хост со присвоеными статусами
+
+
+## DSL
+
+Решено использовать dsl для написания плагинов, плагин выглядит так:
+```ruby
+name "человеко читаемое имя" # по дефолту basename файла
+interval 60 # с какой переодичностью будет запускаться плагин
+always_start true # плагину не нужны дополнительные настройки
+
+default[:nginx][:file] = "/etc/nginx/nginx.conf"
+default[:nginx][:cmd] = "nginx -t" # дефолтные значение для Mashie: 'plugin'
+default[:nginx][:url] = "http://127.0.0.1:133233/status" # данные значения смержаться со значениями
+                                                         # полученными из конфига
+
+run_if :os => 'linux' do # по умолчанию разрешено запускать все и везде
+  File.exists? plugin.file # plugin - не что иное как проставленые значения из default
+                           # доступно обращение plugin[:file], plugin["file"], plugin.file
+end
+
+collect :web_some_platform => true, :os => 'linux' do # значение полученные через ohai, 
+                                                    # collect включиться ohai[:web_some_platform] == true и
+                                                    # для ohai[:os] == 'linux'
+  metric = rest_get(default[:nginx][:url]).split("\n").first.split("Active connections:").last.to_i
+  event(
+    :service => "nginx active connections",          # по дефолту name, если редиректим в graphite
+    :metric => metric,                               # то service будет ключем для url
+    :warning => 10,
+    :critical => 20,
+    :diff => true, # говорим что запоминать предыдущие значения и если разница между новым и старым
+                   # меньше warning - получим статус 'ok', больше critical - 'critical' и так далее
+                   # без :diff мы будем считать честные значения
+                   # для того чтобы посчитать RPS мы просто делим метрику на interval
+    :description => "Что-то для человека-монитора" # допустимо сокращения :desc
+  )
+
+  event(
+    :service => "nginx test config #{plugin.file}",  # сервис должен быть человекочитаемым но уникальным!
+    :state => shell_out("#{ohai[:nginx][:cmd]}").exitstatus == 0  # если :state == true стейт "ok", иначе - "critical"
+                                              # shell_out! - сгенерит exception и riemann уйдет сообщение об ошибке
+                                              # в плагине, также доступен просто shell() - он вернет только stdout и
+                                              # действует как shell_out!
+    :desc => "Ой, конфиг не валидный, наверно nginx -t его испортил :("
+  )
+
+end
+
+```
+Если плагин отправил event, это не означает что он попадает на riemann-server:
+* Эвенты группируются и отсылаются асинхронно пачками (все что накопилось за `Kurchatov::Responders::Riemann::FLUSH_INTERVAL` по дефолту 0.5 секунд)
+* При отсутвии метрики второй и последующий раз `:state == "ok"` не будет отсылаться
+
+Больше примеров вы найдете [тут](https://github.com/vadv/kurchatov/tree/master/examples).
+
+## OHAI
+
+И в африке ohai. Минимальный пример:
+```ruby
+provides "postgres"
+postgres Mash.new
+cmd = "psql -U postgres -tqc 'select version()'"
+status, stdout, stderr = run_command(:command => cmd)
+postgres[:version] = stdout.strip
+```
+
+## Config
+
+Это обычный yml-файл с настройками плагинов, eго удобно генерить chef'ом :)
+```yaml
+plugin name:
+  settins name: 
+  - 'bla-bla'
+```
+
+Есть небольшая магия, для того чтобы использовать плагин как провайдер (например следить за определенными портами):
+```yaml
+web watcher:
+  - url: http://localhost/ # создастся plugin с name == 'web watcher_0'
+    status: 302
+  - url: https://localhost/login # новый плагин name == 'web watcher_1'
+    status: 200
+    ua: Mozilla
+robots txt watcher: # новый плагин name == 'robots txt watcher'
+  parent: web watcher
+  url: https://localhost/robots.txt
+  status: 404
+  ua: ^Yandex
+```
+
+## Почему велосипед
+
+Удобно писать плагины, использовать 1 процесс, 1 коннект, и проч.
+
+Мне не нравиться официальная реализация [riemann-client](https://github.com/aphyr/riemann-ruby-client),
+она течет и создает много ненужных *конкретно* для меня полей для протобуфа (но все равно спасибо [aphyr](http://aphyr.com) за
+прекрасный сервер :) ), так что вы тут не найдете search и udp.
+
+Упор сделан на потребление памяти (эх, ruby), поэтому все на тредах и на данный момент на 1.9.3 вы можете получить 8Mb RES.
+

data/Rakefile

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

data/Vagrantfile

@@ -0,0 +1,16 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+
+  config.vm.box_url = "http://files.vagrantup.com/precise64_vmware.box"
+  config.vm.box = "precise64_kurchatov_gem"
+  config.ssh.forward_agent = true
+
+  config.vm.provider :vmware_fusion do |vmware|
+     vmware.vm.vmx["memsize"] = "2048"
+     vmware.vm.gui = false
+     vmware.box_url = "http://files.vagrantup.com/precise64_vmware.box"
+  end
+
+end

data/bin/kurchatov

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "kurchatov/application"
+
+Kurchatov::Aplication.new.run

data/examples/check_file_contains.rb

@@ -0,0 +1,14 @@
+interval 60
+
+default[:base_uri] = 'http://localhost/check'
+default[:expression] = 'ERROR'
+default[:contains] = false # Contains or not expression
+default[:service] = "check_file_contains"
+
+collect do
+  event(
+    :service => "#{plugin.service} #{plugin.base_uri} #{plugin.expression}",
+    :description => "#{plugin.base_uri} contains #{plugin.expression}",
+    :metric => rest_get(plugin.base_uri).include?(plugin.expression) == plugin.contains
+  )
+end

data/examples/count_proc.rb

@@ -0,0 +1,14 @@
+interval 60
+default[:proc] = 'ruby'
+
+collect :os => 'linux' do
+  count = 0
+  Dir['/proc/[0-9]*/cmdline'].each { |p| count += 1 if File.read(p) =~ /#{plugin.proc}/ }
+  event(
+    :service => "count proc #{plugin.proc}",
+    :metric => count,
+    :description => "count proc #{plugin.proc}, count: #{count}",
+    :warning => 5,
+    :critical => 20
+  )
+end

data/examples/cpu.rb

@@ -0,0 +1,29 @@
+always_start true
+interval 60
+
+default[:per_process] = false
+
+collect :os => '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, :desc => description, :warning => 70, :critical => 58)
+    else
+      event(:service => service, :metric => fraction, :desc => description, :state => 'ok')
+    end
+  end
+end

data/examples/disk.rb

@@ -0,0 +1,56 @@
+require 'sys/filesystem'
+
+always_start true
+interval 60
+
+default[:not_monit_fs_4_size] = %w(sysfs nfs devpts squashfs proc devtmpfs)
+default[:monit_fs_4_fstab] = %w(ext2 ext3 ext4 xfs tmpfs)
+default[:not_monit_device_4_fstab] = %w(none)
+default[:not_monit_point_4_fstab] = %w(/lib/init/rw /dev/shm /dev)
+default[:check_fstab] = true
+
+collect :os => '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 plugin.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 plugin.monit_fs_4_fstab.include?(mtab[2]) &&
+            !plugin.not_monit_point_4_fstab.include?(mtab[1]) &&
+            !plugin.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(:warning => 70, :critical => 85, :service => "disk #{human_point} % block", :desc => "Disk usage #{point}, %", :metric => (1- point_stat.blocks_available.to_f/point_stat.blocks).round(2) * 100) unless point_stat.blocks == 0
+    event(:warning => 70, :critical => 85, :service => "disk #{human_point} % inode", :desc => "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", :desc => "Disk free #{point}, B", :metric => point_stat.blocks_free * point_stat.block_size, :state => 'ok')
+    event(:service => "disk #{human_point} abs total", :desc => "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", :desc => "Mount point #{point} not matched in /etc/fstab", :state => 'critical') unless fstab.match(/#{point}(\s|\/\s)/)
+  end if plugin.check_fstab
+
+end

data/examples/disk_stat.rb

@@ -0,0 +1,28 @@
+always_start true
+interval 60
+
+default[:words] = [ 'reads reqs', 'reads merged', 'reads sector', 'reads time',
+                     'writes reqs', 'writes merged', 'writes sector', 'writes time',
+                     'io reqs', 'io time', 'io weighted' ]
+
+default[:filter] = [ 'reads reqs', 'writes reqs' ] 
+
+run_if do
+  File.exists? '/proc/diskstats'
+end
+
+collect :os => "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/))
+      plugin.filter.each do |filter|
+        event(:service => "diskstat #{dev} #{filter}", :metric => values[plugin.words.index(filter)].to_f/interval, :diff => true)
+      end
+      iops = values[plugin.words.index('reads reqs')].to_i + values[plugin.words.index('writes reqs')].to_i
+      event(:service => "diskstat #{dev} iops", :metric => iops.to_f/interval, :diff => true)
+    end
+  end
+end

data/examples/dns_check.rb

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

data/examples/exim.rb

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

data/examples/file_age.rb

@@ -0,0 +1,11 @@
+default[:file] = '/notexists'
+
+collect do
+  event(
+    :service => "#{name} #{plugin.file}",
+    :metric => (unixnow - File.stat(plugin.file).mtime.to_i).abs.to_f/60,
+    :description => "File #{plugin.file} age",
+    :warning => 1,
+    :critical => 5
+  )
+end

data/examples/find_files.rb

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

data/examples/http.rb

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

data/examples/iptables.rb

@@ -0,0 +1,27 @@
+interval 60
+default[:rule_file] = '/etc/network/iptables'
+always_start true
+
+run_if do
+  File.exists? plugin.rule_file
+end
+
+collect 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(plugin.rules_file).split("\n").map do |x|
+    x[0] == '#' ? nil : delete_counters(x) # delete counters and comments
+  end.compact.join("\n")
+
+  event(
+    :service     => "iptables #{plugin.rule_file}",
+    :state       => current_rules == saved_rules,
+    :description => "iptables rules different between file: #{plugin.rule_file} and iptables-save"
+  )
+end

data/examples/la.rb

@@ -0,0 +1,10 @@
+always_start true
+interval 60
+
+collect :os => "linux" do
+  event(
+    :metric      => File.read('/proc/loadavg').scan(/[\d\.]+/)[0].to_f,
+    :desc => 'LA averaged over 1 minute',
+    :service     => 'la la_1'
+  )
+end

data/examples/mdadm.rb

@@ -0,0 +1,43 @@
+interval 60
+
+run_if do
+  File.exists? '/proc/mdstat'
+end
+
+collect 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 == plugin[states][device].to_s # disabled in config
+    event(:service => "mdadm #{device}", :state => 'critical', :desc => "mdadm failed device #{device}: #{get_failed_parts(device)}")
+  end
+
+end

data/examples/megacli.rb

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

data/examples/memory.rb

@@ -0,0 +1,28 @@
+interval 60
+always_start true
+
+collect :os => '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', :desc => 'Memory usage, %', :metric => fraction.round(2) * 100, :critical => 85, :warning => 75)
+  event(:service => 'memory % swap', :desc => 'Swap usage, %', :metric => swap_fraction.round(2) * 100, :critical => 85, :warning => 75)
+  event(:service => 'memory abs free', :desc => 'Memory free (kB)', :metric => free, :state => 'ok')
+  event(:service => 'memory abs total', :desc => 'Memory total (kB)', :metric => total, :state => 'ok')
+  event(:service => 'memory abs cached', :desc => 'Memory usage, cached (kB)', :metric => cached, :state => 'ok')
+  event(:service => 'memory abs buffers', :desc => 'Memory usage, buffers (kB)', :metric => buffers, :state => 'ok')
+  event(:service => 'memory abs used', :desc => 'Memory usage, used (kB)', :metric => used, :state => 'ok')
+  event(:service => 'memory abs free_bc', :desc => 'Memory usage with cache and buffers (kB)', :metric => free_bc, :state => 'ok')
+end

data/examples/net.rb

@@ -0,0 +1,25 @@
+interval 60
+always_start true
+
+default[:include_alias] = false
+default[:filter] = [ 'rx bytes', 'rx errs', 'rx drop', 'tx bytes', 'tx errs', 'tx drop' ]
+default[:words] =  [ 'rx bytes', 'rx packets', 'rx errs', 'rx drop', 'rx fifo', 'rx frame',
+                    'rx compressed', 'rx multicast', 'tx bytes', 'tx packets', 'tx drops',
+                    'tx fifo', 'tx colls', 'tx carrier', 'tx compressed' ] 
+
+collect :os => "linux" do
+  File.read('/proc/net/dev').each_line do |line|
+    iface = line.split(':')[0].strip
+    iface.gsub!(/\./, '_')
+    next if (iface =~ /\./ && !plugin.include_alias)
+    next unless line =~ /(\w*)\:\s*([\s\d]+)\s*/
+    plugin.words.map do |service|
+      service
+    end.zip(
+      $2.split(/\s+/).map { |str| str.to_i }
+    ).each do |service, value|
+      next unless plugin.filter.include? service
+      event(:service => "net #{iface} #{service}", :metric => value.to_f/interval, :diff => true)
+    end
+  end
+end

data/examples/net_stat.rb

@@ -0,0 +1,25 @@
+interval 5
+default[:ports] = [80, 3994]
+
+collect do
+
+  filter = nil
+  plugin.ports.each do |port|
+    if filter == nil
+      filter = "\\( src *:#{port}"
+    else
+      filter += " or src *:#{port}"
+    end
+  end
+  filter += " \\) and not dst 127.0.0.1:*"
+  cmd    = 'ss -t -4 -n state established ' + filter + ' | wc -l'
+
+  count = shell!(cmd).to_i - 1
+
+  event(
+    :service     => "netstat tcp #{plugin.ports.join(', ')}",
+    :metric      => count,
+    :description => "count established connects: #{count} to ports #{plugin.ports.join(', ')}"
+  )
+
+end

data/examples/nfs.rb

@@ -0,0 +1,9 @@
+interval 60
+default[:file] = '/tmp/file'
+
+collect do
+  event(
+    :state => system("test -f #{file.file}"),
+    :desc => "Check file #{file.file}"
+  )
+end

data/examples/nginx.rb

@@ -0,0 +1,22 @@
+always_start true
+interval 60
+
+default[:file] = '/etc/nginx/sites-enabled/status'
+default[:url] = 'http://127.0.0.1:11311/status'
+default[:nginx_status_1] = %W(accepts handled requests)
+default[:nginx_status_2] = %W(reading writing waiting)
+
+run_if do
+  File.exists? plugin.file
+end
+
+collect :os => "linux" do
+  lines = http_get(plugin.url).split("\n")
+  lines[2].scan(/\d+/).each_with_index do |value, index|
+    event(:service => "nginx #{plugin.nginx_status_1[index]}", :metric => value.to_f/interval, :diff => true)
+  end
+  event(:service => 'nginx active', :metric => lines[0].split(':')[1].strip.to_i)
+  lines[3].scan(/\d+/).each_with_index do |value, index|
+    event(:service => "nginx #{plugin.nginx_status_2[index]}", :metric => value.to_i)
+  end
+end