interferon 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b94afa9f628189dc66075b34239930dcfa60fa37
-  data.tar.gz: 2d566d59b5c4ac62784c359925df1e74f7711fb5
+  metadata.gz: e832b3eccfa9cec75b1e26dba0384209817c3e7e
+  data.tar.gz: 7d3673b1f98c3109f5a2b389c20cf91f6d5ddfe5
 SHA512:
-  metadata.gz: 5f458bfc7b930b91519e1b94098ba92eac52e2c0c4af9b63493d77e9230b8b787e2be63a89e0a0af7f5bc5b0edb07284dbbe1a037bf1a72914e0af32ab870730
-  data.tar.gz: 0c875b39a8df08c93588a8ea3c4726df280eb6d93a5f8e808ce58404859d6d71a22e130c5587f4412c183815be63069103d3e6a12cce85e02008f63e2f361a65
+  metadata.gz: 84ad9260f477f30a7711a7807f3f09df804a43c77493d931febbc9eb98d888441370046f3a7093c78b863b22ec625bd4eeec1c8241376710828fb7c85df591ea
+  data.tar.gz: 3fd09fa405794191e7398297511ae86e7f5d63255adf9828088351955aa339a058780801cdb3108672fed97dbb8ebf936b5db7e7866b9d3e636404cb88841330

data/.travis.yml

@@ -2,6 +2,9 @@
 language: ruby
 sudo: false
 cache: bundler
+# Update bundler before proceeding
+# Travis CI uses an old version that may cause a bunch of errors
+before_install: gem install bundler
 script:
 - bundle exec rspec
 - bundle exec rubocop

data/config.example.yaml

@@ -36,3 +36,4 @@ destinations:
       app_key: "fillmein"
       api_key: "alsomissing"
       api_timeout: 15
+      max_mute_minutes: 20160 # 14 days

data/lib/interferon/alert.rb

@@ -29,12 +29,6 @@ module Interferon
       @dsl.name(name)
     end
 
-    def silence
-      raise 'This alert has not yet been evaluated' unless @dsl
-
-      @dsl.silenced(true)
-    end
-
     def [](attr)
       raise 'This alert has not yet been evaluated' unless @dsl
 

data/lib/interferon/alert_dsl.rb

@@ -126,6 +126,10 @@ module Interferon
     def recovery(v = nil, &block)
       get_or_set(:@recovery, v, block, true)
     end
+
+    def include_tags(v = nil, &block)
+      get_or_set(:@include_tags, v, block, nil)
+    end
   end
 
   class MetricDSL

data/lib/interferon/destinations/datadog.rb

@@ -37,6 +37,7 @@ module Interferon::Destinations
       @dog = Dogapi::Client.new(*args)
 
       @existing_alerts = nil
+      @max_mute_minutes = options['max_mute_minutes']
       @dry_run = options['dry_run']
 
       # Datadog communication threads
@@ -154,6 +155,10 @@ module Interferon::Destinations
         timeout_h: alert['timeout_h'],
       }
 
+      unless alert['notify']['include_tags'].nil?
+        alert_options[:include_tags] = alert['notify']['include_tags']
+      end
+
       unless alert['evaluation_delay'].nil?
         alert_options[:evaluation_delay] = alert['evaluation_delay']
       end
@@ -271,9 +276,15 @@ EOM
           monitor_options
         )
 
-        # Unmute existing alerts that have been unsilenced.
+        # Unmute existing alerts that exceed the max silenced time
         # Datadog does not allow updates to silencing via the update_alert API call.
-        if !existing_alert['options']['silenced'].empty? && alert_options[:silenced].empty?
+        silenced = existing_alert['options']['silenced']
+        if !@max_mute_minutes.nil?
+          silenced = silenced.values.reject do |t|
+            t.nil? || t == '*' || t > Time.now.to_i + @max_mute_minutes * 60
+          end
+          @dog.unmute_monitor(id) if alert_options[:silenced].empty? && silenced.empty?
+        elsif alert_options[:silenced].empty? && !silenced.empty?
           @dog.unmute_monitor(id)
         end
       else
@@ -338,6 +349,7 @@ EOM
         query: alert_api_json['query'].strip,
         message: alert_api_json['message'].strip,
         evaluation_delay: alert_api_json['options']['evaluation_delay'],
+        include_tags: alert_api_json['options']['include_tags'],
         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'],
@@ -355,6 +367,7 @@ EOM
           notify_recovery: alert['notify']['recovery']
         ).strip,
         evaluation_delay: alert['evaluation_delay'],
+        include_tags: alert['notify']['include_tags'],
         notify_no_data: alert['notify_no_data'],
         notify_audit: alert['notify']['audit'],
         no_data_timeframe: alert['no_data_timeframe'],

data/lib/interferon/version.rb

@@ -1,3 +1,3 @@
 module Interferon
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.2.4'.freeze
 end

data/lib/interferon.rb

@@ -148,7 +148,7 @@ module Interferon
     def update_alerts(destinations, hosts, alerts, groups)
       alerts_queue, alert_errors = build_alerts_queue(hosts, alerts, groups)
       if @dry_run && !alert_errors.empty?
-        erroneous_alert_files = alerts_errors.map(&:to_s).join(', ')
+        erroneous_alert_files = alert_errors.map(&:to_s).join(', ')
         raise "Alerts failed to apply or evaluate for all hosts: #{erroneous_alert_files}"
       end
 

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

@@ -3,19 +3,27 @@ require 'interferon/destinations/datadog'
 
 describe Interferon::Destinations::Datadog do
   let(:retries) { 3 }
-  let(:datadog) do
-    Interferon::Destinations::Datadog.new(
+  let(:max_mute_minutes) { 60 }
+  let(:base_datadog_config) do
+    {
       'api_key' => 'TEST_API_KEY',
       'app_key' => 'TEST_APP_KEY',
-      'retries' => retries
+      'retries' => retries,
+    }
+  end
+  let(:datadog) do
+    Interferon::Destinations::Datadog.new(
+      base_datadog_config
     )
   end
   let(:datadog_dry_run) do
     Interferon::Destinations::Datadog.new(
-      'api_key' => 'TEST_API_KEY',
-      'app_key' => 'TEST_APP_KEY',
-      'retries' => retries,
-      'dry_run' => true
+      base_datadog_config.merge('dry_run' => true)
+    )
+  end
+  let(:datadog_max_mute) do
+    Interferon::Destinations::Datadog.new(
+      base_datadog_config.merge('max_mute_minutes' => max_mute_minutes)
     )
   end
   let(:mock_alert_id) { 123 }
@@ -80,7 +88,7 @@ describe Interferon::Destinations::Datadog do
       datadog.create_alert(mock_alert, mock_people)
     end
 
-    it 'calls dogapi to unmute when exiting alert is muted' do
+    it 'calls dogapi to unmute when existing 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 }
@@ -88,6 +96,26 @@ describe Interferon::Destinations::Datadog do
       datadog.create_alert(mock_alert, mock_people)
     end
 
+    it 'calls dogapi to unmute when existing mute exceed max_mute_minutes' 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'] = {
+        '*' => Time.now.to_i + max_mute_minutes * 60 + 10,
+      }
+      expect(datadog_max_mute).to receive(:existing_alerts).and_return(mock_response)
+      datadog_max_mute.create_alert(mock_alert, mock_people)
+    end
+
+    it 'calls dogapi to keep mute when existing mute does not exceed max_mute_minutes' do
+      expect_any_instance_of(Dogapi::Client).to receive(:update_monitor).and_return([200, ''])
+      expect_any_instance_of(Dogapi::Client).not_to receive(:unmute_monitor)
+      mock_response['Test Alert']['options']['silenced'] = {
+        '*' => Time.now.to_i + max_mute_minutes * 60 - 10,
+      }
+      expect(datadog_max_mute).to receive(:existing_alerts).and_return(mock_response)
+      datadog_max_mute.create_alert(mock_alert, mock_people)
+    end
+
     it 'calls validate monitor in dry-run' do
       expect_any_instance_of(Dogapi::Client).to receive(:validate_monitor).and_return([200, ''])
       expect(datadog_dry_run).to receive(:existing_alerts).and_return(mock_response)

data/spec/lib/interferon_spec.rb

@@ -8,62 +8,107 @@ describe Interferon::Destinations::Datadog do
   let(:the_existing_alerts) { mock_existing_alerts }
   let(:dest) { MockDest.new(the_existing_alerts) }
 
-  context 'when checking alerts have changed' do
+  shared_examples_for 'alert_option' do |alert_option, same_value, different_value, alert_dsl|
+    let(:json_message) { 'message' + "\n#{Interferon::Destinations::Datadog::ALERT_KEY}" }
+    let(:alert) do
+      alert_dsl_path = alert_dsl.nil? ? alert_option : alert_dsl
+      create_test_alert('name1', 'testquery', 'message', alert_dsl_path => same_value)
+    end
+    let(:alert_same) do
+      mock_alert_json(
+        'name2', 'testquery', json_message, 'metric alert', [1], alert_option => same_value
+      )
+    end
+    let(:alert_diff) do
+      mock_alert_json(
+        'name2', 'testquery', json_message, 'metric_alert', [1], alert_option => different_value
+      )
+    end
+
+    context 'when the options are the same' do
+      it 'should return true' do
+        expect(Interferon::Destinations::Datadog.same_alerts(alert, [], alert_same)).to be true
+      end
+    end
+
+    context 'when the options are the different' do
+      it 'should return false' do
+        expect(Interferon::Destinations::Datadog.same_alerts(alert, [], alert_diff)).to be false
+      end
+    end
+  end
+
+  describe '#same_alerts' do
+    let(:json_message) { 'message' + "\n#{Interferon::Destinations::Datadog::ALERT_KEY}" }
+
+    it 'detects a no change if alert message is the same' do
+      alert1 = create_test_alert('name1', 'testquery', 'message')
+      alert2 = mock_alert_json('name2', 'testquery', json_message)
+
+      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be true
+    end
+
     it 'detects a change if alert message is different' do
-      alert1 = create_test_alert('name1', 'testquery', 'message1')
-      alert2 = mock_alert_json('name2', 'testquery', 'message2')
+      alert1 = create_test_alert('name1', 'testquery', 'message2')
+      alert2 = mock_alert_json('name2', 'testquery', json_message)
 
       expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
     end
 
-    it 'detects a change if datadog query is different' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1')
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2')
+    it 'detects no change if datadog query is the same' do
+      alert1 = create_test_alert('name1', 'testquery', 'message')
+      alert2 = mock_alert_json('name2', 'testquery', json_message)
 
-      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
+      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be true
     end
 
-    it 'detects a change if alert notify_no_data is different' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', notify_no_data: false)
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2', nil, [1], notify_no_data: true)
+    it 'detects a change if datadog query is different' do
+      alert1 = create_test_alert('name1', 'testquery1', 'message')
+      alert2 = mock_alert_json('name2', 'testquery2', json_message)
 
       expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
     end
 
-    it 'detects a change if alert silenced is different' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', silenced: true)
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2', nil, [1], silenced: {})
+    context 'notify_no_data option' do
+      it_behaves_like('alert_option', 'notify_no_data', true, false)
+    end
 
-      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
+    context 'silenced option' do
+      it_behaves_like('alert_option', 'silenced', { 'silenced' => '*' }, false)
     end
 
-    it 'detects a change if alert no_data_timeframe is different' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', no_data_timeframe: nil)
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2', nil, [1], no_data_timeframe: 60)
+    context 'no_data_timeframe option' do
+      it_behaves_like('alert_option', 'no_data_timeframe', nil, 60)
+    end
 
-      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
+    context 'require_full_window option' do
+      it_behaves_like('alert_option', 'require_full_window', false, true)
     end
 
-    it 'detects a change if alert require_full_window is different' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', require_full_window: false)
-      alert2 = mock_alert_json(
-        'name2', 'testquery2', 'message2', nil, [1], require_full_window: true
-      )
+    context 'evaluation_delay option' do
+      it_behaves_like('alert_option', 'evaluation_delay', nil, 300)
+    end
 
-      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
+    context 'thresholds option' do
+      it_behaves_like('alert_option', 'thresholds', nil, 'critical' => 1)
     end
 
-    it 'detects a change if alert evaluation_delay is different' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1', evaluation_delay: nil)
-      alert2 = mock_alert_json('name2', 'testquery2', 'message2', nil, [1], evaluation_delay: 300)
+    context 'timeout_h option' do
+      it_behaves_like('alert_option', 'timeout_h', nil, 300)
+    end
 
-      expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be false
+    context 'include_tags option' do
+      it_behaves_like('alert_option', 'include_tags', true, false, 'notify' => 'include_tags')
     end
 
-    it 'does not detect a change when alert datadog query and message are the same' do
-      alert1 = create_test_alert('name1', 'testquery1', 'message1')
+    context 'notify_audit option' do
+      it_behaves_like('alert_option', 'notify_audit', true, false, 'notify' => 'audit')
+    end
+
+    it 'detects no change if alert silenced is true compared to wildcard hash' do
+      alert1 = create_test_alert('name1', 'testquery', 'message', 'silenced' => true)
       alert2 = mock_alert_json(
-        'name1', 'testquery1', "message1\nThis alert was created via the alerts framework"
+        'name2', 'testquery', json_message, 'metric alert', [1], 'silenced' => { '*' => nil }
       )
 
       expect(Interferon::Destinations::Datadog.same_alerts(alert1, [], alert2)).to be true
@@ -271,7 +316,6 @@ describe Interferon::Destinations::Datadog do
 
   def mock_alert_json(name, datadog_query, message, type = 'metric alert', id = nil, options = {})
     options = DEFAULT_OPTIONS.merge(options)
-
     {
       'name' => name,
       'query' => datadog_query,
@@ -302,6 +346,9 @@ describe Interferon::Destinations::Datadog do
 
     notify_dsl = NotifyDSL.new({})
     notify_dsl.groups(['a'])
+    notify_dsl.audit(options['notify' => 'audit'])
+    notify_dsl.include_tags(options['notify' => 'include_tags'])
+
     alert_dsl.instance_variable_set(:@notify, notify_dsl)
 
     alert_dsl.name(name)

data/spec/spec_helper.rb

@@ -35,7 +35,7 @@ RSpec.configure do |config|
 
   # This setting enables warnings. It's recommended, but in some cases may
   # be too noisy due to issues in dependencies.
-  config.warnings = true
+  config.warnings = false
 
   # Many RSpec users commonly either run the entire suite or an individual
   # file, and it's useful to allow more verbose output when running an

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interferon
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Igor Serebryany
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2017-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dogapi