interferon 0.0.20 → 0.1.0

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
+sudo: false
 cache: bundler
 script: bundle exec rspec
 rvm:
   - 1.9.3
-  - 2.1.5
-  - 2.2.1
-
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3

data/README.md

@@ -5,7 +5,7 @@
 This repo contains the interferon gem.
 This gem enables you to store your alerts configuration in code.
 You should create your own repository, with a `Gemfile` which imports the interferon gem.
-For an example of such a repository, along with example configuration and alerts files, see https://www.github.com/airbnb/alerts_example
+For an example of such a repository, along with example configuration and alerts files, see https://www.github.com/airbnb/alerts
 
 ## Running This Gem ##
 

data/lib/interferon/alert.rb

@@ -16,7 +16,6 @@ module Interferon
     def evaluate(hostinfo)
       dsl = AlertDSL.new(hostinfo)
       dsl.instance_eval(@text, @filename, 1)
-      dsl.name(dsl.name.strip)
       @dsl = dsl
 
       # return the alert and not the DSL object, which is private

data/lib/interferon/alert_dsl.rb

@@ -19,12 +19,12 @@ module Interferon
       if val.nil? && block.nil?
         f = instance_variable_get(field)
         f.nil? ? default : f
-      elsif val.nil?
-        instance_variable_set(field, block.call)
-      elsif block.nil?
-        instance_variable_set(field, val)
-      else
+      elsif !val.nil? && !block.nil?
         raise ArgumentError, "You must pass either a value or a block but not both to #{field}"
+      else
+        f = val.nil? ? block.call : val
+        f = yield(f) if block_given?
+        instance_variable_set(field, f)
       end
     end
   end
@@ -33,19 +33,31 @@ module Interferon
     include DSLMixin
 
     def name(v = nil, &block)
-      get_or_set(:@name, v, block, '')
+      get_or_set(:@name, v, block, '') { |val| val.strip }
     end
 
     def message(v = nil, &block)
       get_or_set(:@message, v, block, '')
     end
 
-    def silenced(v = nil, &block)
-      get_or_set(:@silenced, v, block, false)
+    def monitor_type(v = nil, &block)
+      get_or_set(:@monitor_type, v, block, 'metric alert')
     end
 
-    def silenced_until(v = nil, &block)
-      get_or_set(:@silenced_until, v && Time.parse(v), block, Time.at(0))
+    def applies(v = nil, &block)
+      get_or_set(:@applies, v, block, false)
+    end
+
+    def silenced(v = nil, &block)
+      get_or_set(:@silenced, v, block, {}) do |val|
+        if val.is_a? Hash
+          val
+        elsif val == true
+          { "*" => nil }
+        else
+          {}
+        end
+      end
     end
 
     def is_work_hour?(args = {})
@@ -62,15 +74,24 @@ module Interferon
     end
 
     def no_data_timeframe(v = nil, &block)
-      get_or_set(:@no_data_timeframe, v, block, false)
+      get_or_set(:@no_data_timeframe, v, block, nil)
     end
 
     def timeout(v = nil, &block)
-      get_or_set(:@timeout, v, block, false)
+      get_or_set(:@timeout, v, block, nil)
     end
 
-    def applies(v = nil, &block)
-      get_or_set(:@applies, v, block, false)
+    def timeout_h
+      # timeout is in seconds, but set it to 1 hour at least
+      timeout ? [1, timeout.to_i / 3600].max : nil
+    end
+
+    def thresholds(v = nil, &block)
+      get_or_set(:@thresholds, v, block, nil)
+    end
+
+    def require_full_window(v = nil, &block)
+      get_or_set(:@require_full_window, v, block, nil)
     end
 
     def notify(v = nil)
@@ -92,13 +113,17 @@ module Interferon
     def groups(v = nil, &block)
       get_or_set(:@groups, v, block, [])
     end
+
+    def audit(v = nil, &block)
+      get_or_set(:@audit, v, block, true)
+    end
   end
 
   class MetricDSL
     include DSLMixin
 
     def datadog_query(v = nil, &block)
-      get_or_set(:@datadog_query, v, block, '')
+      get_or_set(:@datadog_query, v, block, '') { |val| val.strip }
     end
   end
 end

data/lib/interferon/destinations/datadog.rb

@@ -1,6 +1,8 @@
 require 'diffy'
 require 'dogapi'
+require 'parallel'
 require 'set'
+require 'thread'
 
 Diffy::Diff.default_format = :text
 
@@ -37,8 +39,11 @@ module Interferon::Destinations
       @existing_alerts = nil
       @dry_run = options['dry_run']
 
-      # create datadog alerts 10 at a time
+      # Datadog communication threads
       @concurrency = options['concurrency'] || 10
+      # Fetch page size
+      @page_size = options['page_size'] || 1000
+
       # configure retries
       @retries = options['retries'] || 3
 
@@ -66,25 +71,39 @@ module Interferon::Destinations
     end
 
     def get_existing_alerts
-      resp = @dog.get_all_alerts()
+      alerts = Queue.new
+      has_more = true
+
+      Parallel.map_with_index(-> { has_more || Parallel::Stop },
+                              in_threads: @concurrency) do |_, page|
+        successful = false
+        @retries.downto(0) do
+          resp = @dog.get_all_monitors(page: page, page_size: @page_size)
+          code = resp[0].to_i
+          if code != 200
+            log.info("Failed to retrieve existing alerts from datadog. #{code}: #{resp[1].inspect}")
+          else
+            alerts_page = resp[1]
+            if alerts_page.length < @page_size
+              has_more = false
+            end
+            alerts_page.map { |alert| alerts.push(alert) }
+            successful = true
+            break
+          end
+        end
 
-      code = resp[0].to_i
-      if code != 200
-        raise "Failed to retrieve existing alerts from datadog. #{code}: #{resp[1].inspect}"
+        if !successful
+          # Out of retries
+          raise "Retries exceeded for fetching data from datadog."
+        end
       end
-      resp[1]['alerts']
+      alerts.size.times.map { alerts.pop }
     end
 
     def existing_alerts
       unless @existing_alerts
-        retries = @retries
-        begin
-          alerts = get_existing_alerts
-        rescue
-          retries -= 1
-          retry if retries >= 0
-          raise
-        end
+        alerts = get_existing_alerts
 
         # key alerts by name
         @existing_alerts = {}
@@ -108,83 +127,43 @@ module Interferon::Destinations
         ]
       end
 
-      return @existing_alerts
+      @existing_alerts
     end
 
     def create_alert(alert, people)
       # create a message which includes the notifications
+      # Datadog may have a race condition where alerts created in a bad state may be triggered
+      # during the dry-run creation process. Delete people from dry-run alerts to avoid this
       message = generate_message(alert['message'], people)
 
       # create the hash of options to send to datadog
-      alert_opts = {
-        :name => alert['name'],
-        :message => message,
-        :silenced => false,
+      alert_options = {
+        :notify_audit => alert['notify']['audit'],
         :notify_no_data => alert['notify_no_data'],
-        :timeout_h => nil,
+        :no_data_timeframe => alert['no_data_timeframe'],
+        :silenced => alert['silenced'],
+        :timeout_h => alert['timeout_h'],
       }
 
-      if @dry_run
-        # Datadog may have a race condition where alerts created in a bad state may be triggered
-        # during the dry-run creation process. Delete people from dry-run alerts to avoid this
-        alert_opts[:message] = generate_message(alert['message'], [])
+      if !alert['require_full_window'].nil?
+        alert_options[:require_full_window] = alert['require_full_window']
       end
 
-      # Set alert to be silenced if there is a silenced set or silenced_until set
-      if alert['silenced'] || alert['silenced_until'] > Time.now
-        alert_opts[:silenced] = true
+      if !alert['thresholds'].nil?
+        alert_options[:thresholds] = alert['thresholds']
       end
 
-      # allow an optional timeframe for "no data" alerts to be specified
-      # (this feature is supported, even though it's not documented)
-      alert_opts[:no_data_timeframe] = alert['no_data_timeframe'] if alert['no_data_timeframe']
-
-      # timeout is in seconds, but set it to 1 hour at least
-      alert_opts[:timeout_h] = [1, (alert['timeout'].to_i / 3600)].max if alert['timeout']
-
-      datadog_query = alert['metric']['datadog_query'].strip
+      datadog_query = alert['metric']['datadog_query']
       existing_alert = existing_alerts[alert['name']]
 
       # new alert, create it
       if existing_alert.nil?
         action = :creating
-        @stats[:alerts_to_be_created] += 1
-        new_alert_text = "Query: #{datadog_query} Message: #{message.split().join(' ')}"
-        log.info("creating new alert #{alert['name']}: #{new_alert_text}")
-
-        resp = @dog.alert(
-          alert['metric']['datadog_query'].strip,
-          alert_opts,
-        )
-
-      # existing alert, modify it
+        resp = create_datadog_alert(alert, datadog_query, message, alert_options)
       else
+        # existing alert, modify it
         action = :updating
-        @stats[:alerts_to_be_updated] += 1
-        id = existing_alert['id'][0]
-
-        new_alert_text = "Query:\n#{datadog_query}\nMessage:\n#{message}"
-        existing_alert_text = "Query:\n#{existing_alert['query']}\nMessage:\n#{existing_alert['message']}\n"
-        diff = Diffy::Diff.new(existing_alert_text, new_alert_text, :context=>1)
-        log.info("updating existing alert #{id} (#{alert['name']}): #{diff}")
-
-        if @dry_run
-          resp = @dog.alert(
-            alert['metric']['datadog_query'].strip,
-            alert_opts,
-          )
-        else
-          resp = @dog.update_alert(
-            id,
-            alert['metric']['datadog_query'].strip,
-            alert_opts
-          )
-          # Unmute existing alerts that have been unsilenced.
-          # Datadog does not allow updates to silencing via the update_alert API call.
-          if existing_alert['silenced'] && !alert_opts[:silenced]
-            @dog.unmute_monitor(id)
-          end
-        end
+        resp = update_datadog_alert(alert, datadog_query, message, alert_options, existing_alert)
       end
 
       # log whenever we've encountered errors
@@ -196,14 +175,100 @@ module Interferon::Destinations
         # assume this was a success
         @stats[:alerts_created] += 1 if action == :creating
         @stats[:alerts_updated] += 1 if action == :updating
-        @stats[:alerts_silenced] += 1 if alert_opts[:silenced]
+        @stats[:alerts_silenced] += 1 if !alert_options[:silenced].empty?
       end
 
       id = resp[1].nil? ? nil : [resp[1]['id']]
       # lets key alerts by their name
-      return [alert['name'], id]
+      [alert['name'], id]
+    end
+
+    def create_datadog_alert(alert, datadog_query, message, alert_options)
+      @stats[:alerts_to_be_created] += 1
+      new_alert_text = <<-EOM
+Query:
+#{datadog_query}
+Message:
+#{message}
+Options:
+#{alert_options}
+EOM
+      log.info("creating new alert #{alert['name']}: #{new_alert_text}")
+
+      @dog.monitor(
+        alert['monitor_type'],
+        datadog_query,
+        :name => alert['name'],
+        :message => @dry_run ? generate_message(alert, []) : message,
+        :options => alert_options,
+      )
+    end
+
+    def update_datadog_alert(alert, datadog_query, message, alert_options, existing_alert)
+        @stats[:alerts_to_be_updated] += 1
+        id = existing_alert['id'][0]
+
+        new_alert_text = <<-EOM.strip
+Query:
+#{datadog_query.strip}
+Message:
+#{message.strip}
+Options:
+#{alert_options}
+EOM
+        existing_alert_text = <<-EOM.strip
+Query:
+#{existing_alert['query'].strip}
+Message:
+#{existing_alert['message'].strip}
+Options:
+#{alert_options}
+EOM
+        diff = Diffy::Diff.new(existing_alert_text, new_alert_text, :context=>1)
+        log.info("updating existing alert #{id} (#{alert['name']}):\n#{diff}")
+
+        if @dry_run
+          resp = @dog.monitor(
+            alert['monitor_type'],
+            datadog_query,
+            :name => alert['name'],
+            :message => generate_message(alert, []),
+            :options => alert_options,
+          )
+        else
+          if alert['monitor_type'] == existing_alert['type']
+            resp = @dog.update_monitor(
+              id,
+              datadog_query,
+              :name => alert['name'],
+              :message => message,
+              :options => alert_options,
+            )
+
+            # Unmute existing alerts that have been unsilenced.
+            # Datadog does not allow updates to silencing via the update_alert API call.
+            if !existing_alert['options']['silenced'].empty? && alert_options[:silenced].empty?
+              @dog.unmute_monitor(id)
+            end
+          else
+            # Need to recreate alert with new monitor type
+            resp = @dog.delete_monitor(id)
+            code = resp[0].to_i
+            if !(code >= 300 || code == -1)
+              resp = @dog.monitor(
+                alert['monitor_type'],
+                datadog_query,
+                :name => alert['name'],
+                :message => message,
+                :options => alert_options,
+              )
+            end
+          end
+        end
+    resp
     end
 
+
     def remove_alert(alert)
       if alert['message'].include?(ALERT_KEY)
         @stats[:alerts_to_be_deleted] += 1
@@ -211,7 +276,7 @@ module Interferon::Destinations
 
         if !@dry_run
           alert['id'].each do |alert_id|
-            resp = @dog.delete_alert(alert_id)
+            resp = @dog.delete_monitor(alert_id)
             code = resp[0].to_i
             log_datadog_response_code(resp, code, :deleting)
 
@@ -244,7 +309,7 @@ module Interferon::Destinations
     def remove_alert_by_id(alert_id)
       # This should only be used by dry-run to clean up created dry-run alerts
       log.debug("deleting alert, id: #{alert_id}")
-      resp = @dog.delete_alert(alert_id)
+      resp = @dog.delete_monitor(alert_id)
       code = resp[0].to_i
       log_datadog_response_code(resp, code, :deleting)
     end
@@ -263,7 +328,7 @@ module Interferon::Destinations
           statsd.gauge('datadog.api.client_error', 1, :tags => ["alert:#{alert}"])
           statsd.gauge('datadog.api.success', 0, :tags => ["alert:#{alert}"])
           log.error("client error while #{action} alert '#{alert['name']}';" \
-                    " query was '#{alert['metric']['datadog_query'].strip}'" \
+                    " query was '#{alert['metric']['datadog_query']}'" \
                     " response was #{resp[0]}:'#{resp[1].inspect}'")
         end
 
@@ -275,7 +340,7 @@ module Interferon::Destinations
           statsd.gauge('datadog.api.client_error', 0, :tags => ["alert:#{alert}"])
           statsd.gauge('datadog.api.success', 0, :tags => ["alert:#{alert}"])
           log.error("unknown error while #{action} alert '#{alert['name']}':" \
-                    " query was '#{alert['metric']['datadog_query'].strip}'" \
+                    " query was '#{alert['metric']['datadog_query']}'" \
                     " response was #{resp[0]}:'#{resp[1].inspect}'")
         end
       else

data/lib/interferon/version.rb

@@ -1,3 +1,3 @@
 module Interferon
-  VERSION = "0.0.20"
+  VERSION = "0.1.0"
 end

data/lib/interferon.rb

@@ -391,27 +391,46 @@ module Interferon
       end
     end
 
+    def self.normalize_monitor_type(monitor_type)
+      # Convert 'query alert' type to 'metric alert' type. They can used interchangeably when
+      # submitting monitors to Datadog. Datadog will automatically do the conversion to 'query
+      # alert' for a "complex" query that includes multiple metrics/tags while using 'metric alert'
+      # for monitors that include a single scope/metric.
+      monitor_type == 'query alert' ? 'metric alert' : monitor_type
+    end
+
     def self.same_alerts(dest, alert_people_pair, alert_api_json)
       alert, people = alert_people_pair
 
       prev_alert = {
+        :monitor_type => normalize_monitor_type(alert_api_json['type']),
         :query => alert_api_json['query'].strip,
         :message => alert_api_json['message'].strip,
-        :notify_no_data => alert_api_json['notify_no_data'],
-        :silenced => alert_api_json['silenced'],
-        :timeout => alert_api_json['timeout_h'],
-        :no_data_timeframe => alert_api_json['no_data_timeframe']
+        :notify_no_data => alert_api_json['options']['notify_no_data'],
+        :notify_audit => alert_api_json['options']['notify_audit'],
+        :no_data_timeframe => alert_api_json['options']['no_data_timeframe'],
+        :silenced => alert_api_json['options']['silenced'],
+        :thresholds => alert_api_json['options']['thresholds'],
+        :timeout_h => alert_api_json['options']['timeout_h'],
       }
 
       new_alert = {
-        :query => alert['metric']['datadog_query'].strip,
+        :monitor_type => normalize_monitor_type(alert['monitor_type']),
+        :query => alert['metric']['datadog_query'],
         :message => dest.generate_message(alert['message'], people).strip,
         :notify_no_data => alert['notify_no_data'],
-        :silenced => alert['silenced'] || alert['silenced_until'] > Time.now,
-        :timeout => alert['timeout'] ? [1, alert['timeout'].to_i / 3600].max : nil,
-        :no_data_timeframe => alert['no_data_timeframe'] || nil
+        :notify_audit => alert['notify']['audit'],
+        :no_data_timeframe => alert['no_data_timeframe'],
+        :silenced => alert['silenced'],
+        :thresholds => alert['thresholds'],
+        :timeout_h => alert['timeout_h']
       }
 
+      if !alert['require_full_window'].nil?
+        pre_alert[:require_full_window] = alert_api_json['options']['require_full_window']
+        new_alert[:require_full_window] = alert['require_full_window']
+      end
+
       prev_alert == new_alert
     end
 

data/spec/lib/interferon/destinations/datadog_spec.rb

@@ -25,85 +25,100 @@ describe Interferon::Destinations::Datadog do
       'name' => 'Test Alert',
       'message' => "Test Message",
       'metric' => { 'datadog_query' => 'avg:metric{*}' },
-      'silenced' => false,
-      'silenced_until' => Time.at(0),
+      'silenced' => {},
+      'notify' => {},
     }
   }
   let(:mock_people) { ['foo', 'bar', 'baz'] }
+  let(:mock_response) {
+    {
+      "Test Alert" => {
+        "id" => 567,
+        "name" => 'Test Alert',
+        'message' => "Test Message",
+        "query" => 'avg:metric{*}',
+        "options" => {
+          "silenced" => {}
+        }
+      }
+    }
+  }
 
   describe ".get_existing_alerts" do
-    it "calls dogapi get_all_alerts" do
-      expect_any_instance_of(Dogapi::Client).to receive(:get_all_alerts).and_return([200, ""])
+    it "calls dogapi get_all_monitors" do
+      expect_any_instance_of(Dogapi::Client).to receive(:get_all_monitors).and_return([200, []])
       datadog.get_existing_alerts
     end
   end
 
   describe ".existing_alerts" do
-    it "retries dogapi get_all_alerts" do
+    it "retries dogapi get_all_monitors" do
       return_vals = [[400, ""]] * (retries + 1)
-      expect_any_instance_of(Dogapi::Client).to receive(:get_all_alerts).and_return(*return_vals)
+      expect_any_instance_of(Dogapi::Client).to receive(:get_all_monitors).and_return(*return_vals)
       expect { datadog.existing_alerts }.to raise_error RuntimeError
     end
   end
 
   describe ".create_alert" do
-    it "calls dogapi alert" do
-      expect_any_instance_of(Dogapi::Client).to receive(:alert).and_return([200, ""])
+    it "calls dogapi monitor" do
+      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ""])
       expect(datadog).to receive(:existing_alerts).and_return({})
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it "calls dogapi update_alert when alert name is found" do
-      expect_any_instance_of(Dogapi::Client).to receive(:update_alert).and_return([200, ""])
-      expect(datadog).to receive(:existing_alerts).and_return(
-        {
-          "Test Alert" => {
-            "id" => 567,
-            "name" => 'Test Alert',
-          }
-        }
-      )
+    it "calls dogapi update_monitor when alert name is found" do
+      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ""])
+      expect(datadog).to receive(:existing_alerts).and_return(mock_response)
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it "always calls alert in dry-run" do
-      expect_any_instance_of(Dogapi::Client).to receive(:alert).and_return([200, ""])
-      expect(datadog_dry_run).to receive(:existing_alerts).and_return(
-        {
-          "Test Alert" => {
-            "id" => 567,
-            "name" => 'Test Alert',
-          }
-        }
-      )
+    it "calls dogapi to delete and recreate when alert name is found" do
+      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).and_return([200, ""])
+      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ""])
+      mock_response["Test Alert"]["type"] = "event_alert"
+      expect(datadog).to receive(:existing_alerts).and_return(mock_response)
+      datadog.create_alert(mock_alert, mock_people)
+    end
+
+    it "calls dogapi to unmute when exiting alert is muted" do
+      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ""])
+      expect_any_instance_of(Dogapi::Client).to receive(:unmute_monitor).and_return([200, ""])
+      mock_response["Test Alert"]["options"]["silenced"] = { '*' => nil }
+      expect(datadog).to receive(:existing_alerts).and_return(mock_response)
+      datadog.create_alert(mock_alert, mock_people)
+    end
+
+    it "always calls monitor in dry-run" do
+      expect_any_instance_of(Dogapi::Client).to receive(:monitor).and_return([200, ""])
+      expect(datadog_dry_run).to receive(:existing_alerts).and_return(mock_response)
       datadog_dry_run.create_alert(mock_alert, mock_people)
     end
   end
 
   describe ".remove_alert" do
-    it "calls dogapi delete_alert with the correct alert id" do
+    it "calls dogapi delete_monitor with the correct alert id" do
       mock_alert["message"] += Interferon::Destinations::Datadog::ALERT_KEY
-      expect_any_instance_of(Dogapi::Client).to receive(:delete_alert).
+      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).
         with(mock_alert_id).and_return([200, ""])
       datadog.remove_alert(mock_alert)
     end
 
-    it "does not call dogapi delete_alert in dry_run" do
+    it "does not call dogapi delete_monitor in dry_run" do
       mock_alert["message"] += Interferon::Destinations::Datadog::ALERT_KEY
-      expect_any_instance_of(Dogapi::Client).to_not receive(:delete_alert)
+      expect_any_instance_of(Dogapi::Client).to_not receive(:delete_monitor)
       datadog_dry_run.remove_alert(mock_alert)
     end
 
-    it "does not call dogapi delete_alert when ALERT_KEY is missing" do
-      expect_any_instance_of(Dogapi::Client).to_not receive(:delete_alert)
+    it "does not call dogapi delete_monitor when ALERT_KEY is missing" do
+      expect_any_instance_of(Dogapi::Client).to_not receive(:delete_monitor)
       datadog.remove_alert(mock_alert)
     end
 
   end
 
   describe ".remove_alert_by_id" do
-    it "calls dogapi delete_alert" do
-      expect_any_instance_of(Dogapi::Client).to receive(:delete_alert).
+    it "calls dogapi delete_monitor" do
+      expect_any_instance_of(Dogapi::Client).to receive(:delete_monitor).
         with(mock_alert_id).and_return([200, ""])
       datadog.remove_alert_by_id(mock_alert_id)
     end

data/spec/lib/interferon_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'helpers/mock_alert'
-require 'helpers/dsl_helper'
 require 'interferon/destinations/datadog'
 
 include Interferon
@@ -26,22 +25,33 @@ describe Interferon::Interferon do
     end
 
     it "detects a change if alert notify_no_data is different" do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', false)
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2', true)
+      alert1 = create_test_alert('name1', 'testquery1', 'message1', { :notify_no_data => false })
+      alert2 = mock_alert_json(
+        'name2',
+        'testquery2',
+        'message2',
+        nil,
+        [1],
+        { :notify_no_data => true }
+      )
 
       expect(Interferon::Interferon.same_alerts(dest, [alert1, []], alert2)).to be false
     end
 
     it "detects a change if alert silenced is different" do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', false, true)
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2', false, false)
+      alert1 = create_test_alert('name1', 'testquery1', 'message1', { :silenced => true })
+      alert2 = mock_alert_json('name2', 'testquery2', 'message2', nil, [1], { :silenced => {} })
 
       expect(Interferon::Interferon.same_alerts(dest, [alert1, []], alert2)).to be false
     end
 
     it "does not detect a change when alert datadog query and message are the same" do
       alert1 = create_test_alert('name1', 'testquery1', 'message1')
-      alert2 = mock_alert_json('name1', 'testquery1', "message1\nThis alert was created via the alerts framework")
+      alert2 = mock_alert_json(
+        'name1',
+        'testquery1',
+        "message1\nThis alert was created via the alerts framework"
+      )
 
       expect(Interferon::Interferon.same_alerts(dest, [alert1, []], alert2)).to be true
     end
@@ -62,7 +72,12 @@ describe Interferon::Interferon do
       expect(dest).not_to receive(:create_alert)
       expect(dest).not_to receive(:remove_alert_by_id)
 
-      interferon.update_alerts_on_destination(dest, ['host'], [alerts['name1'], alerts['name2']], {})
+      interferon.update_alerts_on_destination(
+        dest,
+        ['host'],
+        [alerts['name1'], alerts['name2']],
+        {}
+      )
     end
 
     it 'runs added alerts' do
@@ -71,7 +86,12 @@ describe Interferon::Interferon do
       expect(dest).to receive(:create_alert).once.and_call_original
       expect(dest).to receive(:remove_alert_by_id).with('3').once
 
-      interferon.update_alerts_on_destination(dest, ['host'], [alerts['name1'], alerts['name2'], added], {})
+      interferon.update_alerts_on_destination(
+        dest,
+        ['host'],
+        [alerts['name1'], alerts['name2'], added],
+        {}
+      )
     end
 
     it 'runs updated alerts' do
@@ -89,7 +109,7 @@ describe Interferon::Interferon do
     end
 
     it 'deletes duplicate old alerts' do
-      alert1 = mock_alert_json('name1', 'testquery1', '', false, false, [1, 2, 3])
+      alert1 = mock_alert_json('name1', 'testquery1', '', nil, [1, 2, 3])
       alert2 = mock_alert_json('name2', 'testquery2', '')
       existing_alerts = {'name1' => alert1, 'name2' => alert2}
       dest = MockDest.new(existing_alerts)
@@ -104,7 +124,7 @@ describe Interferon::Interferon do
     end
 
     it 'deletes duplicate old alerts when creating new alert' do
-      alert1 = mock_alert_json('name1', 'testquery1', '', false, false, [1, 2, 3])
+      alert1 = mock_alert_json('name1', 'testquery1', '', nil, [1, 2, 3])
       alert2 = mock_alert_json('name2', 'testquery2', '')
       existing_alerts = {'name1' => alert1, 'name2' => alert2}
       dest = MockDest.new(existing_alerts)
@@ -116,7 +136,7 @@ describe Interferon::Interferon do
 
       # Since we change id to nil we will not be attempting to delete duplicate alerts
       # during dry run
-      # expect(dest).to receive(:remove_alert).with(existing_alerts['name1'])
+      expect(dest).to_not receive(:remove_alert).with(existing_alerts['name1'])
       expect(dest).to receive(:remove_alert).with(existing_alerts['name2'])
 
       interferon.update_alerts_on_destination(dest, ['host'], [added], {})
@@ -147,7 +167,12 @@ describe Interferon::Interferon do
       expect(dest).to receive(:create_alert).once.and_call_original
       expect(dest).not_to receive(:remove_alert_by_id).with('3')
 
-      interferon.update_alerts_on_destination(dest, ['host'], [alerts['name1'], alerts['name2'], added], {})
+      interferon.update_alerts_on_destination(
+        dest,
+        ['host'],
+        [alerts['name1'], alerts['name2'], added],
+        {}
+      )
     end
 
     it 'runs updated alerts' do
@@ -167,7 +192,7 @@ describe Interferon::Interferon do
     end
 
     it 'deletes duplicate old alerts' do
-      alert1 = mock_alert_json('name1', 'testquery1', '', false, false, [1, 2, 3])
+      alert1 = mock_alert_json('name1', 'testquery1', '', nil, [1, 2, 3])
       alert2 = mock_alert_json('name2', 'testquery2', '')
       existing_alerts = {'name1' => alert1, 'name2' => alert2}
       dest = MockDest.new(existing_alerts)
@@ -182,7 +207,7 @@ describe Interferon::Interferon do
     end
 
     it 'deletes duplicate old alerts when creating new alert' do
-      alert1 = mock_alert_json('name1', 'testquery1', '', false, false, [1, 2, 3])
+      alert1 = mock_alert_json('name1', 'testquery1', '', nil, [1, 2, 3])
       alert2 = mock_alert_json('name2', 'testquery2', '')
       existing_alerts = {'name1' => alert1, 'name2' => alert2}
       dest = MockDest.new(existing_alerts)
@@ -190,7 +215,13 @@ describe Interferon::Interferon do
 
       added = create_test_alert('name1', 'testquery1', '')
 
-      expect(dest).to receive(:remove_alert).with(mock_alert_json('name1', 'testquery1', '', false, false, [2, 3]))
+      expect(dest).to receive(:remove_alert).with(mock_alert_json(
+        'name1',
+        'testquery1',
+        '',
+        nil,
+        [2, 3]
+      ))
       expect(dest).to receive(:remove_alert).with(existing_alerts['name2'])
 
       interferon.update_alerts_on_destination(dest, ['host'], [added], {})
@@ -204,8 +235,6 @@ describe Interferon::Interferon do
   end
 
   class MockDest < Interferon::Destinations::Datadog
-    @existing_alerts
-
     def initialize(the_existing_alerts)
       @existing_alerts = the_existing_alerts
     end
@@ -221,29 +250,53 @@ describe Interferon::Interferon do
     end
   end
 
-  def mock_alert_json(name, datadog_query, message, notify_no_data=false, silenced=false, id=nil)
-    { 'name'=> name,
-      'query'=> datadog_query,
-      'message'=> message,
-      'notify_no_data' => notify_no_data,
-      'silenced' => silenced,
-      'id' => id.nil? ? [name[-1]] : id
+  DEFAULT_OPTIONS = {
+    'notify_audit' => true,
+    'notify_no_data' => false,
+    'silenced' => {},
+    'thresholds' => nil,
+    'no_data_timeframe' => nil,
+    'require_full_window' => nil,
+    'timeout' => nil,
+  }
+
+  def mock_alert_json(name, datadog_query, message, type="metric alert", id=nil, options={})
+    options = DEFAULT_OPTIONS.merge(options)
+
+    {
+      'name'=> name,
+      'query' => datadog_query,
+      'type' => type,
+      'message' => message,
+      'id' => id.nil? ? [name[-1]] : id,
+      'options' => options,
     }
   end
 
-  def create_test_alert(name, datadog_query, message, notify_no_data=false, silenced=false)
-    alert_dsl = MockAlertDSL.new
-    metric_dsl = MockMetricDSL.new
+  def create_test_alert(name, datadog_query, message, options={})
+    options = DEFAULT_OPTIONS.merge(options)
+
+    alert_dsl = AlertDSL.new({})
+
+    metric_dsl = MetricDSL.new({})
     metric_dsl.datadog_query(datadog_query)
-    alert_dsl.metric(metric_dsl)
+    alert_dsl.instance_variable_set(:@metric, metric_dsl)
+
+    notify_dsl = NotifyDSL.new({})
+    notify_dsl.groups(['a'])
+    alert_dsl.instance_variable_set(:@notify, notify_dsl)
+
     alert_dsl.name(name)
     alert_dsl.applies(true)
     alert_dsl.message(message)
-    alert_dsl.silenced(silenced)
-    alert_dsl.notify_no_data(notify_no_data)
-    notify_dsl = MockNotifyDSL.new
-    notify_dsl.groups(['a'])
-    alert_dsl.notify(notify_dsl)
+
+    alert_dsl.no_data_timeframe(options['no_data_timeframe'])
+    alert_dsl.notify_no_data(options['notify_no_data'])
+    alert_dsl.require_full_window(options['require_full_window'])
+    alert_dsl.thresholds(options['thresholds'])
+    alert_dsl.timeout(options['timeout'])
+    alert_dsl.silenced(options['silenced'])
+
     MockAlert.new(alert_dsl)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interferon
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-03 00:00:00.000000000 Z
+date: 2017-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dogapi
@@ -231,7 +231,6 @@ files:
 - spec/fixtures/loaders2/test_sources/order_test_source.rb
 - spec/fixtures/loaders2/test_sources/secondary_source.rb
 - spec/fixtures/loaders2/test_sources/test_source.rb
-- spec/helpers/dsl_helper.rb
 - spec/helpers/loader_helper.rb
 - spec/helpers/logging_helper.rb
 - spec/helpers/mock_alert.rb
@@ -276,7 +275,6 @@ test_files:
 - spec/fixtures/loaders2/test_sources/order_test_source.rb
 - spec/fixtures/loaders2/test_sources/secondary_source.rb
 - spec/fixtures/loaders2/test_sources/test_source.rb
-- spec/helpers/dsl_helper.rb
 - spec/helpers/loader_helper.rb
 - spec/helpers/logging_helper.rb
 - spec/helpers/mock_alert.rb

data/spec/helpers/dsl_helper.rb

@@ -1,48 +0,0 @@
-module Interferon
-  module MockDSLMixin
-    def initialize
-    end
-
-    def get_or_set(field, val, block, default)
-      @hash ||= Hash.new
-      if val.nil?
-        f = @hash[field]
-        f.nil? ? default : f
-      else
-        @hash[field] = val
-      end
-    end
-  end
-
-  class MockAlertDSL < AlertDSL
-    include MockDSLMixin
-
-    def notify(v = nil)
-      get_or_set(:notify, v, nil, nil)
-    end
-
-    def metric(v = nil)
-      get_or_set(:metric, v, nil, nil)
-    end
-
-    def id(v = nil, &block)
-      get_or_set(:@id, v, block, '')
-    end
-
-    def silenced(v = nil, &block)
-      get_or_set(:@silenced, v, block, false)
-    end
-
-    def silenced_until(v = nil, &block)
-      get_or_set(:@silenced_until, v && Time.parse(v), block, Time.at(0))
-    end
-  end
-
-  class MockNotifyDSL < NotifyDSL
-    include MockDSLMixin
-  end
-
-  class MockMetricDSL < MetricDSL
-    include MockDSLMixin
-  end
-end