check 0.2.0

data/lib/check/api/metrics.rb

@@ -0,0 +1,64 @@
+require_relative '../../check/metric'
+
+require 'grape'
+
+module Check
+  class Metrics < Grape::API
+    default_format :json
+    error_format :json
+    format :json
+
+    helpers do
+      # We'll do pretty some other time, promise!
+      def metric_params
+        params.inject({}) do |result, (k, v)|
+          unless (k == "route_info")
+            typecast_value = if v.match(/^\d+$/)
+              v.to_i
+            elsif v.index(',')
+              v.split(',')
+            else
+              v
+            end
+            result[k.to_sym] = typecast_value
+          end
+          result
+        end
+      end
+    end
+
+    resources :metrics do
+      desc 'Create metric check'
+      post '/' do
+        metric_check = Metric.new(metric_params).save
+
+        if metric_check.valid?
+          [metric_check.name]
+        else
+          error!({:errors => metric_check.errors}, 409)
+        end
+      end
+
+      desc 'Delete specific metric check'
+      delete '/' do
+        Metric.find(metric_params).delete
+      end
+
+      desc 'Delete all matching metric checks'
+      delete '/:name' do
+        Metric.delete_all(params[:name])
+      end
+
+      desc 'List all matching metric checks'
+      get '/:name' do
+        metric_check = Metric.find(metric_params)
+
+        if metric_check.persisted?
+          metric_check.similar.to_json
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/check/metric.rb

@@ -0,0 +1,225 @@
+require_relative '../check'
+
+require 'hashr'
+require 'redis/set'
+require 'redis/list'
+require 'redis/value'
+require 'msgpack'
+
+module Check
+  class Metric < Hashr
+    # If you really want to overwrite the defaults completely, inherit this
+    # class and re-define self.defaults.  Don't forget to invoke the define
+    # method with the new defaults as this is Hashr's way of defining the hash
+    # blueprint.
+    #
+    # It would be interesting to go further with positives and categorize them
+    # as consistent (>50% matches are lower or higher) or fluctuating (50/50).
+    #
+    def self.defaults
+      {
+        lower: 1,
+        upper: 10,
+        matches_for_positive: 2,
+        over_seconds: 60,
+        suspend_after_positives: 1,
+        keep_positives: 10,
+        suspend_for_seconds: 1800
+      }
+    end
+    define self.defaults
+
+    # In this example, we are overwriting the defaults so that all new
+    # configs will consider 5 matches over a period of 60 seconds to
+    # be a positive.  The metric check will be suspended for 1h after 3
+    # positives.  The lower and upper bounds are also adjusted.
+    #
+    #   Check::Metric.defaults = {
+    #     lower: 10,
+    #     upper: 100,
+    #     matches_for_positive: 5,
+    #     over_seconds: 60,
+    #     suspend_after_positives: 3,
+    #     suspend_for_seconds: 3600
+    #   }
+    #
+    def self.defaults=(params={})
+      define self.defaults.merge(params)
+    end
+
+    def self.delete_all(name)
+      Redis.current.del(name)
+    end
+
+    def self.find(params={})
+      Metric.new(params)
+    end
+
+    def set
+      Redis::Set.new(self.fetch(:name)) if valid_name?
+    end
+
+    def similar
+      set.members.map do |member|
+        Metric.new(unpack(member))
+      end
+    end
+
+    def pack
+      self.to_hash.to_msgpack
+    end
+    alias :packed :pack
+
+    def unpack(value)
+      MessagePack.unpack(value)
+    end
+
+    def save
+      set.add(packed) if valid?
+      self
+    end
+
+    def delete
+      delete_associated
+      set.delete(packed)
+    end
+
+    def id
+      hash.abs
+    end
+
+    def namespace(string)
+      "#{self.fetch(:name)}:#{string}:#{self.id}"
+    end
+
+    def matches_key
+      namespace("matches")
+    end
+
+    def positives_key
+      namespace("positives")
+    end
+
+    def disable_key
+      namespace("disable")
+    end
+
+    def matches
+      Redis::List.new(matches_key, maxlength: self.fetch(:matches_for_positive), marshal: true)
+    end
+
+    def delete_matches
+      Redis.current.del(matches_key)
+    end
+    # removing all elements from a list is the same as deleting that list altogether
+    alias :clear_matches :delete_matches
+
+    def positives
+      Redis::List.new(positives_key, maxlength: self.fetch(:keep_positives), marshal: true)
+    end
+
+    def delete_positives
+      Redis.current.del(positives_key)
+    end
+    # removing all elements from a list is the same as deleting that list altogether
+    alias :clear_positives :delete_positives
+
+    def delete_associated
+      Redis.current.del([matches_key, positives_key, disable_key])
+    end
+
+    def suspended?(timestamp=Time.now.utc.to_i)
+      last_positive = positives.last
+
+      if last_positive
+        timestamp - last_positive.fetch(:timestamp) <= self.fetch(:suspend_for_seconds)
+      else
+        false
+      end
+    end
+
+    def disable
+      Redis::Value.new(disable_key, marshal: true)
+    end
+
+    def disable!
+      disable.value = true
+    end
+
+    def enable!
+      disable.delete
+    end
+    alias :delete_disable :enable!
+
+    def disabled?
+      disable.exists?
+    end
+
+    def trigger_positive?
+      first_match = matches.first
+      last_match = matches.last
+
+      if first_match and last_match
+        matches.length == self.fetch(:matches_for_positive) and
+        last_match.fetch(:timestamp) - first_match.fetch(:timestamp) <= self.fetch(:over_seconds)
+      end
+    end
+
+    def notify?
+      REDIS_NOTIFICATIONS.strip != ""
+    end
+
+    def notify(message)
+      Redis.current.publish(REDIS_NOTIFICATIONS, message.to_msgpack) if notify?
+    end
+
+    def check(params)
+      timestamp = params.fetch(:timestamp) { Time.now.utc }.to_i
+      value = params.fetch(:value)
+
+      similar.each do |metric|
+        next if metric.suspended?(timestamp) or metric.disabled?
+
+        unless value.between?(metric.fetch(:lower), metric.fetch(:upper))
+          metric.matches.push({
+            value: value,
+            timestamp: timestamp
+          })
+        end
+
+        if metric.trigger_positive?
+          new_positive = {
+            timestamp: metric.matches.last.fetch(:timestamp),
+            matches: metric.matches.values
+          }
+          metric.positives.push(new_positive)
+          notify(new_positive.merge(metric))
+          metric.clear_matches
+        end
+      end
+    end
+
+    def errors
+      return @errors if @errors
+      @errors = {}
+    end
+
+    def valid_name?
+      if (self.fetch(:name) { "" }.strip != "")
+        errors.delete(:name)
+        return true
+      else
+        errors[:name] = "can't be blank"
+        return false
+      end
+    end
+
+    def valid?
+      valid_name?
+    end
+
+    def persisted?
+      set.include?(packed)
+    end
+  end
+end

data/lib/check/notifications.rb

@@ -0,0 +1,65 @@
+require 'bundler/setup'
+require 'check'
+require 'msgpack'
+
+module Check
+  class Notifications
+    def initialize(redis_notifications=REDIS_NOTIFICATIONS)
+      shutdown_gracefully
+
+      Redis.current.subscribe(redis_notifications) do |on|
+        if block_given?
+          yield(on)
+        else
+          on_subscribe.(on)
+          on_message.(on)
+          on_unsubscribe.(on)
+        end
+      end
+    end
+
+    def on_subscribe
+      Proc.new do |on|
+        on.subscribe do |channel, subscriptions|
+          puts "Subscribed to #{channel} (#{subscriptions} subscriptions)"
+        end
+      end
+    end
+
+    def on_message
+      Proc.new do |on|
+        on.message do |channel, message|
+          puts "#{channel}: #{unpack(message)}"
+        end
+      end
+    end
+
+    def on_unsubscribe
+      Proc.new do |on|
+        on.unsubscribe do |channel, subscriptions|
+          puts "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+        end
+      end
+    end
+
+    def unpack(message)
+      MessagePack.unpack(message)
+    rescue MessagePack::UnpackError
+      puts "#{message.inspect} could not be unpacked by MessagePack"
+    end
+
+    def shutdown_gracefully
+      Signal.trap "SIGTERM", shutdown
+      Signal.trap "SIGINT", shutdown
+      Signal.trap "SIGQUIT", shutdown
+    end
+
+    def shutdown
+      Proc.new do
+        Redis.current.disconnect
+        puts "\n#{self.class} shutting down..."
+        exit 0
+      end
+    end
+  end
+end

data/test/check/api/metrics_test.rb

@@ -0,0 +1,109 @@
+require_relative '../../test_helper'
+
+require 'check/api/metrics'
+
+module Check
+  describe Metrics do
+    include Rack::Test::Methods
+
+    def app
+      Check::Metrics
+    end
+
+    def body
+      JSON.parse(last_response.body)
+    end
+
+    before do
+      Redis.current.flushdb
+    end
+
+    describe "GET /metrics/:metric_name" do
+      describe "when there are no metrics" do
+        it "returns empty array" do
+          get("/metrics/foo")
+          last_response.content_type.must_equal "application/json"
+          last_response.status.must_equal 200
+          body.must_equal([])
+        end
+      end
+
+      describe "when there are metrics" do
+        before do
+          matching_metric = Metric.new(name: "foo").save
+          other_metric = Metric.new(name: "bar").save
+        end
+
+        it "returns only matching ones" do
+          get("/metrics/foo")
+          last_response.content_type.must_equal "application/json"
+          last_response.status.must_equal 200
+          body.size.must_equal 1
+          body.first.fetch('name').must_equal "foo"
+        end
+      end
+    end
+
+    describe "POST /metrics" do
+      it "returns a 409 if params are invalid" do
+        post("/metrics")
+        last_response.content_type.must_equal "application/json"
+        last_response.status.must_equal 409
+        body["errors"].must_equal({
+          'name' => "can't be blank"
+        })
+      end
+
+      it "creates a new metric if params are valid" do
+        post("/metrics/", { name: "metric1" })
+        last_response.content_type.must_equal "application/json"
+        last_response.status.must_equal 201
+        body.must_equal ["metric1"]
+        Metric.find(name: "metric1").must_be :persisted?
+      end
+
+      it "persists values with , as arrays" do
+        post("/metrics", { name: "metric2", emails: "foo@bar.com,baz@qux.com" })
+        metric = Metric.find(name: "metric2").similar.first
+        (%w[foo@bar.com baz@qux.com] - metric.emails).must_equal []
+      end
+    end
+
+    describe "DELETE /metrics/:metric_name" do
+      describe "when metric does not exist" do
+        it "doesn't delete anything" do
+          delete("/metrics/foo")
+          last_response.status.must_equal 200
+        end
+      end
+
+      describe "when metric exists" do
+        it "deletes all similar" do
+          Metric.new(name: "foo").save
+          Metric.new(name: "foo", lower: 2).save
+          Metric.new(name: "bar").save
+          delete("/metrics/foo")
+          last_response.status.must_equal 200
+          Redis.current.keys.must_equal ["bar"]
+        end
+      end
+    end
+
+    describe "DELETE /metrics" do
+      it "returns 200 if metric doesn't exist" do
+        delete("/metrics", { name: "foo" })
+        last_response.status.must_equal 200
+      end
+
+      it "deletes a specific metric" do
+        Metric.new(name: "foo", lower: 10).save
+        Metric.new(name: "foo", lower: 9).save
+
+        delete("/metrics", { name: "foo", lower: 10 })
+        last_response.content_type.must_equal "application/json"
+        last_response.status.must_equal 200
+        Metric.find(name: "foo").similar.size.must_equal 1
+      end
+    end
+  end
+end