reacter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78f3df07bc48af15f0de952a22a18e0ef37cec7d
+  data.tar.gz: e5269dca6726a6a13ff2caeb2ea637f32f35b4c2
+SHA512:
+  metadata.gz: 28b7fdd002e758c901dcf64968633c16b473a9517da311ef423eefce35fa3fa7c8975514980a00a702e2439f59efc13e156a308e24400c63c38f4ed16e526d80
+  data.tar.gz: 0042e5ec4cba2ec33bad8d3562b33058c20c0847cb3ce07aafc8628d575c0ba4617447fae6e75618dd39dcc7439aa7e736b1f69ebc5052ecb2bb3cb229b25c7f

data/lib/reacter.rb

@@ -0,0 +1 @@
+require 'reacter/core'

data/lib/reacter/adapter.rb

@@ -0,0 +1,61 @@
+#------------------------------------------------------------------------------#
+# Adapter
+#
+require 'reacter/message'
+require 'reacter/config'
+require 'reacter/util'
+
+class AdapterConnectionFailed < Exception; end
+class AdapterConnectionFaulted < Exception; end
+class AdapterConnectionClosed < Exception; end
+
+class Reacter
+  class Adapter
+    attr :config
+    attr :type
+
+    def initialize()
+      @config = Reacter.get('global.adapter', {})
+      @type = @config.get('type')
+      Util.info("Loading adapter #{@type}...")
+    end
+
+  # implement: connect to the data source
+    def connect(args={})
+      false
+    end
+
+  # implement: send a message suitable for consumption by an instance of reacter
+  #            in listen mode
+    def send(message)
+      false
+    end
+
+  # implement: poll for a new message and return it
+    def poll()
+      false
+    end
+
+  # implement: manual disconnect / cleanup
+    def disconnect()
+      raise AdapterConnectionClosed
+    end
+
+    class<<self
+      def create(type)
+        if type
+          begin
+            require "reacter/adapters/#{type}"
+            rv = (Reacter.const_get("#{type.capitalize}Adapter").new())
+            return rv
+
+          rescue LoadError
+            nil
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/reacter/adapters/amqp.rb

@@ -0,0 +1,45 @@
+#------------------------------------------------------------------------------#
+# AMQP Adapter
+#
+require 'reacter/adapter'
+require 'reacter/config'
+require 'reacter/util'
+
+class Reacter
+  class AmqpAdapter < Adapter
+    require 'amqp'
+
+    DEFAULT_QUEUENAME='reacter'
+
+    def connect(args={})
+      @_connection = AMQP.connect({
+        :host     => @config.get(:hostname, 'localhost'),
+        :port     => @config.get(:port, 5672),
+        :username => @config.get(:username, 'guest'),
+        :password => @config.get(:password, 'guest'),
+        :vhost    => @config.get(:vhost, '/')
+      })
+
+      @_channel  = AMQP::Channel.new(@_connection)
+      @_queue    = @_channel.queue(@config.get(:queue, DEFAULT_QUEUENAME), {
+        :auto_delete => @config.get(:autodelete, true)
+      })
+
+      @_exchange = @config.get(:exchange, '')
+    end
+
+    def send(message)
+      false
+    end
+
+    def poll(&block)
+      @_queue.bind(@_exchange).subscribe do |payload|
+        yield Message.parse(payload)
+      end
+    end
+
+    def disconnect()
+      raise AdapterConnectionClosed
+    end
+  end
+end

data/lib/reacter/adapters/file.rb

@@ -0,0 +1,39 @@
+#------------------------------------------------------------------------------#
+# Standard Input Adapter
+#
+require 'reacter/adapter'
+require 'reacter/config'
+require 'reacter/util'
+
+class Reacter
+  class FileAdapter < Adapter
+    def connect(args={})
+      if @config.get(:filename) == 'stdin'
+        @_stdin = true
+      else
+        @_stdin = false
+        @_input = File.open(File.expand_path(@config.get(:filename)), 'r+')
+      end
+    end
+
+    def send(message)
+      false
+    end
+
+    def poll(&block)
+      loop do
+        line = @_input.gets
+        yield Message.parse(line)
+      end
+    end
+
+    def disconnect()
+      raise AdapterConnectionClosed
+    end
+
+  private
+    def stdin?()
+      @_stdin
+    end
+  end
+end

data/lib/reacter/agent.rb

@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------#
+# Agent
+#
+require 'reacter/message'
+require 'reacter/config'
+require 'reacter/util'
+
+class Reacter
+  class Agent
+    attr :config
+    attr :type
+
+    def initialize()
+      @type = self.class.name.sub('Agent', '').split('::').last.downcase
+      @config = Reacter.get("agents.#{@type}", {})
+      Util.info("Loading agent #{@type}...")
+    end
+
+    def received(message)
+      false
+    end
+
+    class<<self
+      def create(type)
+        if type
+          begin
+            agentpath = Reacter['global.agents.path']
+            $: << File.expand_path(agentpath) if agentpath
+
+            require "reacter/agents/#{type}"
+            rv = (Reacter.const_get("#{type.capitalize}Agent").new())
+            return rv
+
+          rescue LoadError
+            nil
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/reacter/agents/decider.rb

@@ -0,0 +1,159 @@
+#------------------------------------------------------------------------------#
+# DeciderAgent
+#
+require 'reacter/agent'
+
+class Reacter
+  class DeciderAgent < Agent
+    class EmitAlert < Exception; end
+
+    STATES=[:okay, :warning, :critical]
+    COMPARISONS=%w{not is above below}
+
+    def initialize()
+      super
+
+      @_state_names = {}
+      STATES.each_index do |i|
+        @_state_names[STATES[i]] = i
+      end
+
+      @_alerts = {}
+    end
+
+    def received(message)
+    # early exit conditions
+      return false unless @config
+      return false unless @config['sources']
+      return false unless message.metric
+      unless message.source
+        return false unless @config['sources']['any']
+      end
+
+    # build effective configuration rule for this message
+      general = (@config['sources']['any'][message.metric] or {} rescue {})
+      specific = (@config['sources'][message.source][message.metric] or {} rescue {})
+      rule = specific.deep_merge!(general)
+
+    # quit early for empty rules
+      return false if rule.empty?
+
+    # quit early for invalid rules
+      return false unless (rule['threshold'] and rule['actions'])
+
+    # 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
+      })
+
+    # get current state of this message according to the rule
+      state, comparison = state_of(message, rule)
+
+      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
+          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
+          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
+          # 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
+            # only emit if this metric has ever failed
+              if @_alerts[message.source][message.metric][:has_ever_failed]
+                raise EmitAlert
+              end
+            end
+          end
+
+
+      rescue EmitAlert
+        message[:state] = state
+        message[:comparison] = comparison
+        message[:check_value] = (rule['threshold'][state][comparison] rescue nil)
+        message[:alerted_at] = Time.now.to_i
+
+        rv = message
+
+      # alert is emitted, it's not new anymore
+        @_alerts[message.source][message.metric][: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
+      end
+
+      return rv
+    end
+
+
+  private
+
+    def state_of(message, rule)
+      worst_state = 0
+      comparison = nil
+
+    # for each state, add all breached states
+      rule['threshold'].each do |state, check|
+        state = state.to_sym
+
+        check.each do |comp, test|
+          if compare(message.value, comp, test)
+          # this breached state is worse than what we've seen, make it the worst
+            if @_state_names[state] > worst_state
+              worst_state = @_state_names[state]
+              comparison = comp
+            end
+          end
+        end
+      end
+
+      return [STATES[worst_state], comparison]
+    end
+
+    def compare(value, comparison, test)
+      case comparison.to_sym
+      when :not
+        return (value != test)
+      when :is
+        return (value == test)
+      when :above
+        return (value > test)
+      when :below
+        return (value < test)
+      else
+        return false
+      end
+    end
+  end
+end
+
+
+# {"complements"=>"df-var.df_complex-used",
+#   "attributes"=>{
+#     "owner"=>"This Guy <tguy@outbrain.com>",
+#     "description"=>"",
+#     "neon"=>{"url"=>"http://localhost:5000/alert/new"}},
+#   "actions"=>{
+#     "exec"=>["~/Dropbox/Outbrain/reacter-notify"]},
+#   "threshold"=>{
+#     "warning"=>{
+#       "below"=>"5%"}}}

data/lib/reacter/agents/logger.rb

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

data/lib/reacter/config.rb

@@ -0,0 +1,81 @@
+class Reacter
+  class<<self
+    require 'yaml'
+
+    DEFAULT_CONFIG={
+      'global' => {
+        'searchpath' => ['~/.reacter', '/etc/reacter'],
+        'configs' => [
+          '~/.reacter/reacter.yaml',
+          '/etc/reacter/reacter.yaml'
+        ]
+      }
+    }
+
+    def load_config(config={})
+      @_config = DEFAULT_CONFIG
+      default_path = DEFAULT_CONFIG.get('global.configs')
+
+    # load from default paths
+      default_path.each do |path|
+        _load_file(path)
+      end
+
+    # load any supplemental configs
+      @_config.get('global.searchpath').each do |dir|
+      # adapters
+        adapter = @_config.get('global.adapter.type')
+        _load_file(File.join(dir, 'adapters', "#{adapter}.yaml")) if adapter
+
+      # agents
+        @_config.get('global.agents.enabled', []).each do |agent|
+          _load_file(File.join(dir, 'agents', "#{agent}.yaml"))
+        end
+      end
+
+    # load from any new paths that were loaded
+      (@_config.get('global.configs') - default_path).each do |path|
+        _load_file(path)
+      end
+
+      @_config = config.deep_merge!(@_config, {
+        :merge_hash_arrays => true
+      })
+    end
+
+    def [](key)
+      get(key)
+    end
+
+    def []=(key, value)
+      set(key, value)
+    end
+
+    def get(path, default=nil)
+      @_config.get(path, default)
+    end
+
+    def set(path, value)
+      @_config.set(path, value)
+    end
+
+    def dump_config()
+      @_config
+    end
+
+
+  private
+    def _load_file(path)
+      path = File.expand_path(path)
+
+      if File.exists?(path)
+        Util.info("Loading configuration #{path}...")
+        yaml = YAML.load(File.read(path))
+
+        @_config = yaml.deep_merge!(@_config, {
+          :merge_hash_arrays => true
+        })
+      end
+    end
+  end
+end

data/lib/reacter/core.rb

@@ -0,0 +1,102 @@
+require 'eventmachine'
+require 'deep_merge'
+require 'hashlib'
+require 'reacter/message'
+require 'reacter/config'
+require 'reacter/util'
+require 'reacter/adapter'
+require 'reacter/agent'
+
+class Reacter
+  class Core < EM::Connection
+    def initialize(*args)
+      super
+
+      @_dispatch_queue = EM::Queue.new
+      @_adapter = nil
+      @_agents = []
+
+      Reacter.load_config()
+
+      load_adapters()
+      load_agents()
+    end
+
+    def load_adapters()
+      adapter_config = Reacter.get('global.adapter', nil)
+
+      if adapter_config
+        type = adapter_config.get('type')
+
+        @_adapter = Adapter.create(type)
+
+        if @_adapter
+          @_adapter.connect()
+        else
+          raise "Adapter '#{type}' not found, exiting"
+          exit 1
+        end
+      else
+        Util.fatal("No adapters specified, exiting")
+        exit 1
+      end
+    end
+
+    def load_agents()
+      Reacter.get('global.agents.enabled', []).each do |agent|
+        agent = Agent.create(agent)
+        @_agents << agent if agent
+      end
+
+      if @_agents.empty?
+        Util.fatal("No agents enabled, exiting")
+        exit 1
+      end
+    end
+
+    def run()
+      Util.info("Start listening using #{@_adapter.type} adapter...")
+
+
+    # agent message dispatch subprocess
+      dispatch = proc do |messages|
+        messages.each do |message|
+          rv = message
+
+        # send this message to all agents
+          @_agents.each do |agent|
+            next if rv === false
+            rv = agent.received(rv)
+          end
+        end
+      end
+
+    # enter polling loop
+      begin
+        @_adapter.poll do |messages|
+          @_dispatch_queue.push(messages)
+          @_dispatch_queue.pop(dispatch)
+        end
+
+      rescue AdapterConnectionFailed => e
+        Util.error("Adapter connection failed: #{e.message}")
+
+      rescue AdapterConnectionFaulted => e
+        Util.error("Adapter connection error: #{e.message}")
+
+      rescue AdapterConnectionClosed => e
+        Util.info("Adapter closed connection")
+
+      end
+    end
+  end
+
+  class<<self
+    def start()
+      EM.run do
+        reacter = EM.connect('127.0.0.1', 9000, Reacter::Core)
+        reacter.run()
+      end
+    end
+  end
+end

data/lib/reacter/message.rb

@@ -0,0 +1,90 @@
+require 'reacter/util'
+require 'reacter/config'
+
+class Reacter
+  class Message
+    require 'hashlib'
+    DEFAULT_SOURCE_NAME='default'
+
+    def initialize(message={})
+      @_data = {
+        :raw        => message,
+        :time       => (Time.now.to_i * 1000),
+        :attributes => {},
+        :metric     => nil,
+        :source     => DEFAULT_SOURCE_NAME
+      }.merge(message)
+
+      if not @_data.has_key?(:event) and not @_data.has_key?(:value)
+        @_data[:event] = true
+      else
+        @_data[:event] = false
+      end
+    end
+
+    def to_h
+      @_data
+    end
+
+    def [](key)
+      @_data[key.to_sym]
+    end
+
+    def []=(key, value)
+      @_data[key.to_sym] = value
+    end
+
+    def method_missing(name, *args)
+      @_data[name.to_sym] or args.first
+    end
+
+    class<<self
+      def load_parsers()
+        unless defined?(@@_parsers)
+          @@_parsers = {}
+
+        # load and initialize parsers
+          Dir[File.join(File.dirname(__FILE__), 'parsers', '*.rb')].each do |i|
+            i = File.basename(i,'.rb')
+            require "reacter/parsers/#{i}"
+            @@_parsers[i.to_sym] = Message.const_get("#{i.capitalize}Parser")
+          end
+        end
+      end
+
+      def parse(body)
+        load_parsers()
+
+      # split strings into lines
+        body = body.lines if body.is_a?(String)
+        messages = []
+
+        if body.respond_to?(:each)
+          body.each do |message|
+          # strings need to be detected and parsed
+            if message.is_a?(String)
+              next if message.strip.chomp.empty?
+
+            # use first parser that claims it can handle this string
+              @@_parsers.each do |name, parser|
+                if parser.detected?(message)
+                  #Util.debug("Using parser #{name}")
+                  m = parser.parse(message)
+                  (m.is_a?(Array) ? messages += m : messages << m)
+                  next
+                end
+              end
+
+          # hashes go directly into the stack
+            elsif message.is_a?(Hash)
+              messages << message
+            end
+          end
+
+        end
+
+        messages.collect{|i| Message.new(i) }
+      end
+    end
+  end
+end

data/lib/reacter/parsers/collectd.rb

@@ -0,0 +1,28 @@
+require 'reacter/parsers/default'
+
+class Reacter
+  class Message
+    class CollectdParser < DefaultParser
+      class<<self
+        def detected?(message)
+          (message[0..6] == 'PUTVAL ')
+        end
+
+        def parse(message)
+          message = message.split(' ')
+          source, plugin, type = message[1].split('/')
+          attributes = Hash[message[2].split(';').collect{|i| i.split('=',2) }]
+          time, value = message[3].split(':')
+
+          {
+            :source     => source,
+            :metric     => [plugin, type].join('.'),
+            :time       => (time.to_i * 1000),
+            :value      => value.to_f,
+            :attributes => attributes
+          }
+        end
+      end
+    end
+  end
+end

data/lib/reacter/parsers/default.rb

@@ -0,0 +1,15 @@
+class Reacter
+  class Message
+    class DefaultParser
+      class<<self
+        def detected?(message)
+          false
+        end
+
+        def parse(message)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/reacter/parsers/graphite.rb

@@ -0,0 +1,26 @@
+require 'reacter/parsers/default'
+
+class Reacter
+  class Message
+    class GraphiteParser < DefaultParser
+      class<<self
+      # Graphite
+      #   |metric-----|value|epoch----|
+      # => metric.name 12345 123456789
+        def detected?(message)
+          (message =~ /^[\w\.]+ [\d\.\-]+ \d+$/ ? true : false)
+        end
+
+        def parse(message)
+          message = message.split(' ')
+
+          {
+            :metric     => message[0],
+            :value      => message[1].to_f,
+            :time       => (message[2].to_i * 1000)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/reacter/parsers/json.rb

@@ -0,0 +1,19 @@
+require 'reacter/parsers/default'
+
+class Reacter
+  class Message
+    class JsonParser < DefaultParser
+      class<<self
+        require 'json'
+
+        def detected?(message)
+          (message[0] == '{' or message[0] == '[')
+        end
+
+        def parse(message)
+          ([*JSON.load(message)] rescue [])
+        end
+      end
+    end
+  end
+end

data/lib/reacter/parsers/tsdb.rb

@@ -0,0 +1,24 @@
+require 'reacter/parsers/default'
+
+class Reacter
+  class Message
+    class TsdbParser < DefaultParser
+      class<<self
+        def detected?(message)
+          return (message.upcase[0..4] == 'PUT ')
+        end
+
+        def parse(message)
+          message = message.split(' ')
+
+          {
+            :metric     => message[1],
+            :time       => (message[2].to_i * 1000),
+            :value      => message[3].to_f,
+            :attributes => Hash[message[4..-1].collect{|i| i.split('=',2) }]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/reacter/util.rb

@@ -0,0 +1,38 @@
+require 'reacter/config'
+
+class Reacter
+  class Util
+    class<<self
+      require 'logger'
+
+      @@_logger = {
+        :default => Logger.new(STDOUT)
+      }
+
+      def log(message, severity=:info, log=:default)
+        @@_logger[log] = Logger.new(STDOUT) unless @@_logger[log]
+        @@_logger[log].send(severity, [*message].join(' '))
+      end
+
+      def info(message, log=:default)
+        log(message, :info, log)
+      end
+
+      def debug(message, log=:default)
+        log(message, :debug, log)
+      end
+
+      def warn(message, log=:default)
+        log(message, :warn, log)
+      end
+
+      def error(message, log=:default)
+        log(message, :error, log)
+      end
+
+      def fatal(message, log=:default)
+        log(message, :fatal, log)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: reacter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gary Hetzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A utility for consuming, transforming, and routing monitoring data from
+  various sources
+email: ghetzel@outbrain.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/reacter.rb
+- lib/reacter/adapter.rb
+- lib/reacter/adapters/amqp.rb
+- lib/reacter/adapters/file.rb
+- lib/reacter/agent.rb
+- lib/reacter/agents/decider.rb
+- lib/reacter/agents/logger.rb
+- lib/reacter/config.rb
+- lib/reacter/core.rb
+- lib/reacter/message.rb
+- lib/reacter/parsers/collectd.rb
+- lib/reacter/parsers/default.rb
+- lib/reacter/parsers/graphite.rb
+- lib/reacter/parsers/json.rb
+- lib/reacter/parsers/tsdb.rb
+- lib/reacter/util.rb
+homepage: http://outbrain.github.com/reacter/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Reacter monitoring processor
+test_files: []