redis_alerting 1.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDAxYmIwZDg4OWI1NzkxMWU3NjYwYTNhYjBhMDgyZWE4OGU4OTQ1Yg==
+  data.tar.gz: !binary |-
+    ODRlY2JlMTIyMzZiOWU5YTgwM2NlMjE4YjNlZGU2NGI3MDlkNmM2ZQ==
+SHA512:
+  metadata.gz: !binary |-
+    ODlkNjRiMTQ3MzE3MzUwYzU1ZTU2OWI5YzdkMjYyYzk0ZmI4OGQ3NWEyOGE1
+    NzRlNDM5YjA1NmU4MDkzNjQyN2E3ZWUzZDE4ZjIyYjI5Y2Q2OWIyMzQ0NTkx
+    NjE0ZmE3ZDZlYTVlMjZmMmI3MGI2YzIwYTE2NzE1ZTZiMTVhYTg=
+  data.tar.gz: !binary |-
+    MTg2YWNiODQyZTg4NzgwNTVkZGIzZTAzMDVjMDE2OGUyYTcwMWE3MjBiMjUy
+    MjlkM2M3Zjk5ZmEzOTkxOWRiYzY0ZmM3NDBkZmY1YTEyYWNkZjUwN2U5ZjZl
+    N2UyZjQ1ZTA2NTljMGZlNGI4MzQ0Y2Q5NGRhYmZkMWZmZDlhMTg=

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis-alerting.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Robert McLeod
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+# RedisAlerting
+
+An alerting engine that uses keys from redis to determine if a reading is out of range.  It then writes to a key in redis to indicate that the reading is out of range.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'redis_alerting'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis_alerting
+
+## Usage
+
+To start the engine:
+
+```sh
+redis-alerting start -- -c path/to/config.yml
+```
+
+Check the status:
+
+```sh
+redis-alerting status
+```
+
+Stop it:
+
+```sh
+redis-alerting stop
+```
+
+## How it works
+
+The gem uses specific key patterns to get the min and the max limits for a reading.
+
+Given the config file below we will describe how the gem would check some limits and write back to redis to inidicate an out of range state.
+
+```yaml
+---
+alerting:
+  :interval: 1              # how often to check the readings
+  :namespace: alerts        # where the min/max settings, and active alerts are located
+  :channel: alerts          # publish alert messages to this channel
+  :sources:                 # keys to obtain values from that need to be checked
+    :ph: readings.ph
+    :ec: readings.ec
+    :flow: readings.flow
+#   :name: redis.key.with.live.value
+```
+
+With the example of `ph` above, the alerting system would check the redis key `readings.ph` and determine if it was outside the limits set in `alerts.ph.max` and `alerts.ph.min`.
+
+When it finds that the value in `readings.ph` is outside the range, it will add "ph" to the redis set `alerts.active`.  When it comes back into range "ph" will be removed from the `alerts.active` set.
+
+So to quickly summarize:
+
+* `readings.ph` - the reading value used to check against the min and max settings
+* `alerts.ph.min` - the minimum value for the reading (below which an alert is raised)
+* `alerts.ph.max` - the maximum value for the reading (above which an alert is raised)
+* `alerts.active` - the Redis SET that contains the names of the active alerts (e.g. "ph", "ec" or "flow")
+
+### Published messages
+
+When an alert condition is added or removed, the following message will be published the channel specified in the config file in JSON format:
+
+So when an alert is raised, this message will be published:
+
+```json
+{
+  "action"   : "add",
+  "name"     : "ec",
+  "condition": "high",
+  "value"    : 6.2,
+  "min"      : 0.1,
+  "max"      : 5.8
+}
+```
+
+When an alert is no longer active, this message will be published:
+
+```json
+{
+  "action" : "remove",
+  "name"   : "flow",
+  "value"  : 2.4,
+  "min"    : 0.1,
+  "max"    : 5.8
+}
+```
+
+### Simple example
+
+With the engine started try this (still sticking with the keys in the config file above):
+
+```sh
+$ redis-cli
+127.0.0.1:6379> set alerts.ph.min 4000
+127.0.0.1:6379> set alerts.ph.max 9000
+127.0.0.1:6379> set readings.ph 6000
+127.0.0.1:6379> smembers alerts.active
+(empty list or set)
+127.0.0.1:6379> set readings.ph 9100
+127.0.0.1:6379> smembers alerts.active
+1) "ph"
+127.0.0.1:6379> set readings.ph 3900
+127.0.0.1:6379> smembers alerts.active
+1) "ph"
+127.0.0.1:6379> set readings.ph 6000
+127.0.0.1:6379> smembers alerts.active
+(empty list or set)
+```
+
+## Todo
+
+* more specs
+
+## Contributing
+
+1. Fork it ( https://github.com/AutogrowSystems/RedisAlerting/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.rspec_opts = "--color"
+  end
+
+  task :test => :spec
+rescue LoadError
+  # no rspec available
+end

data/bin/redis-alerting

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'redis_alerting'
+require 'slop'
+require 'daemons'
+
+daemon_opts = {
+  monitor: true,
+  multiple: false,
+  log_output: true,
+  log_dir: "/tmp"
+}
+
+slop_args = []
+
+# build the slop args custom because daemons gem overrides
+# ARGV and slop can't deal with it
+if ARGV.index("--")
+  slop_args = ARGV[(ARGV.index("--")+1)..-1]
+
+  # set the PWD
+  if slop_args.index("-p").nil?
+    slop_args << "-p"
+    slop_args << Dir.pwd
+  end
+end
+
+Daemons.run_proc("redis_alerting", daemon_opts ) do
+  opts = Slop.parse slop_args do
+    on :c, :config=, 'Configuration File'
+    on :p, :pwd=, "Working directory"
+  end
+
+  begin
+    RedisAlerting.run(opts.to_hash)
+  rescue ArgumentError => e
+    abort "ERROR: #{e.message}"
+  end
+end

data/etc/config.yml

@@ -0,0 +1,9 @@
+---
+alerting:
+  :interval: 1
+  :namespace: alerts
+  :channel: alerts
+  :sources:
+    :ph: readings.ph
+    :ec: readings.ec
+    :flow: readings.flow

data/lib/redis_alerting/config.rb

@@ -0,0 +1,35 @@
+module RedisAlerting
+  class Config
+    def initialize(opts)
+      @config = opts
+      parse_config
+    end
+
+    def to_hash
+      @config
+    end
+    
+    private
+
+    def parse_config
+      raise ArgumentError, "No config file specified" if @config[:config].nil?
+      
+      # automatically use a relative config path
+      if @config[:config][0] != "/"
+        @config[:config] = File.expand_path(@config[:config], @config[:pwd])
+      end
+
+      raise ArgumentError, "Invalid config file: #{@config[:config]}" unless File.exists? @config[:config]
+      
+      yaml = YAML.load_file(@config[:config])
+      @config.merge!(yaml["alerting"])
+
+      raise ArgumentError, "Incomplete configuration" unless valid_config?
+    end
+
+    # TODO: check we have all the needed options
+    def valid_config?
+      true
+    end
+  end
+end

data/lib/redis_alerting/engine.rb

@@ -0,0 +1,79 @@
+module RedisAlerting
+  class Engine
+    def initialize(config, redis)
+      @config = config
+      @active_set = "#{@config[:namespace]}.active"
+      @redis = redis
+      check_redis
+    end
+
+    def run
+      ns = @config[:namespace]
+      @config[:sources].each do |name, source|
+
+        # get the readings and alert ranges
+        min = @redis.get("#{ns}.#{name}.min").to_i
+        max = @redis.get("#{ns}.#{name}.max").to_i
+        value = @redis.get(source).to_i
+
+        # silently ignore
+        next if max.nil? or min.nil? or value.nil?
+
+        # check for alert conditions
+        if condition = out_of_range?(value, min, max)
+          add_alert_for(name, condition, value, min, max)
+          next
+        end
+
+        # if we got to here the alert conditions are not present anymore
+        # so we should remove the alert if it exists
+        remove_if_alert_exists name, value, min, max
+      end
+    end
+
+    private
+
+    def out_of_range?(value, min, max)
+      return :high if value > max
+      return :low if value < min
+      return false
+    end
+
+    def add_alert_for(name, condition, value, min, max)
+      return if @redis.sismember(@active_set, name)
+      @redis.sadd @active_set, name
+      
+      publish({
+        action: :add, 
+        name: name,
+        condition: condition,
+        value: value,
+        min: min,
+        max: max
+      })
+    end
+
+    def remove_if_alert_exists(name, value, min, max)
+      return unless @redis.sismember(@active_set, name)
+      @redis.srem @active_set, name
+      
+      publish({
+        action: :remove,
+        name: name,
+        value: value,
+        min: min,
+        max: max
+      })
+    end
+
+    def publish(message)
+      @redis.publish @config[:channel], message.to_json
+      puts "pushed message: #{message.inspect}"
+    end
+
+    def check_redis
+      raise ArgumentError, "Invalid Redis instance given" unless @redis.is_a? Redis
+      raise ArgumentError, "Could not connect to Redis" unless @redis.ping == "PONG"
+    end
+  end
+end

data/lib/redis_alerting/version.rb

@@ -0,0 +1,3 @@
+module RedisAlerting
+  VERSION = "1.1.1"
+end

data/lib/redis_alerting.rb

@@ -0,0 +1,20 @@
+require "redis_alerting/version"
+require "redis_alerting/engine"
+require "redis_alerting/config"
+require 'redis'
+require 'yaml'
+require 'json'
+
+module RedisAlerting
+  class << self
+    def run(opts)
+      config = RedisAlerting::Config.new(opts).to_hash
+      engine = RedisAlerting::Engine.new(config, ::Redis.new)
+
+      loop do
+        engine.run
+        sleep config[:interval]
+      end
+    end
+  end
+end

data/redis_alerting.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redis_alerting/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redis_alerting"
+  spec.version       = RedisAlerting::VERSION
+  spec.authors       = ["Robert McLeod"]
+  spec.email         = ["robert@autogrow.com"]
+  spec.summary       = %q{Checks redis for alert conditions}
+  spec.description   = %q{Checks redis for alert conditions and adds keys to a set when a value is round to be out of range}
+  spec.homepage      = "https://github.com/AutogrowSystems/RedisAlerting"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "redis"
+  spec.add_dependency "slop"
+  spec.add_dependency "daemons"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

data/spec/lib/redis_alerting/engine_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe RedisAlerting::Engine do
+  subject(:engine) { RedisAlerting::Engine.new(config, redis) }
+  let(:config)     { test_config }
+  let(:redis)      { ::Redis.new }
+  
+  before(:all) do
+    @r = Redis.new
+    @key = "ph"
+    @source = test_config[:sources][:ph]
+    @namespace = test_config[:namespace]
+  end
+
+  before(:each) do
+    @r.set "#{@namespace}.ph.min", 4000
+    @r.set "#{@namespace}.ph.max", 9000
+  end
+
+  after(:each) { @r.del @namespace }
+  
+  context "the reading is above the max limit" do
+    before(:each) { @r.set @source, 9100 }
+
+    it "should add the key to the set" do
+      engine.run
+      expect(redis.sismember(config[:namespace], "ph")).to be_truthy
+    end
+
+    it "should add the number of members in the set" do
+      expect {
+        engine.run
+      }.to change { redis.scard config[:namespace] }.by(1)
+    end
+  end
+
+  context "the reading is below the max limit" do
+    before(:each) { @r.set @source, 3900 }
+
+    it "should add the number of members in the set" do
+      expect {
+        engine.run
+      }.to change { redis.scard config[:namespace] }.by(1)
+    end
+
+    it "should add the key to the set" do
+      engine.run
+      expect(redis.sismember(config[:namespace], "ph")).to be_truthy
+    end
+  end
+
+  context "an alert exists" do
+    before(:each) { @r.sadd @namespace, "ph" }
+
+    context "and the reading comes back into range" do
+      before(:each) { @r.set @source, 6800 }
+
+      it "should remove the key from the set" do
+        engine.run
+        expect(redis.sismember(config[:namespace], "ph")).to be_falsey
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'redis'
+require 'pry'
+require 'redis_alerting'
+
+def test_config
+  {
+    namespace: "test.alerts",
+    sources: {
+      ph: "test.readings.ph"
+    }
+  }
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: redis_alerting
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Robert McLeod
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  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: slop
+  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: daemons
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Checks redis for alert conditions and adds keys to a set when a value
+  is round to be out of range
+email:
+- robert@autogrow.com
+executables:
+- redis-alerting
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/redis-alerting
+- etc/config.yml
+- lib/redis_alerting.rb
+- lib/redis_alerting/config.rb
+- lib/redis_alerting/engine.rb
+- lib/redis_alerting/version.rb
+- redis_alerting.gemspec
+- spec/lib/redis_alerting/engine_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/AutogrowSystems/RedisAlerting
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Checks redis for alert conditions
+test_files:
+- spec/lib/redis_alerting/engine_spec.rb
+- spec/spec_helper.rb