reacter 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78f3df07bc48af15f0de952a22a18e0ef37cec7d
-  data.tar.gz: e5269dca6726a6a13ff2caeb2ea637f32f35b4c2
+  metadata.gz: 85466ac92fce993fd08a3b321ac6080013cc0fba
+  data.tar.gz: 02b305a9c8195c60239e4801ab0507e7fd3748df
 SHA512:
-  metadata.gz: 28b7fdd002e758c901dcf64968633c16b473a9517da311ef423eefce35fa3fa7c8975514980a00a702e2439f59efc13e156a308e24400c63c38f4ed16e526d80
-  data.tar.gz: 0042e5ec4cba2ec33bad8d3562b33058c20c0847cb3ce07aafc8628d575c0ba4617447fae6e75618dd39dcc7439aa7e736b1f69ebc5052ecb2bb3cb229b25c7f
+  metadata.gz: 74fea13a574c9385fab7783b7d220c47acb692c4701123e093c518f0806e8e9c59e04c1502a84945359709f6d881f58cbd6bd193d0702fad12d4fffee1b302d4
+  data.tar.gz: 1eaeef3dc876f4b85f3e32dcb1700cfa91dffa76b35283c881c1e56e0f8407ec4c1caf73f4ebfcf9d84c61520ad15df4a2fb9dc9389e051320210373b4e14e46

data/bin/reacter

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+#
+# reacter - a utility for consuming, transforming, and routing monitoring data from various sources
+#
+# DESCRIPTION
+#        This script creates a mirror of a source directory, manipulating
+#        path components based on rules defined in dirmangle.yaml.  The
+#        purpose of this is to provide links to (or copies of) data using
+#        an alternative directory tree.
+#
+#        -C, --config FILE
+#                The location of the configuration YAML to load
+#
+#        -o, --option NAME VALUE
+#                Set the option NAME to VALUE
+#
+#        -v, --verbosity LEVEL
+#                Set the log verbosity level [debug, info (default), warn, error, fatal]
+#
+# AUTHOR
+#        Gary Hetzel <garyhetzel@gmail.com>
+#
+require 'reacter'
+require 'optparse'
+
+class Reacter
+  class CLI
+    class<<self
+      def run()
+        @options = {}
+
+        (OptionParser.new do |opts|
+          opts.banner = "Usage: reacter [options]"
+
+        # -----------------------------------------------------------------------------
+          opts.on('-C', '--config FILE', 'Configuration YAML location') do |file|
+            if File.exists?(file)
+              @options[:configfile] = file
+            else
+              raise "Configuration file #{file} does not exist"
+            end
+          end
+
+        # -----------------------------------------------------------------------------
+          @options[:options] = {}
+          opts.on('-o', '--option NAME=VALUE', 'Set the option NAME to VALUE') do |pair|
+            name, value = pair.split('=', 2)
+            @options[:options].set(name.strip.chomp, value) unless name.empty?
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-v', '--verbosity LEVEL', 'Logging verbosity') do |level|
+            level = level.to_s.downcase
+
+            if ['debug', 'info', 'warn', 'error', 'fatal'].include?(level)
+              @options[:loglevel] = level.to_sym
+            end
+          end
+        end).parse!
+
+      # options parsed, pass them to a new Reacter
+        Reacter.start(@options)
+      end
+    end
+  end
+end
+
+Reacter::CLI.run()

data/lib/reacter/adapter.rb

@@ -14,8 +14,8 @@ class Reacter
     attr :config
     attr :type
 
-    def initialize()
-      @config = Reacter.get('global.adapter', {})
+    def initialize(config=nil)
+      @config = (config || Reacter.get('global.adapter', {}))
       @type = @config.get('type')
       Util.info("Loading adapter #{@type}...")
     end
@@ -27,12 +27,12 @@ class Reacter
 
   # implement: send a message suitable for consumption by an instance of reacter
   #            in listen mode
-    def send(message)
+    def send(message, format=nil)
       false
     end
 
   # implement: poll for a new message and return it
-    def poll()
+    def poll(&block)
       false
     end
 
@@ -42,11 +42,11 @@ class Reacter
     end
 
     class<<self
-      def create(type)
+      def create(type, config=nil)
         if type
           begin
             require "reacter/adapters/#{type}"
-            rv = (Reacter.const_get("#{type.capitalize}Adapter").new())
+            rv = (Reacter.const_get("#{type.capitalize}Adapter").new(config))
             return rv
 
           rescue LoadError

data/lib/reacter/adapters/amqp.rb

@@ -28,7 +28,7 @@ class Reacter
       @_exchange = @config.get(:exchange, '')
     end
 
-    def send(message)
+    def send(message, format=nil)
       false
     end
 

data/lib/reacter/adapters/file.rb

@@ -12,18 +12,33 @@ class Reacter
         @_stdin = true
       else
         @_stdin = false
-        @_input = File.open(File.expand_path(@config.get(:filename)), 'r+')
+
+        readfile = (@config.get('filename') || @config.get('file.read'))
+        writefile = @config.get('file.write')
+
+        @_input = File.open(File.expand_path(readfile), 'r+') if readfile
+        @_output = File.open(File.expand_path(writefile), 'a') if writefile
       end
     end
 
-    def send(message)
-      false
+    def send(message, format=nil)
+      if defined?(@_output)
+        message = Message.dump(message, format)
+        @_output.puts(message) if message
+        @_output.flush()
+      else
+        Util.warn("file: Attempting to send without a valid output file handle")
+      end
     end
 
     def poll(&block)
-      loop do
-        line = @_input.gets
-        yield Message.parse(line)
+      if @_input
+        loop do
+          line = @_input.gets
+          yield Message.parse(line)
+        end
+      else
+        Util.warn("file: Attempting to poll without a valid input file handle")
       end
     end
 

data/lib/reacter/agents/decider.rb

@@ -7,8 +7,56 @@ class Reacter
   class DeciderAgent < Agent
     class EmitAlert < Exception; end
 
+  # local memory persistence mechanism for state tracking
+    class MemoryPersist
+      class<<self
+        def setup()
+          @_alerts = {}
+        end
+
+        def init(source, metric)
+        # initialize in-memory alert tracking (per source, per metric)
+          @_alerts[source] ||= {}
+          @_alerts[source][metric] ||= ({
+            :count           => 1,
+            :last_state      => nil,
+            :last_seen       => nil,
+            :new_alert       => false,
+            :has_ever_failed => false
+          })
+        end
+
+        def get(source, metric, key)
+          @_alerts[source][metric][key] rescue nil
+        end
+
+        def set(source, metric, key, value)
+          (@_alerts[source][metric][key] = value) rescue nil
+        end
+      end
+    end
+
+  # redis persistence mechanism for shared state tracking
+    class RedisPersist
+      #require 'redis'
+      class<<self
+        def setup()
+        end
+
+        def init(source, metric)
+        end
+
+        def get(source, metric, key)
+        end
+
+        def set(source, metric, key, value)
+        end
+      end
+    end
+
     STATES=[:okay, :warning, :critical]
     COMPARISONS=%w{not is above below}
+    DEFAULT_PERSISTENCE='memory'
 
     def initialize()
       super
@@ -18,7 +66,8 @@ class Reacter
         @_state_names[STATES[i]] = i
       end
 
-      @_alerts = {}
+      @_persistence = DeciderAgent.const_get(@config.get('options.persistence.type', DEFAULT_PERSISTENCE).capitalize+'Persist')
+      @_persistence.setup()
     end
 
     def received(message)
@@ -30,9 +79,12 @@ class Reacter
         return false unless @config['sources']['any']
       end
 
+      s = message.source
+      m = message.metric
+
     # build effective configuration rule for this message
-      general = (@config['sources']['any'][message.metric] or {} rescue {})
-      specific = (@config['sources'][message.source][message.metric] or {} rescue {})
+      general = (@config['sources']['any'][m] or {} rescue {})
+      specific = (@config['sources'][s][m] or {} rescue {})
       rule = specific.deep_merge!(general)
 
     # quit early for empty rules
@@ -41,18 +93,17 @@ class Reacter
     # quit early for invalid rules
       return false unless (rule['threshold'] and rule['actions'])
 
+    # passthrough mode
+    #   if in passthrough mode, all messages that are present in the configuration
+    #   will be passed regardless of state.  this is useful in conjunction with
+    #   the relay agent to offload the decision making to another reacter instance
+      return message if (@config['options'] and @config['options']['passthrough'])
+
     # default return value: false
       rv = false
 
-    # initialize in-memory alert tracking (per source, per metric)
-      @_alerts[message.source] ||= {}
-      @_alerts[message.source][message.metric] ||= ({
-        :count           => 1,
-        :last_state      => nil,
-        :last_seen       => nil,
-        :new_alert       => false,
-        :has_ever_failed => false
-      })
+    # initialize persistence for this source/metric
+      persist_init(s,m)
 
     # get current state of this message according to the rule
       state, comparison = state_of(message, rule)
@@ -60,24 +111,24 @@ class Reacter
       begin
         # a non-okay alert has occurred, this metric can now be said to have failed
           unless state == :okay
-            @_alerts[message.source][message.metric][:has_ever_failed] = true
+            persist_set(s,m, :has_ever_failed, true)
           end
 
         # the state has changed, reset counter
-          if @_alerts[message.source][message.metric][:last_state] != state
-            @_alerts[message.source][message.metric][:new_alert] = true
-            @_alerts[message.source][message.metric][:count] = 1
+          if persist_get(s,m, :last_state) != state
+            persist_set(s,m, :new_alert, true)
+            persist_set(s,m, :count, 1)
           end
 
           hits = ((rule['threshold'][state.to_s][hits] rescue rule['hits']) or rule['hits'] or 1).to_i
           persist = ((rule['threshold'][state.to_s]['persist'] === true) rescue false)
 
         # only raise every n alerts
-          if @_alerts[message.source][message.metric][:count] >= hits
+          if persist_get(s,m, :count) >= hits
           # raise the alert if it's new or if we're persistently reminding of alerts
-            if @_alerts[message.source][message.metric][:new_alert] or persist
+            if persist_get(s,m, :new_alert) or persist
             # only emit if this metric has ever failed
-              if @_alerts[message.source][message.metric][:has_ever_failed]
+              if persist_get(s,m, :has_ever_failed)
                 raise EmitAlert
               end
             end
@@ -93,12 +144,12 @@ class Reacter
         rv = message
 
       # alert is emitted, it's not new anymore
-        @_alerts[message.source][message.metric][:new_alert] = false
+        persist_set(s,m, :new_alert, false)
 
       ensure
-        @_alerts[message.source][message.metric][:count] += 1
-        @_alerts[message.source][message.metric][:last_state] = state
-        @_alerts[message.source][message.metric][:last_seen] = Time.now.to_i
+        persist_set(s,m, :count, persist_get(s,m, :count) + 1)
+        persist_set(s,m, :last_state, state)
+        persist_set(s,m, :last_seen, Time.now.to_i)
       end
 
       return rv
@@ -143,6 +194,18 @@ class Reacter
         return false
       end
     end
+
+    def persist_init(source, metric)
+      @_persistence.init(source, metric)
+    end
+
+    def persist_get(source, metric, key)
+      @_persistence.get(source, metric, key)
+    end
+
+    def persist_set(source, metric, key, value)
+      @_persistence.set(source, metric, key, value)
+    end
   end
 end
 

data/lib/reacter/agents/logger.rb

@@ -6,7 +6,8 @@ require 'reacter/agent'
 class Reacter
   class LoggerAgent < Agent
     def received(message)
-      Util.info("LOGGER: [#{message.state or :unknown}] #{message.source}/#{message.metric}")
+      Util.info("logger: [#{message.state or :unknown}] #{message.source}/#{message.metric}")
+      message
     end
   end
 end

data/lib/reacter/core.rb

@@ -16,7 +16,7 @@ class Reacter
       @_adapter = nil
       @_agents = []
 
-      Reacter.load_config()
+      Reacter.load_config(args.first || {})
 
       load_adapters()
       load_agents()
@@ -92,9 +92,9 @@ class Reacter
   end
 
   class<<self
-    def start()
+    def start(config={})
       EM.run do
-        reacter = EM.connect('127.0.0.1', 9000, Reacter::Core)
+        reacter = EM.connect('127.0.0.1', 9000, Reacter::Core, config[:options])
         reacter.run()
       end
     end

data/lib/reacter/message.rb

@@ -5,6 +5,7 @@ class Reacter
   class Message
     require 'hashlib'
     DEFAULT_SOURCE_NAME='default'
+    DEFAULT_FORMAT=:json
 
     def initialize(message={})
       @_data = {
@@ -52,6 +53,20 @@ class Reacter
         end
       end
 
+      def dump(message, format=nil)
+        load_parsers() unless defined?(@@_parsers)
+
+        if @@_parsers
+          format = DEFAULT_FORMAT unless format
+
+          if @@_parsers.has_key?(format.to_sym)
+            return @@_parsers[format.to_sym].dump(message)
+          end
+        end
+
+        return nil
+      end
+
       def parse(body)
         load_parsers()
 

data/lib/reacter/parsers/collectd.rb

@@ -22,6 +22,22 @@ class Reacter
             :attributes => attributes
           }
         end
+
+        def dump(message)
+          message = message.to_h if message.is_a?(Message)
+          return nil unless message.is_a?(Hash)
+          return nil unless message[:source]
+          return nil unless message[:metric]
+          return nil unless message[:value]
+          return nil unless message[:time]
+
+          ([
+            'PUTVAL',
+            "#{message[:source]}/#{message[:metric]}",
+            (message[:attributes] || {}).collect{|k,v| "#{k}=#{v}"}.join(';'),
+            "#{(message[:time] / 1000).to_i}:#{message[:value]}"
+          ].join(' ')).strip
+        end
       end
     end
   end

data/lib/reacter/parsers/default.rb

@@ -9,6 +9,10 @@ class Reacter
         def parse(message)
           nil
         end
+
+        def dump(message)
+          nil
+        end
       end
     end
   end

data/lib/reacter/parsers/graphite.rb

@@ -20,6 +20,17 @@ class Reacter
             :time       => (message[2].to_i * 1000)
           }
         end
+
+        def dump(message)
+          message = message.to_h if message.is_a?(Message)
+          return nil unless message.is_a?(Hash)
+          #return nil unless message[:source]
+          return nil unless message[:metric]
+          return nil unless message[:value]
+          return nil unless message[:time]
+
+          "#{message[:metric]} #{message[:value]} #{(message[:time] / 1000).to_i}".strip
+        end
       end
     end
   end

data/lib/reacter/parsers/json.rb

@@ -13,6 +13,12 @@ class Reacter
         def parse(message)
           ([*JSON.load(message)] rescue [])
         end
+
+        def dump(message)
+          message = message.to_h if message.is_a?(Message)
+          return nil unless message.is_a?(Hash)
+          JSON.dump(message)
+        end
       end
     end
   end

data/lib/reacter/parsers/tsdb.rb

@@ -18,6 +18,27 @@ class Reacter
             :attributes => Hash[message[4..-1].collect{|i| i.split('=',2) }]
           }
         end
+
+        def dump(message)
+          message = message.to_h if message.is_a?(Message)
+          return nil unless message.is_a?(Hash)
+          return nil unless message[:source]
+          return nil unless message[:metric]
+          return nil unless message[:value]
+          return nil unless message[:time]
+
+          attributes = {
+            :host => message[:source]
+          }.merge(message[:attributes] || {})
+
+          ([
+            'PUT',
+            message[:metric],
+            (message[:time] / 1000).to_i,
+            message[:value],
+            attributes.collect{|k,v| "#{k}=#{v}" }.join(' ')
+          ].join(' ')).strip
+        end
       end
     end
   end

data/lib/reacter/util.rb

@@ -4,11 +4,16 @@ class Reacter
   class Util
     class<<self
       require 'logger'
+      require 'socket'
 
       @@_logger = {
         :default => Logger.new(STDOUT)
       }
 
+      def signature(custom=nil)
+        [%x{hostname -f}, Process.pid, custom].compact.join(':')
+      end
+
       def log(message, severity=:info, log=:default)
         @@_logger[log] = Logger.new(STDOUT) unless @@_logger[log]
         @@_logger[log].send(severity, [*message].join(' '))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reacter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Gary Hetzel
@@ -55,7 +55,8 @@ dependencies:
 description: A utility for consuming, transforming, and routing monitoring data from
   various sources
 email: ghetzel@outbrain.com
-executables: []
+executables:
+- reacter
 extensions: []
 extra_rdoc_files: []
 files:
@@ -75,6 +76,7 @@ files:
 - lib/reacter/parsers/json.rb
 - lib/reacter/parsers/tsdb.rb
 - lib/reacter/util.rb
+- bin/reacter
 homepage: http://outbrain.github.com/reacter/
 licenses: []
 metadata: {}