riemann-babbler 1.4.0 → 2.0.0pre1

data/lib/riemann/babbler/plugins/pgsql.rb

@@ -1,4 +1,4 @@
-class Riemann::Babbler::Pgsql < Riemann::Babbler
+class Riemann::Babbler::Plugin::Pgsql < Riemann::Babbler::Plugin
 
   def init
     plugin.set_default(:service, 'pgsql')
@@ -30,21 +30,21 @@ class Riemann::Babbler::Pgsql < Riemann::Babbler
 
   # connection to pg
   def connections
-    max_conn = run_sql("show max_connections").to_i
-    res_conn = run_sql("show superuser_reserved_connections").to_i
-    cur_conn = run_sql("select count(1) from pg_stat_activity;").to_i
+    max_conn = run_sql('show max_connections').to_i
+    res_conn = run_sql('show superuser_reserved_connections').to_i
+    cur_conn = run_sql('select count(1) from pg_stat_activity;').to_i
     [cur_conn, (max_conn - res_conn - cur_conn)]
   end
 
   def rep_lag_state
-    rep_lag = run_sql(plugin.rep_lag_sql).to_i
-    if rep_lag >= plugin.rep_lag_crit || rep_lag == 0
-      { :service => plugin.service + ' rep_lag', :description => "Postgresql replication lag state", :state => 'critical', :metric => rep_lag }
+    rep_lag = abs(run_sql(plugin.rep_lag_sql).to_i)
+    if rep_lag >= plugin.rep_lag_crit
+      { :service => plugin.service + ' rep_lag', :description => 'Postgresql replication lag state', :state => 'critical', :metric => rep_lag }
     elsif rep_lag >= plugin.rep_lag_warn
-      { :service => plugin.service + ' rep_lag', :description => "Postgresql replication lag state", :state => 'warning', :metric => rep_lag }
+      { :service => plugin.service + ' rep_lag', :description => 'Postgresql replication lag state', :state => 'warning', :metric => rep_lag }
     else
-      { :service => plugin.service + ' rep_lag', :description => "Postgresql replication lag state", :state => 'ok', :metric => rep_lag }
-    end    
+      { :service => plugin.service + ' rep_lag', :description => 'Postgresql replication lag state', :state => 'ok', :metric => rep_lag }
+    end
   end
 
   def collect
@@ -53,14 +53,14 @@ class Riemann::Babbler::Pgsql < Riemann::Babbler
     cur_conn, res_conn = connections
 
     status << rep_lag_state if in_recovery?
-    status << { :service => plugin.service + ' connections', :description => "Postgresql current connections", :state => 'ok', :metric => cur_conn }
+    status << { :service => plugin.service + ' connections', :description => 'Postgresql current connections', :state => 'ok', :metric => cur_conn }
 
     # check reserved pool size
     if res_conn < plugin.conn_warn
       if res_conn > plugin.conn_crit
-        status << { :service => plugin.service + ' reserved connections', :description => "Postgresql reserved connections state", :state => 'warning', :metric => res_conn }
+        status << { :service => plugin.service + ' reserved connections', :description => 'Postgresql reserved connections state', :state => 'warning', :metric => res_conn }
       else
-        status << { :service => plugin.service + ' reserved connections', :description => "Postgresql reserved connections state", :state => 'critical', :metric => res_conn }
+        status << { :service => plugin.service + ' reserved connections', :description => 'Postgresql reserved connections state', :state => 'critical', :metric => res_conn }
       end
     end
 

data/lib/riemann/babbler/plugins/runit.rb

@@ -1,10 +1,9 @@
-class Riemann::Babbler::Runit < Riemann::Babbler
+class Riemann::Babbler::Plugin::Runit < Riemann::Babbler::Plugin
 
   def init
     plugin.set_default(:service, 'runit')
-    plugin.set_default(:not_monit, ['riemann-client'])
+    plugin.set_default(:not_monit, %w(riemann-client))
     plugin.set_default(:interval, 60)
-
     @status_history = Array.new
   end
 
@@ -22,7 +21,7 @@ class Riemann::Babbler::Runit < Riemann::Babbler
   def runned?(service)
     stat_file = File.join(service, 'supervise', 'stat')
     return false unless File.exists?(stat_file)
-    File.read( stat_file ).strip == 'run'
+    File.read(stat_file).strip == 'run'
   end
 
   def human_srv(service)
@@ -40,12 +39,12 @@ class Riemann::Babbler::Runit < Riemann::Babbler
       next if not_monit?(srv)
       srv_uptime = uptime(srv)
       srv_runned = runned?(srv)
-      srv_name = human_srv(srv)
+      srv_name   = human_srv(srv)
 
       # сервис запущен и работает дольше чем мы приходили к нему в прошлый раз
       if srv_runned && srv_uptime > plugin.interval
         @status_history.delete(srv_name)
-        status << {:service => plugin.service + ' ' + srv_name , :state => 'ok', :description => "runit service #{srv_name} running", :metric => srv_uptime}
+        status << { :service => plugin.service + ' ' + srv_name, :state => 'ok', :description => "runit service #{srv_name} running", :metric => srv_uptime }
       else
         # сервис запущен но работает подозрительно мало, но последний раз замечен не был
         if srv_uptime < plugin.interval && srv_runned && !@status_history.include?(srv_name)
@@ -53,7 +52,7 @@ class Riemann::Babbler::Runit < Riemann::Babbler
           @status_history << srv_name
         else
           # во всех остальных случаях сообщаем о проблеме
-          status << {:service => plugin.service + ' ' + srv_name , :state => 'critical', :description => "runit service #{srv_name} not running", :metric => srv_uptime}
+          status << { :service => plugin.service + ' ' + srv_name, :state => 'critical', :description => "runit service #{srv_name} not running", :metric => srv_uptime }
         end
       end
 

data/lib/riemann/babbler/plugins/status_file.rb

@@ -1,4 +1,4 @@
-class Riemann::Babbler::StatusFile < Riemann::Babbler
+class Riemann::Babbler::Plugin::StatusFile < Riemann::Babbler::Plugin
 
   def init
     plugin.set_default(:service, 'check state file')
@@ -11,11 +11,11 @@ class Riemann::Babbler::StatusFile < Riemann::Babbler
 
   def collect
     return [] unless File.exists? plugin.file
-    content = File.read(plugin.file).split("\n").delete_if {|x| x.strip.empty? }
+    content = File.read(plugin.file).split("\n").delete_if { |x| x.strip.empty? }
     {
-        :service => plugin.service + " #{plugin.file}",
+        :service     => plugin.service + " #{plugin.file}",
         :description => content.last(plugin.report_lines).join("\n"),
-        :metric => content.count
+        :metric      => content.count
     }
   end
 

data/lib/riemann/babbler/plugins/tw_cli.rb

@@ -1,4 +1,4 @@
-class Riemann::Babbler::TwCli < Riemann::Babbler
+class Riemann::Babbler::Plugin::TwCli < Riemann::Babbler::Plugin
 
   def init
     plugin.set_default(:service, 'twcli')
@@ -12,10 +12,10 @@ class Riemann::Babbler::TwCli < Riemann::Babbler
   end
 
   def collect
-    { 
-      :service => plugin.service,
-      :metric => shell(plugin.cmd).to_i,
-      :description => 'Hardware raid tw_cli status'
+    {
+        :service     => plugin.service,
+        :metric      => shell(plugin.cmd).to_i,
+        :description => 'Hardware raid tw_cli status'
     }
   end
 

data/lib/riemann/babbler/responder.rb

@@ -0,0 +1,45 @@
+require 'net/http/server'
+require 'json'
+
+module Riemann
+  module Babbler
+
+    class Responder
+
+
+      include Riemann::Babbler::Logging
+      include Riemann::Babbler::Options
+
+      attr_accessor :port, :errors, :config, :started_at
+
+      def initialize
+        @port       = opts.riemann.responder_port
+        @started_at = Time.now.to_i
+        @errors     = opts.errors
+        @config     = opts.riemann
+      end
+
+      def info
+        {
+            :version => Riemann::Babbler::VERSION,
+            :ruby    => "#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}",
+            :uptime  => Time.now.to_i - started_at,
+            :errors  => errors.to_hash,
+            :config  => config.to_hash
+        }
+      end
+
+      def run!
+        Thread.new {
+          log :unknown, "Start responder 0.0.0.0:#{port}"
+          Net::HTTP::Server.run(:port => port) do |request, _|
+            log :debug, "Responder request: #{request}"
+            [200, { 'Content-Type' => 'application/json' }, [info.to_json]]
+          end
+        }
+      end
+    end
+
+  end
+end
+

data/lib/riemann/babbler/sender.rb

@@ -0,0 +1,102 @@
+require 'riemann/client'
+require 'resolv'
+require 'socket'
+
+module Riemann
+  module Babbler
+
+    class Sender
+
+      include Riemann::Babbler::Logging
+      include Riemann::Babbler::Options
+      include Riemann::Babbler::Errors
+
+      attr_accessor :sender
+
+      HOSTNAME_FILE = '/proc/sys/kernel/hostname'
+
+      def initialize
+        @sender   = build_riemann_client
+        @hostname = hostname
+      end
+
+      alias :r :sender
+
+      def build_riemann_client
+        @sender = Riemann::Client.new(
+            :host    => resolv(opts.riemann.host), #todo: add ttl
+            :port    => opts.riemann.port,
+            :timeout => opts.riemann.timeout
+        )
+        @sender = @sender.tcp if opts.riemann.tcp
+        connect_client(@sender)
+        @sender
+      end
+
+      #@return ipaddress of riemann server
+      def resolv(host)
+        begin
+          ip = Resolv.new.getaddress(host)
+          log :debug, "Resolv host: #{host} => #{ip}"
+        rescue
+          log :fatal, "Can't resolv hostname: #{host}"
+          exit Errors::RESOLV_RIEMANN_SERVER
+        end
+        ip
+      end
+
+      #@return connect to riemann
+      def connect_client(riemann)
+        begin
+          connect = @sender.connect
+          log :debug, "Connected to #{riemann.host}:#{riemann.port}"
+        rescue
+          log :fatal, "Can't connect to riemann server: #{riemann.host}:#{riemann.port}"
+          exit Errors::INIT_CONNECT
+        end
+        connect
+      end
+
+      def <<(event)
+        set_event_hostname(event)
+        set_event_tags(event)
+        log :debug, "Post event: #{event}"
+        send_with_rescue(event, opts.riemann.timeout)
+      end
+
+      def send_with_rescue(event, timeout)
+        begin
+          Timeout::timeout(timeout) {
+            @sender << event
+          }
+        rescue
+          log :fatal, "Connection problem with #{@sender.host}:#{@sender.port}, exit."
+          exit Errors::CONNECTION_PROBLEM
+        end
+      end
+
+      def set_event_tags(event)
+        unless opts.riemann.tags.nil?
+          event[:tags] = opts.riemann.tags unless event[:tags]
+        end
+      end
+
+      def set_event_hostname(event)
+        event[:host] = @hostname unless event[:host]
+      end
+
+      def hostname
+        if opts.riemann.fqdn
+          hostname = Socket.gethostbyname(Socket.gethostname).first
+          log :debug, "Get hostname from Socket.gethostname: #{hostname}"
+        else
+          hostname = File.read(HOSTNAME_FILE).strip.downcase if File.exist? HOSTNAME_FILE
+          log :debug, "Get hostname from #{HOSTNAME_FILE}: #{hostname}"
+        end
+        hostname
+      end
+
+    end
+
+  end
+end

data/lib/riemann/babbler/version.rb

@@ -1,5 +1,5 @@
 module Riemann
-  class Babbler
-    VERSION = '1.4.0'
+  module Babbler
+    VERSION = '2.0.0pre1'
   end
 end

data/lib/riemann/babbler.rb

@@ -1,175 +1,8 @@
-# encoding: utf-8
-
-require 'riemann/babbler/support/plugin_helpers'
-require 'riemann/client'
-require 'open3'
-require 'timeout'
-require 'rest_client'
-require 'socket'
-require 'net/ping'
-require 'file/tail'
-require 'riemann/babbler/support/monkey_patches'
-require 'riemann/babbler/support/errors'
-
-
-# Базовое описание плагина
-module Riemann
-  class Babbler
-
-    def self.registered_plugins
-      @plugins ||= []
-    end
-
-    def self.inherited( klass )
-      registered_plugins << klass
-    end
-
-    attr_reader :hostname, :has_last_error, :logger, :riemann, :has_last_error
-    alias :r :riemann
-
-    def initialize( configatron, logger, riemann )
-      @configatron = configatron
-      @logger = logger
-      @riemann = riemann
-      @storage = Hash.new
-      @hostname = get_hostname
-      @has_last_error = false
-      init
-      plugin.set_default(:interval, configatron.riemann.interval)
-    end
-
-    # Доступ к конфигу определенного плагина
-    def plugin
-      plugin_name = self.class.name.split('::').last.gsub( /(\p{Lower})(\p{Upper})/, "\\1_\\2" ).downcase
-      options.plugins.send plugin_name
-    end
-
-    def options
-      @configatron
-    end
-    alias :opts :options
-
-    def report(event)
-      report_with_diff(event) and return if event[:as_diff]
-      # если нет event[:state] то попробовать его добавить
-      unless event[:state]
-        event[:state] = state(event[:metric]) unless plugin.states.critical.nil?
-      end
-      event[:metric] = event[:metric].round(2) if event[:metric].kind_of? Float
-      # set tags
-      if event[:tags].nil?
-        event[:tags] = options.riemann.tags unless options.riemann.tags.nil?
-      end
-      # set host
-      event[:host] =  hostname if event[:host].nil?
-      logger.debug "Report status: #{event.inspect}"
-      riemann << event
-    end
-
-    def report_with_diff(event)
-      current_metric = event[:metric]
-      old_metric = @storage[event[:service]]
-      if old_metric && current_metric + old_metric < 2**64
-        event[:metric] = current_metric - old_metric
-        event.delete(:as_diff)
-        report(event)
-      end
-      @storage[event[:service]] = current_metric
-    end
-
-    def get_hostname
-      # разбор fqdn
-      if options.riemann.use_fqdn.nil? || options.riemann.use_fqdn == false
-        if File.exist? '/proc/sys/kernel/hostname'
-          hostname = File.read('/proc/sys/kernel/hostname').strip.downcase
-        else
-          hostname = `hostname`
-        end
-      else
-        hostname = Socket.gethostbyname(Socket.gethostname).first
-      end
-      # разбор инсталяции
-      if options.riemann.installation.nil?
-        hostname += options.riemann.suffix unless options.riemann.suffix.nil?
-      else
-        hostname += ( '.' + options.riemann.installation )
-      end
-      hostname = options.riemann.prefix + hostname unless options.riemann.prefix.nil?
-      hostname
-    end
-
-    # не запускаем плагин есть 
-    def run_plugin
-      if plugin.run.nil?
-        true
-      else
-        plugin.run ? true : false
-      end
-    end
-
-    # Переодически вызываемое действие
-    def tick
-      posted_array = collect
-      posted_array = posted_array.class == Array ? posted_array : [ posted_array ]
-      posted_array.uniq.each { |event| report event }
-    end
-
-    # Plugin init
-    def init
-    end
-
-    def run
-      # выйти если run_plugin не равен true
-      # error - текущая ошибка, @has_last_error - предыдущая
-      # две переменные для того что бы не удвоить сообщения об 'ОК'
-      return 0 unless run_plugin
-      error = false
-      t0 = Time.now
-      loop do
-
-        begin
-          Timeout::timeout( plugin.interval ) { tick }
-        rescue TimeoutError
-          report({:state => 'critical', :service => plugin.service + " plugin errors", :description => "Broken plugin: deadlock"})
-          logger.error("Plugin #{self.class.name} timed out!")
-          error = true
-        rescue Riemann::Babbler::PluginHelperError
-          logger.error("Plugin helper error!")
-          error = true
-        rescue => e
-          report({:state => 'critical', :service => plugin.service + " plugin errors", :description => "Plugin exception: #{e.class}\n #{e.backtrace.join "\n"}"})
-          logger.error("Plugin #{self.class.name} : #{e.class} #{e}\n#{e.backtrace.join "\n"}")
-          error = true
-        end
-
-        if (!error && @has_last_error)
-          report({:state => 'ok', :service => plugin.service + " plugin errors"})
-        end
-
-        @has_last_error = error
-        sleep(plugin.interval - ((Time.now - t0) % plugin.interval))
-      end
-
-    end
-
-    # хелпер, описание статуса
-    def state(my_state)
-      return 'critical' if my_state.nil?
-      if plugin.states.warning.nil?
-        my_state >= plugin.states.critical ? 'critical' : 'ok'
-      elsif plugin.states.critical.nil?
-        my_state >= plugin.states.warning ? 'warning' : 'ok'
-      else
-        case
-          when my_state.between?(plugin.states.warning, plugin.states.critical)
-            'warning'
-          when my_state > plugin.states.warning
-            'critical'
-          else
-            'ok'
-        end
-      end
-    end
-
-  end
-end
+require 'riemann/babbler/version'
+require 'riemann/babbler/options'
+require 'riemann/babbler/logging'
+require 'riemann/babbler/errors'
+require 'riemann/babbler/monkey_patches'
+require 'riemann/babbler/sender'
+require 'riemann/babbler/responder'
+require 'riemann/babbler/plugin_loader'

data/riemann-babbler.gemspec

@@ -1,29 +1,33 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/riemann/babbler/version', __FILE__)
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'riemann/babbler/version'
 
-Gem::Specification.new do |s|
-  s.name        = 'riemann-babbler'
-  s.version     = Riemann::Babbler::VERSION
-  s.authors     = ['Vasiliev D.V.']
-  s.email       = %w(vadv.mkn@gmail.com)
-  s.homepage    = 'https://github.com/vadv/riemann-babbler'
-  s.summary     = %q{Plugin manager for riemann.}
-  s.description = %q{Plugin manager for riemann.}
-  s.licenses    = %w(MIT)
-  
-  s.add_dependency('riemann-client')
-  s.add_dependency('configatron')
-  s.add_dependency('logger')
-  s.add_dependency('trollop')
-  s.add_dependency('sys-filesystem')
-  s.add_dependency('rest-client')
-  s.add_dependency('net-ping')
-  s.add_dependency('file-tail')
-  s.add_dependency('sys-proctable')
-  s.add_dependency('net-http-server')
+Gem::Specification.new do |spec|
+  spec.name        = 'riemann-babbler'
+  spec.version     = Riemann::Babbler::VERSION
+  spec.authors     = ['Vasiliev Dmitry']
+  spec.email       = ['vadv.mkn@gmail.com']
+  spec.description = %q{Monitoring tool for riemann}
+  spec.summary     = %q{Monitoring tool for riemann server, aka plugin manager}
+  spec.homepage    = 'https://github.com/vadv/riemann-babbler'
+  spec.license     = 'MIT'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = %w(lib)
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_dependency 'riemann-client'
+  spec.add_dependency 'trollop'
+  spec.add_dependency 'rest-client'
+  spec.add_dependency 'sys-filesystem'
+  spec.add_dependency 'docile'
+  spec.add_dependency 'configatron'
+  spec.add_dependency 'net-http-server'
+
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry'
 end