Add fallback_groups feature

Author: mcwqy9

lib/interferon.rb

@@ -306,6 +306,15 @@ def build_alerts_queue(hosts, alerts, groups)
             people += (groups[g] || [])
           end
 
+          # Convenience for alerts that select groups dynamically, since
+          # those groups may not exist. Allow configuration of one or more
+          # fallback_groups, that are static and are known to exist
+          if people.empty?
+            alert[:notify][:fallback_groups].each do |g|
+              people += (groups[g] || [])
+            end
+          end
+
           # queue the alert up for creation; we clone the alert to save the current state
           alerts_generated[alert[:name]] = [alert.clone, people]
           break if alert[:applies] == :once

lib/interferon/alert_dsl.rb

@@ -129,6 +129,10 @@ def groups(v = nil, &block)
       get_or_set(:@groups, v, block, [])
     end
 
+    def fallback_groups(v=nil, &block)
+      get_or_set(:@fallback_groups, v, block, [])
+    end
+
     def audit(v = nil, &block)
       get_or_set(:@audit, v, block, false)
     end

spec/lib/interferon_spec.rb

@@ -126,7 +126,40 @@
     end
   end
 
-  context 'dry_run_update_alerts_on_destination' do
+  context "#build_alerts_queue(hosts, alerts, groups)" do
+    let(:interferon) { Interferon::Interferon.new({ 'processes' => 0 }, true) }
+
+    before do
+      allow_any_instance_of(MockAlert).to receive(:evaluate)
+    end
+
+    it 'adds people to alerts when notify.groups{} is used' do
+      added = create_test_alert('name1', 'testquery3', '')
+      groups = {'a' => ['foo', 'bar']}
+      result = interferon.build_alerts_queue(['host'], [added], groups)
+      expect(result[0]['name1'][1]).to eq(['foo', 'bar'].to_set)
+    end
+
+    context 'when notify.fallback_groups{} is used' do
+      it 'adds fallback people to alerts when no other groups are found' do
+        added = create_test_alert_with_groups_and_fallback_groups(['nonexistent_group'],['fallback_group'])
+        groups = {'fallback_group' => ['biz', 'baz']}
+        result = interferon.build_alerts_queue(['host'], [added], groups)
+        expect(result[0]['name1'][1]).to eq(['biz', 'baz'].to_set)
+      end
+
+      it 'does not add fallback people to alerts when other groups are found' do
+        added = create_test_alert_with_groups_and_fallback_groups(['group'],['fallback_group'])
+        groups = {}
+        groups['group'] = ['foo', 'bar']
+        groups['fallback_groups'] = ['biz', 'baz']
+        result = interferon.build_alerts_queue(['host'], [added], groups)
+        expect(result[0]['name1'][1]).to eq(['foo', 'bar'].to_set)
+      end
+    end
+  end
+
+  context "dry_run_update_alerts_on_destination" do
     let(:interferon) { Interferon::Interferon.new({ 'processes' => 0 }, true) }
 
     before do
@@ -380,4 +413,18 @@ def create_test_alert(name, datadog_query, message, options = {})
 
     MockAlert.new(alert_dsl)
   end
+
+  def create_test_alert_with_groups_and_fallback_groups(groups=[], fallback_groups=[])
+    alert_dsl = AlertDSL.new({})
+
+    notify_dsl = NotifyDSL.new({})
+    notify_dsl.groups(groups)
+    notify_dsl.fallback_groups(fallback_groups)
+    alert_dsl.instance_variable_set(:@notify, notify_dsl)
+
+    alert_dsl.name('name1')
+    alert_dsl.applies(true)
+
+    MockAlert.new(alert_dsl)
+  end
 end