malevich 0.0.1

data/lib/malevich/monitor.rb

@@ -0,0 +1,40 @@
+module Malevich
+  class Monitor
+
+    CHECK_ALIVE = 5
+
+    attr_reader :tasks
+
+    def initialize
+      @tasks = Array.new
+    end
+
+    def plugins
+      @tasks.select {|t| t[1].is_a?(Malevich::Plugin) }.map {|x| {x[1].name => x[1].settings.to_hash} }
+    end
+
+    def <<(obj)
+      return false unless obj.respond_to?(:name) || obj.respond_to?(:run!)
+      th = Thread.new do
+        obj.run!
+      end
+      log :info, "Add '#{obj.class}(#{obj.name})'"
+      @tasks << [th, obj]
+    end
+
+    def run!
+      loop do
+        @tasks.each_with_index do |task, i|
+          next if task[0].alive?
+          # start new thread
+          log :error, "Thread for '#{task[1].class}(#{task[1].name})' is dead, start it"
+          @tasks.delete_at(i)
+          self << task[1]
+        end
+        log :debug, "Check alive #{@tasks.count} threads"
+        sleep CHECK_ALIVE
+      end
+    end
+
+  end
+end

data/lib/malevich/plugin.rb

@@ -0,0 +1,70 @@
+require_relative 'plugin/init'
+
+module Malevich
+  class Plugin
+
+    include Malevich::PluginHelpers
+
+    attr_accessor :name, :always_start, :interval,
+                  :run_if, :collect, :settings, :histories, :errors
+
+    alias :plugin :settings
+
+    def initialize(name)
+      @name         = name
+      @interval     = 60
+      @run_if       = Proc.new { true }
+      @always_start = false
+    end
+
+    def suitable_platform?(name)
+      platforms = name.nil? || name.empty? ? ['linux'] : name
+      platforms.include?(ohai[:platform]) || platforms.include?(ohai[:os])
+    end
+
+    def runnable?
+      def log_and_false(level = :info, msg)
+        log level, msg
+        false
+      end
+      return log_and_false("'#{name}' not started, because have not 'collect'") if collect.nil?
+      return log_and_false("'#{name}' disabled in config") if settings.disable? && settings.disable
+      return log_and_false("'#{name} disabled by run_if statement'") unless !!self.instance_eval(&run_if)
+      log :unknown, "'#{name}' started"
+    end
+
+    def run!
+      loop do
+        t_start = Time.now
+        begin
+          Timeout.timeout(interval.to_f * 2/3) do
+            self.instance_eval(&collect)
+          end
+        rescue => e
+          error(e)
+        end
+        sleep(interval - (Time.now - t_start).to_i)
+      end
+    end
+
+    private
+
+    def ohai
+      malevich.ohai
+    end
+
+    def self.make_container(container)
+      define_method(container) do |&block|
+        malevich.plugins[container]            ||= {}
+        malevich.plugins[container][self.name] ||= Hashie::Mash.new
+        malevich.plugins[container][self.name]
+      end
+    end
+
+    make_container :settings
+    alias :plugin :settings
+    make_container :histories
+    make_container :errors
+
+  end
+end

data/lib/malevich/plugin/error.rb

@@ -0,0 +1,12 @@
+module Malevich
+  module PluginHelpers
+
+    def error(e)
+      errors.last_at  = Time.now
+      errors.msg      = "#{e.class}: #{e}\n #{e.backtrace.join("\n")}"
+      errors.reported = false
+      log :error, "Plugin '#{name}' has a error: #{e.class}: #{e}\n #{e.backtrace.join("\n")}"
+    end
+
+  end
+end

data/lib/malevich/plugin/event.rb

@@ -0,0 +1,68 @@
+module Malevich
+  module PluginHelpers
+
+    def event(hash)
+      event_normalize(hash)
+      hash[:metric] = metric_diff(hash) if hash[:diff]
+      hash[:state]  = state_check(hash)
+      if malevich.cmd[:test_given]
+        log :unknown, "Event message from test plugin: #{hash.inspect}"
+      else
+        event_minimizer(hash)
+      end
+    end
+
+    def metric_diff(hash)
+      return unless hash[:metric]
+      current_metric          = hash[:metric]
+      old_metric              = histories[hash[:service]]
+      histories[hash[:service]] = current_metric
+      hash.delete(:diff)
+      old_metric ? current_metric - old_metric : nil
+    end
+
+    def state_check(hash)
+      return hash[:state] if hash[:state]
+      return hash[:state] if hash[:metric].nil?
+      return hash[:state] if hash[:metric].kind_of?(Float) && hash[:metric].nan?
+      warning  = settings.respond_to?(:warning) ? settings.warning : nil
+      critical = settings.respond_to?(:critical) ? settings.critical : nil
+      return 'ok' if (warning || critical).nil?
+      metric = hash[:metric].to_f
+      if warning && critical
+        return case
+                 when metric.between?(warning, critical)
+                   'warning'
+                 when metric > warning
+                   'critical'
+                 else
+                   'ok'
+               end
+      end
+      if warning
+        return (metric >= warning) ? 'warning' : 'ok'
+      end
+      if critical
+        return (metric >= critical) ? 'critical' : 'ok'
+      end
+      'critical'
+    end
+
+    def event_normalize(hash)
+      hash[:metric]  = hash[:metric].round(2) if hash[:metric].kind_of?(Float)
+      hash[:state]   = 'ok' if hash[:state].kind_of?(TrueClass)
+      hash[:state]   = 'critical' if hash[:state].kind_of?(FalseClass)
+      hash[:service] ||= name
+      hash[:host]    ||= ohai[:fqdn]
+      hash[:tags]    ||= malevich.cmd.tags
+    end
+
+    def event_minimizer(hash)
+      return if hash[:state] == 'ok' && hash[:metric].nil? && histories[hash[:service]] &&
+          histories[hash[:service]][:state] == 'ok'
+      histories[hash[:service]] = hash
+      malevich.events << hash
+    end
+
+  end
+end

data/lib/malevich/plugin/http.rb

@@ -0,0 +1,25 @@
+require 'rest_client'
+require 'uri'
+require 'open-uri'
+
+module Malevich
+  module PluginHelpers
+
+    def http_get(url)
+      RestClient.get(url)
+    end
+    alias :rest_get :http_get
+
+    def body_get(url)
+      case URI.parse(url).scheme
+        when 'http', 'https'
+          http_get(url)
+        when 'file'
+          raise "body_get('#{url}'): hasn't support yet"
+        else
+          File.read(url)
+      end
+    end
+
+  end
+end

data/lib/malevich/plugin/init.rb

@@ -0,0 +1,5 @@
+require_relative 'shell_out'
+require_relative 'http'
+require_relative 'time'
+require_relative 'event'
+require_relative 'error'

data/lib/malevich/plugin/shell_out.rb

@@ -0,0 +1,28 @@
+require 'mixlib/shellout'
+
+module Malevich
+  module PluginHelpers
+
+    def shell_out(*command_args)
+      cmd             = Mixlib::ShellOut.new(*command_args)
+      #cmd.live_stream = STDOUT if STDOUT.tty?
+      cmd.run_command
+      cmd
+    end
+
+    def shell_out!(*command_args)
+      cmd= shell_out(*command_args)
+      cmd.error!
+      cmd
+    end
+
+    def shell(*command_args)
+      shell_out(*command_args).stdout
+    end
+
+    def shell!(*command_args)
+      shell_out!(*command_args).stdout
+    end
+
+  end
+end

data/lib/malevich/plugin/time.rb

@@ -0,0 +1,9 @@
+module Malevich
+  module PluginHelpers
+
+    def unixnow
+      Time.now.to_i
+    end
+
+  end
+end

data/lib/malevich/responders/error.rb

@@ -0,0 +1,30 @@
+module Malevich
+  module Responder
+    class Error
+
+      attr_reader :name
+
+      def initialize
+        @name = 'plugin error responder'
+      end
+
+      def run!
+        loop do
+          if malevich.plugins.errors
+            errors = 0
+            malevich.plugins.errors.each { |_, val| errors += 1 unless val.reported? }
+            if errors == 0
+              malevich.events << {:service => 'plugins errors', :state => 'ok'}
+            else
+              malevich.events << {:service => 'plugin errors', :metric => errors,
+                                  :description => "Plugins has errors \n #{malevich.plugins.errors}"}
+              malevich.plugins.errors.each { |_, val| val.reported = true unless val.reported? }
+            end
+          end
+          sleep 60
+        end
+      end
+
+    end
+  end
+end

data/lib/malevich/responders/http.rb

@@ -0,0 +1,46 @@
+module Malevich
+  module Responder
+    class Http
+
+      attr_reader :name
+
+      def initialize
+        @host, @port = malevich.cmd['http-responder'].split(':')
+        @started_at = Time.now.to_i
+        @name = 'http api'
+      end
+
+      def run!
+        log :unknown, "Start http server at #{@host}:#{@port}"
+        server = TCPServer.new(@host, @port)
+        loop do
+          client = server.accept
+          log :unknown, "Accepted client: #{client.inspect}"
+          response = info
+          headers = "HTTP/1.1 200 OK\r\n" +
+              "Server: Malevich Ruby\r\n" +
+              "Content-Length: #{response.bytesize}\r\n" +
+              "Content-Type: application/json\r\n\r\n"
+          client.print headers
+          client.print response
+          client.close
+        end
+      end
+
+      def info
+        {
+          :cmd => malevich.cmd,
+          :config => malevich.config,
+          :plugins => malevich.monitor.plugins,
+          :monitor => malevich.monitor.tasks.map {|x| { x[1].name => x[0].alive? } },
+          :errors => (malevich.plugins.errors rescue {}),
+          :version => Malevich::VERSION,
+          :ruby => "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}",
+          :uptime => Time.now.to_i - @started_at,
+          :queue_size => malevich.events.size
+        }.to_json + "\n"
+      end
+
+    end
+  end
+end

data/lib/malevich/responders/init.rb

@@ -0,0 +1,4 @@
+require_relative 'riemann'
+require_relative 'http'
+require_relative 'udp'
+require_relative 'error'

data/lib/malevich/responders/riemann.rb

@@ -0,0 +1,59 @@
+require 'riemann/client'
+require 'resolv'
+
+module Malevich
+  module Responder
+    class Riemann
+
+      INTERVAL_FLUSH = 0.5
+
+      attr_reader :name
+
+      def initialize
+        @riemanns = Array.new
+        @name = "riemann client"
+      end
+
+      def run!
+        make_clients
+        loop do
+          flush
+          sleep INTERVAL_FLUSH
+        end
+      end
+
+      private
+
+      def make_clients
+        @riemanns.clear
+        malevich.cmd['riemann-host'].each do |host|
+          riemann, port = host.split(':')
+          port ||= 5555
+          client = ::Riemann::Client.new({
+                                           :host => Resolv.new.getaddress(riemann),
+                                           :port => port,
+                                           :timeout => 10
+                                       })
+          client = client.tcp if malevich.cmd['riemann-tcp']
+          log :debug, "Add new riemann client: #{client.host}:#{client.port}"
+          @riemanns << client
+          @name = @riemanns.map {|c| "riemann client [#{c.host}:#{c.port}]" }.join(" , ")
+        end
+        @riemanns
+      end
+
+      def flush
+        until malevich.events.empty?
+          event = malevich.events.pop
+          @riemanns.each do |riemann|
+            Timeout::timeout(10) {
+              log :debug, "Sent message #{event} for #{riemann.host}:#{riemann.port}"
+              riemann << event
+            }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/malevich/responders/udp.rb

@@ -0,0 +1,59 @@
+require 'socket'
+
+module Malevich
+  module Responder
+    class Udp
+
+      RIEMANN_RESERVED_FIELDS = [
+          :time,
+          :state,
+          :service,
+          :host,
+          :description,
+          :metric,
+          :tags,
+          :ttl
+      ]
+
+      attr_reader :name
+
+      def initialize
+        @host, @port = malevich.cmd['udp-responder'].split(':')
+        @name = 'udp api'
+      end
+
+      def process(data, src)
+        begin
+          malevich.events << event_from_json(data)
+          src.reply "sended\n\n"
+        rescue
+          log :error, "Failed to send message: #{data.inspect}"
+          src.reply "failed to send: #{data.inspect}\n"
+        end
+      end
+
+      def event_from_hash(hash=nil)
+        new_hash = Hash.new
+        RIEMANN_RESERVED_FIELDS.each do |key|
+          new_hash[key] = hash[key] || hash[key.to_s]
+        end
+        new_hash[:host] ||= malevich.ohai[:fqdn]
+        new_hash[:tags] ||= malevich.cmd.tags
+        new_hash
+      end
+
+      def event_from_json(str)
+        event_from_hash(JSON.parse(str))
+      end
+
+      def run!
+        log :unknown, "Start udp server at #{@host}:#{@port}"
+        Socket.udp_server_loop(@host, @port) do |data, src|
+          log :debug, "Received data: #{data.inspect}, from client: #{src.inspect}"
+          process(data, src)
+        end
+      end
+
+    end
+  end
+end