dogwatch 1.0.0

data/lib/dogwatch/model/mixin/colorize.rb

@@ -0,0 +1,23 @@
+module DogWatch
+  module Model
+    module Mixin
+      ##
+      # Provides a colorize() mixin that handles shell output coloring
+      ##
+      module Colorize
+        def colorize(param, options = {})
+          define_method(:color) do
+            case instance_variable_get("@#{ param }")
+            when *options.fetch(:white, [:status]) then :white
+            when *options.fetch(:cyan, [:debug, :trace]) then :cyan
+            when *options.fetch(:green, [:info, :success, :create]) then :green
+            when *options.fetch(:yellow, [:warn, :update]) then :yellow
+            when *options.fetch(:red, [:error, :fail, :delete]) then :red
+            else options.fetch(:default, :green)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dogwatch/model/monitor.rb

@@ -0,0 +1,68 @@
+require 'ostruct'
+require_relative 'options'
+
+module DogWatch
+  module Model
+    ##
+    # Handles monitor DSL methods and object validation
+    ##
+    class Monitor
+      TYPE_MAP = {
+        metric_alert: 'metric alert',
+        service_check: 'service check',
+        event_alert: 'event alert'
+      }
+
+      attr_reader :name
+      attr_reader :attributes
+
+      # @param [String] name
+      # @return [String]
+      def initialize(name)
+        @attributes = OpenStruct.new
+        @name = name
+      end
+
+      # @param [Symbol] type
+      # @return [String]
+      def type(type)
+        @attributes.type = TYPE_MAP[type]
+      end
+
+      # @param [String] query
+      # @return [String]
+      def query(query)
+        @attributes.query = query.to_s
+      end
+
+      # @param [String] message
+      # @return [String]
+      def message(message)
+        @attributes.message = message.to_s
+      end
+
+      # @param [Array] tags
+      # @return [Array]
+      def tags(tags)
+        @attributes.tags = tags.to_a
+      end
+
+      # @param [Proc] block
+      # @return [Hash]
+      def options(&block)
+        opts = DogWatch::Model::Options.new
+        opts.instance_eval(&block)
+        @attributes.options = opts.render
+      end
+
+      # @return [TrueClass|FalseClass]
+      def validate
+        return false unless TYPE_MAP.value?(@attributes.type)
+        return true unless @attributes.type.nil? || @attributes.type.empty? ||
+                           @attributes.query.nil? || @attributes.query.empty?
+
+        false
+      end
+    end
+  end
+end

data/lib/dogwatch/model/options.rb

@@ -0,0 +1,60 @@
+require 'ostruct'
+
+module DogWatch
+  module Model
+    ##
+    # Handles the options block methods
+    ##
+    class Options
+      attr_reader :attributes
+
+      def initialize
+        @attributes = OpenStruct.new
+      end
+
+      def render
+        @attributes.each_pair.to_h
+      end
+
+      # @param [Hash] args
+      def silenced(args)
+        @attributes.silenced = args.to_h
+      end
+
+      # @param [Boolean] notify
+      def notify_no_data(notify = false)
+        @attributes.notify_no_data = !!notify
+      end
+
+      # @param [Integer] minutes
+      def no_data_timeframe(minutes)
+        @attributes.no_data_timeframe = minutes.to_i
+      end
+
+      # @param [Integer] hours
+      def timeout_h(hours)
+        @attributes.timeout_h = hours.to_i
+      end
+
+      # @param [Integer] minutes
+      def renotify_interval(minutes)
+        @attributes.renotify_interval = minutes.to_i
+      end
+
+      # @param [String] message
+      def escalation_message(message)
+        @attributes.escalation_message = message.to_s
+      end
+
+      # @param [Boolean] notify
+      def notify_audit(notify = false)
+        @attributes.notify_audit = !!notify
+      end
+
+      # @param [Boolean] include
+      def include_tags(include = true)
+        @attributes.include_tags = !!include
+      end
+    end
+  end
+end

data/lib/dogwatch/model/response.rb

@@ -0,0 +1,62 @@
+require_relative 'mixin/colorize'
+
+module DogWatch
+  module Model
+    ##
+    # Takes DataDog client responses and formats them nicely
+    ##
+    class Response
+      extend Mixin::Colorize
+
+      ERROR = '400'
+      CREATED = '200'
+      ACCEPTED = '202'
+      colorize(:action,
+               :green => [:created, :accepted, :updated],
+               :yellow => [],
+               :red => [:error]
+              )
+
+      attr_accessor :response
+
+      def initialize(response, updated = false)
+        @response = response
+        @updated = updated
+      end
+
+      def status
+        return :updated if @updated == true
+        return :created if created?
+        return :error if failed?
+        return :accepted if accepted?
+      end
+
+      def message
+        attrs = @response[1]
+        return attrs['errors'] if attrs.key?('errors')
+        "#{status.to_s.capitalize} monitor #{attrs['name']}"\
+        " with message #{attrs['message']}"
+      end
+
+      def to_thor
+        action = status
+        text = message
+        [action, text, color]
+      end
+
+      private
+
+      def accepted?
+        @response[0] == ACCEPTED ? true : false
+      end
+
+      def created?
+        @response[0] == CREATED ? true : false
+      end
+
+      def failed?
+        @response[0] == ERROR ? true : false
+      end
+    end
+  end
+end

data/lib/dogwatch/monitor.rb

@@ -0,0 +1,51 @@
+require_relative 'model/client'
+require_relative 'model/monitor'
+
+module DogWatch
+  ##
+  # Provides a container around each monitor block
+  ##
+  class Monitor
+    attr_reader :client
+    attr_reader :responses
+    attr_accessor :config
+
+    # @param [String] name
+    # @param [Proc] block
+    # @return [DogWatch::Model::Monitor]
+    def initialize(name = nil, &block)
+      @name = name
+      @monitors = []
+      @config = nil
+      instance_exec(&block)
+    end
+
+    # @param [String] name
+    # @param [Proc] block
+    # @return [Array]
+    def monitor(name, &block)
+      monitor = DogWatch::Model::Monitor.new(name)
+      monitor.instance_eval(&block)
+      @monitors << monitor
+    end
+
+    # @return [Array]
+    def get
+      @responses = @monitors.map do |m|
+        if m.validate
+          @client.execute(m)
+        else
+          # Need somewhere to inject local errors such as if the request
+          # was never sent because the type or query wasn't supplied.
+          res = ['400', { 'errors' => ['The DogWatch monitor is invalid.'] }]
+          DogWatch::Model::Response.new(res)
+        end
+      end
+    end
+
+    # @return [DogWatch::Model::Client]
+    def client(client = nil)
+      @client = client.nil? ? DogWatch::Model::Client.new(@config) : client
+    end
+  end
+end

data/lib/dogwatch/version.rb

@@ -0,0 +1,6 @@
+# nodoc
+module DogWatch
+  VERSION = IO.read(File.expand_path('../../../VERSION', __FILE__)) rescue '0.0.1'
+  SUMMARY = 'A DSL to create DataDog Monitors'
+  DESCRIPTION = IO.read(File.expand_path('../../../README.md', __FILE__)) rescue ''
+end

data/test/data/monitors.json

@@ -0,0 +1,58 @@
+[
+  "200",
+  [
+    {
+      "created_at": 1440168271000,
+      "creator": {
+        "email": "sperson@rapid7.com",
+        "handle": "sperson@rapid7.com",
+        "id": 10000,
+        "name": "Some Person"
+      },
+      "id": 123456,
+      "message": "Some message",
+      "multi": false,
+      "name": "Monitor name",
+      "options": {
+        "no_data_timeframe": 2,
+        "notify_audit": false,
+        "notify_no_data": false,
+        "renotify_interval": 0,
+        "silenced": {},
+        "timeout_h": 0
+      },
+      "org_id": 12345,
+      "overall_state": "OK",
+      "query": "Some query",
+      "tags": [],
+      "type": "event alert"
+    },
+    {
+      "created_at": 1436300628000,
+      "creator": {
+        "email": "sperson@rapid7.com",
+        "handle": "sperson@rapid7.com",
+        "id": 10000,
+        "name": "Some Person"
+      },
+      "id": 234567,
+      "message": "Some message",
+      "multi": false,
+      "name": "Second monitor name",
+      "options": {
+        "escalation_message": "Oh noes!",
+        "no_data_timeframe": 2,
+        "notify_audit": true,
+        "notify_no_data": true,
+        "renotify_interval": 10,
+        "silenced": {},
+        "timeout_h": 1
+      },
+      "org_id": 12345,
+      "overall_state": "OK",
+      "query": "avg(last_1m):avg:system.cpu.user{region:us-east-1} > 20",
+      "tags": [],
+      "type": "metric alert"
+    }
+  ]
+]

data/test/data/responses.rb

@@ -0,0 +1,22 @@
+ERROR_RES = [
+  '400',
+  { 'errors' => ["The value provided for parameter 'query' is invalid"] }
+]
+VALID_RES = [
+  '200',
+  {
+    'name' => 'foobar',
+    'query' => 'some query',
+    'message' => 'foobar',
+    'id' => 1_234_567
+  }
+]
+ACCEPTED_RES = [
+  '202',
+  {
+    'name' => 'foobar',
+    'query' => 'some query',
+    'message' => 'foobar',
+    'id' => 1_234_567
+  }
+]

data/test/dogwatch/test_client.rb

@@ -0,0 +1,66 @@
+require_relative '../test_helper'
+require_relative '../../lib/dogwatch/model/client'
+require_relative '../../lib/dogwatch/model/config'
+require_relative '../../lib/dogwatch/model/monitor'
+require 'dogapi'
+require 'json'
+
+class TestClient < Minitest::Test
+  TEST_RESPONSE = [
+    '200',
+    [
+      name: 'test monitor',
+      type: 'metric alert',
+      query: 'test query'
+    ]
+  ]
+
+  UPDATED_RESPONSE = [
+    '200',
+    [
+      name: 'Monitor name',
+      type: :metric_alert,
+      query: 'scheduled maintenance query'
+    ]
+  ]
+
+  def setup
+    config = DogWatch::Model::Config.new('foo', 'bar')
+
+    m = monitors
+    k = Class.new(DogWatch::Model::Client) do
+      define_method(:all_monitors) do
+        m[1]
+      end
+    end
+    @client = k.new(config)
+  end
+
+  def monitors
+    monitor_file = File.expand_path('../../data/monitors.json', __FILE__)
+    monitors = JSON.parse(IO.read(monitor_file))
+    monitors
+  end
+
+  def test_create_monitor
+    new_monitor = DogWatch::Model::Monitor.new('test monitor')
+    new_monitor.type(:metric_alert)
+    new_monitor.query('test query')
+
+    @client.client.stub :monitor, TEST_RESPONSE do
+      @client.execute(new_monitor)
+      assert_equal @client.response.status, :created
+    end
+  end
+
+  def test_update_monitor
+    update_monitor = DogWatch::Model::Monitor.new('Monitor name')
+    update_monitor.type(:metric_alert)
+    update_monitor.query('scheduled maintenance query')
+
+    @client.client.stub :update_monitor, UPDATED_RESPONSE do
+      @client.execute(update_monitor)
+      assert_equal @client.response.status, :updated
+    end
+  end
+end

data/test/dogwatch/test_colorize.rb

@@ -0,0 +1,21 @@
+require_relative '../test_helper'
+require_relative '../../lib/dogwatch/model/mixin/colorize'
+
+class ToColor
+  extend DogWatch::Model::Mixin::Colorize
+
+  colorize(:action,
+           :green => [:created, :accepted, :updated],
+           :yellow => [],
+           :red => [:error])
+end
+
+class TestColorize < Minitest::Test
+  def setup
+    @tocolor = ToColor.new
+  end
+
+  def test_colorize_default
+    assert_equal :green, @tocolor.color
+  end
+end