riemann-babbler 2.1.5 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f58e1eb7094678ae29379799a5fc8b1af372ef29
-  data.tar.gz: b19cf01b3a8cc0703676932b42d6e8097cc3fef5
+  metadata.gz: d7dde4680673d2a1b6285938ac38b35b441a76a4
+  data.tar.gz: 3fcbaf886ab2039c512355c3c8137c52c384313c
 SHA512:
-  metadata.gz: 9df3a7c42860545236093a66b79e156d8df9a271d889148461a256d56e7d97ca8f00fd16e38b87a8ce6d8c7d889d2e30046d268b9829fedc4503866ac365e281
-  data.tar.gz: f483d97d7bc9aebdc8929c25fbbc38deb213acced0e0bff4f654ee5a92b0e1e58b62c66a4ea69e9dc3955e6e2cad5c8abe0931e522e2f5273b5bff83e6cbc6cc
+  metadata.gz: 905dcf97e58e7d31739f23c699dc11da2d78dc2a40d6f216a4649aa27f33a9c3c9fcac2b4169c8c737ad03642f15429ef33ea993ec016957450e731b21c8a459
+  data.tar.gz: 48003d96e5f612b8bc5fc402078a2e285891594a1aad3441d9018e8f1c485ec344b2c6b9122b2739e602ca9ee2dac08aaf0febd4e10786197931fed82f0a24ab

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    riemann-babbler (2.1.5)
+    riemann-babbler (2.5.0)
       configatron
       docile
       file-tail

data/bin/riemann-babbler

@@ -19,19 +19,17 @@ where [options] are:
   EOS
 
   opt :config, 'Config file', :default => '/etc/riemann-babbler/config.yml'
-  opt :host, 'Riemann host', :default => '127.0.0.1'
-  opt :port, 'Riemann port', :default => 5555
+  opt :host, 'Riemann server', :default => '127.0.0.1', :multi => true
+  opt :port, 'Riemann server default port', :default => 5555
+  opt :backlog, 'Riemann server backlog for events', :default => 100
   opt :timeout, 'Riemann timeout', :default => 5
-  #todo: opt :event_hostname, 'Event hostname', :type => String
   opt :fqdn, 'Use fqdn for event hostname', :default => true
   opt :ttl, 'TTL for events', :default => 60
   opt :interval, 'Seconds between updates', :default => 60
   opt :log_level, 'Level log', :default => 'DEBUG'
-  #todo: opt :log_output, 'Directions to puts your log', :default => STDOUT
-  #todo: opt :log_format, 'Log format', :default => '%Y-%m-%d %H:%M:%S'
-  opt :plugins_directory, 'Directory for plugins', :default => '/usr/share/riemann-babbler/plugins'
+  opt :plugins_directory, 'Directory for plugins', :short => '-d', :default => '/usr/share/riemann-babbler/plugins'
   opt :tcp, 'Use TCP transport instead of UDP (improves reliability, slight overhead.', :default => true
-  opt :minimize_event_count, 'Minimize count of sent messages', :default => true
+  opt :minimize_event_count, 'Minimize count of sent messages', :short => '-m', :default => true
   opt :responder_bind_http, 'Bind to http responder', :default => '0.0.0.0:55755'
   opt :responder_bind_udp, 'Bind to udp responder', :default => '0.0.0.0:55955'
 end

data/lib/riemann/babbler/plugin_manager.rb

@@ -5,6 +5,8 @@ module Riemann
       include Riemann::Babbler::Logging
       include Riemann::Babbler::Errors
 
+      CHECK_ALIVE_PLUGINS = 10
+
       def initialize(sender, array_of_klasses)
         @plugins = array_of_klasses
         @sender  = sender
@@ -12,7 +14,6 @@ module Riemann
       end
 
       def run!
-
         @plugins.map do |plugin|
           unless plugin.new(@sender).send(:run_plugin)
             log :unknown, "Disable plugin: #{plugin}, because it not started by condition: run_plugin"
@@ -20,13 +21,14 @@ module Riemann
           end
           @mapping[plugin] = run_thread(plugin)
         end
-
         loop do
           check_alive
-          sleep 10
+          sleep CHECK_ALIVE_PLUGINS
         end
       end
 
+      private
+
       def run_thread(plugin)
         Thread.new {
           log :unknown, "Start plugin #{plugin}"
@@ -52,4 +54,4 @@ module Riemann
 
     end
   end
-end
+end

data/lib/riemann/babbler/sender.rb

@@ -1,6 +1,4 @@
-require 'riemann/client'
-require 'resolv'
-require 'socket'
+require_relative 'sender_client'
 
 module Riemann
   module Babbler
@@ -11,68 +9,41 @@ module Riemann
       include Riemann::Babbler::Options
       include Riemann::Babbler::Errors
 
-      attr_accessor :sender
-
       HOSTNAME_FILE = '/proc/sys/kernel/hostname'
+      CHECK_CLIENT_ALIVE = 10
 
       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
+        @riemanns = create_riemanns
+        start
       end
 
       def <<(event)
         set_event_hostname(event)
         set_event_tags(event)
-        log :debug, "Post event: #{event}"
-        send_with_rescue(event, opts.riemann.timeout)
+        @riemanns.each {|r| r << event }
       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
+      private
+
+      def start
+        Thread.new do
+          loop do
+            @riemanns.each do |r|
+              next if r.alive?
+              log :error, "Riemann client #{r.host}:#{r.port} is died, up it"
+              r.start
+            end
+            log :debug, "Check alive of riemann client [#{@riemanns.count}]"
+            sleep CHECK_CLIENT_ALIVE
+          end
+        end  
+      end
+
+      def create_riemanns
+        riemanns = Array.new
+        opts.riemann.host.each { |host| riemanns << Riemann::Babbler::Sender::Client.new(host) }
+        riemanns
       end
 
       def set_event_tags(event)

data/lib/riemann/babbler/sender_client.rb

@@ -0,0 +1,104 @@
+require 'riemann/client'
+require 'resolv'
+require 'socket'
+
+module Riemann
+  module Babbler
+    class Sender
+      class Client
+
+        include Riemann::Babbler::Logging
+        include Riemann::Babbler::Options
+        include Riemann::Babbler::Errors
+
+        INTERVAL_FLUSH = 0.1
+
+        attr_accessor :host, :port, :events
+
+        def initialize(host)
+          @host, @port   = host.split(':')
+          @port ||= opts.riemann.port
+          @events = Array.new
+          @riemann = client
+          start
+        end
+
+        def start
+          @running = true
+          @runner = Thread.new do
+            while @running
+              sleep INTERVAL_FLUSH
+              flush
+            end
+            @runner = nil
+          end
+        end
+
+        def stop
+          @running = false
+        end
+
+        def alive?
+          @runner.nil? || @runner.alive?
+        end
+
+        def <<(event)
+          @events.shift if @events.size < opts.riemann.backlog
+          @events << event
+        end
+
+        private
+
+        # flush events
+        def flush
+          return nil if @events.empty?
+          while @events.size > 0
+            event = @events[0]
+            log :debug, "Post event via #{@host}:#{@port} : #{event.inspect}"
+            Timeout::timeout(opts.riemann.timeout) {
+              @riemann << event
+            }
+            @events.shift
+          end
+        end
+
+        # riemann client connect
+        def client
+          sender = Riemann::Client.new(
+            :host    => resolv(@host), #todo: add ttl
+            :port    => @port,
+            :timeout => opts.riemann.timeout
+          )
+          sender = sender.tcp if opts.riemann.tcp
+          connect_client(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)
+          connect = riemann
+          begin
+            connect = riemann.connect if opts.riemann.tcp
+            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
+
+      end
+    end
+  end
+end

data/lib/riemann/babbler/version.rb

@@ -1,5 +1,5 @@
 module Riemann
   module Babbler
-    VERSION = '2.1.5'
+    VERSION = '2.5.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riemann-babbler
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.5.0
 platform: ruby
 authors:
 - Vasiliev Dmitry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-26 00:00:00.000000000 Z
+date: 2013-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riemann-client
@@ -276,6 +276,7 @@ files:
 - lib/riemann/babbler/plugins/status_file.rb
 - lib/riemann/babbler/plugins/tw_cli.rb
 - lib/riemann/babbler/sender.rb
+- lib/riemann/babbler/sender_client.rb
 - lib/riemann/babbler/version.rb
 - riemann-babbler.gemspec
 - test/default_spec.rb