interferon 0.0.7 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf3a434f94d6e961434e2d3011613ff875c07e83
-  data.tar.gz: 56ed577469d6d97ea2a7798e12e7d0ab3f4e59a8
+  metadata.gz: 35b5382f5aabd274b548257bcc5f227faf1b951e
+  data.tar.gz: abacd2609b40bf28b2783bbd21b24c384f991188
 SHA512:
-  metadata.gz: eb304b434ad6417a9d8184bea6292bbbb80cf45edba557f34df78f7a6376bc58079257fcaa1f3d04f4826dadf991a608fed508f514a7a68d49b41295be5c46b5
-  data.tar.gz: dcd28c67b74e92a5c2a43f470ed4845a292a1d2915eeb2d7d3710e5868a17f858eeb298b42139f85c41b14408ee2882039d51d5270f011bc2b35c9d57e0e5ab0
+  metadata.gz: b215a4e355f66daa582d65b521fe0eef5842eb795551df1998844d82cb1892a64b7a95e3b60fff1ec2992eb2e88de2f584c274c9bd5570b6f0ae4026b05eeb5a
+  data.tar.gz: 2bb6ee4093fe2bbe46d811a3cb79a357066073727a699d773b306a5355fd8f7b9d06a4f2bdb51082ac6570a3166820ce7f1b88d63f9fb76d6d032fc8b97073b0

data/config.example.yaml

@@ -35,3 +35,4 @@ destinations:
     options:
       app_key: "fillmein"
       api_key: "alsomissing"
+      api_timeout: 15

data/lib/interferon/alert.rb

@@ -22,6 +22,14 @@ module Interferon
       self
     end
 
+    def change_name(name)
+      unless @dsl
+        raise "This alert has not yet been evaluated"
+      end
+
+      @dsl.name(name)
+    end
+
     def [](attr)
       unless @dsl
         raise "This alert has not yet been evaluated"

data/lib/interferon/destinations/datadog.rb

@@ -15,8 +15,22 @@ module Interferon::Destinations
         end
       end
 
-      @dog = Dogapi::Client.new(options['api_key'], options['app_key'])
-      @dry_run = !!options['dry_run']
+      # Set dogapi timeout explicitly
+      api_timeout = options['api_timeout'] || 15
+
+      # Default parameters of Dogapi Client initialize() can be referenced from link below:
+      # (as of this writing)
+      # https://github.com/DataDog/dogapi-rb/blob/master/lib/dogapi/facade.rb#L14
+      args = [
+        options['api_key'],
+        options['app_key'],
+        nil, # host to talk to
+        nil, # device
+        true, # silent?
+        api_timeout, # API timeout
+      ]
+      @dog = Dogapi::Client.new(*args)
+
       @existing_alerts = nil
 
       # create datadog alerts 10 at a time
@@ -34,9 +48,19 @@ module Interferon::Destinations
       }
     end
 
+    def api_errors
+      @api_errors ||= []
+    end
+
     def existing_alerts
       unless @existing_alerts
         resp = @dog.get_all_alerts()
+
+        code = resp[0].to_i
+        if code != 200
+          raise "Failed to retrieve existing alerts from datadog. #{code.to_s}: #{resp[1].inspect}"
+        end
+
         alerts = resp[1]['alerts']
 
         # key alerts by name
@@ -87,7 +111,7 @@ module Interferon::Destinations
         resp = @dog.alert(
           alert['metric']['datadog_query'].strip,
           alert_opts,
-        ) unless @dry_run
+        )
 
       # existing alert, modify it
       else
@@ -99,11 +123,14 @@ module Interferon::Destinations
           id,
           alert['metric']['datadog_query'].strip,
           alert_opts
-        ) unless @dry_run
+        )
       end
 
       # log whenever we've encountered errors
-      code = @dry_run ? 200 : resp[0].to_i
+      code = resp[0].to_i
+      if code != 200
+        api_errors << "#{code.to_s} on alert #{alert['name']}"
+      end
 
       # client error
       if code == 400
@@ -113,7 +140,8 @@ module Interferon::Destinations
 
         @stats[:api_client_errors] += 1
         log.error("client error while #{action} alert '#{alert['name']}';" \
-            " query was '#{alert['metric']['datadog_query'].strip}'")
+            " query was '#{alert['metric']['datadog_query'].strip}'" \
+            " response was #{resp[0]}:'#{resp[1].inspect}'")
 
       # unknown (prob. datadog) error:
       elsif code >= 400 || code == -1
@@ -138,14 +166,15 @@ module Interferon::Destinations
         @stats[:alerts_silenced] += 1 if alert_opts[:silenced]
       end
 
+      id = resp[1].nil? ? nil : resp[1]['id']
       # lets key alerts by their name
-      return alert['name']
+      return [alert['name'], id]
     end
 
     def remove_alert(alert)
       if alert['message'].include?(ALERT_KEY)
         log.debug("deleting alert #{alert['id']} (#{alert['name']})")
-        @dog.delete_alert(alert['id']) unless @dry_run
+        @dog.delete_alert(alert['id'])
         @stats[:alerts_deleted] += 1
       else
         log.warn("not deleting manually-created alert #{alert['id']} (#{alert['name']})")
@@ -163,5 +192,11 @@ module Interferon::Destinations
         @stats[:alerts_deleted],
       ]
     end
+
+    def remove_alert_by_id(alert_id)
+      log.debug("deleting alert, id: #{alert_id}")
+      @dog.delete_alert(alert_id)
+      @stats[:alerts_deleted] += 1
+    end
   end
 end

data/lib/interferon/version.rb

@@ -1,3 +1,3 @@
 module Interferon
-  VERSION = "0.0.7"
+  VERSION = "0.0.12"
 end

data/lib/interferon.rb

@@ -18,6 +18,8 @@ module Interferon
     include Logging
     attr_accessor :host_sources, :destinations, :host_info
 
+    DRY_RUN_ALERTS_NAME_PREFIX = '[-dry-run-]'
+
     # groups_sources is a hash from type => options for each group source
     # host_sources is a hash from type => options for each host source
     # destinations is a similiar hash from type => options for each alerter
@@ -41,13 +43,11 @@ module Interferon
       groups = read_groups(@groups_sources)
       hosts = read_hosts(@host_sources)
 
-      # make sure destinations know if it's a dry run
       @destinations.each do |dest|
         dest['options'] ||= {}
-        dest['options']['dry_run'] = dry_run
       end
 
-      update_alerts(@destinations, hosts, alerts, groups)
+      update_alerts(@destinations, hosts, alerts, groups, dry_run)
 
       if @request_shutdown
         log.info "interferon #{run_desc} shut down by SIGTERM"
@@ -133,132 +133,198 @@ module Interferon
       return hosts
     end
 
-    def update_alerts(destinations, hosts, alerts, groups)
+    def update_alerts(destinations, hosts, alerts, groups, dry_run)
       loader = DestinationsLoader.new([@alerts_repo_path])
       loader.get_all(destinations).each do |dest|
         break if @request_shutdown
         log.info "updating alerts on #{dest.class.name}"
+        update_alerts_on_destination(dest, hosts, alerts, groups, dry_run)
+      end
+    end
 
-        # track some counters/stats per destination
-        start_time = Time.new.to_f
-
-        # get already-defined alerts
-        existing_alerts = dest.existing_alerts.dup
-        existing_alerts.each{ |key, existing_alert| existing_alert['still_exists'] = false }
-
-        # create or update alerts; mark when we've done that
-        alerts_queue = Hash.new
-        alerts.each do |alert|
-          break if @request_shutdown
-          counters = {
-            :errors => 0,
-            :evals => 0,
-            :applies => 0,
-            :hosts => hosts.length
-          }
-          last_eval_error = nil
-
-          hosts.each do |hostinfo|
-            begin
-              alert.evaluate(hostinfo)
-              counters[:evals] += 1
-            rescue StandardError => e
-              log.debug "Evaluation of alert #{alert} failed in the context of host #{hostinfo}"
-              counters[:errors] += 1
-              last_eval_error = e
-              next
-            end
+    def update_alerts_on_destination(dest, hosts, alerts, groups, dry_run)
+      # track some counters/stats per destination
+      start_time = Time.new.to_f
 
-            # don't define an alert that doesn't apply to this hostinfo
-            unless alert[:applies]
-              log.debug "alert #{alert[:name]} doesn't apply to #{hostinfo.inspect}"
-              next
-            end
+      # get already-defined alerts
+      existing_alerts = dest.existing_alerts.dup
 
-            counters[:applies] += 1
+      if dry_run
+        do_dry_run_update(dest, hosts, alerts, existing_alerts, groups)
+      else
+        do_regular_update(dest, hosts, alerts, existing_alerts, groups)
+      end
 
-            # don't define alerts twice
-            next if alerts_queue.key?(alert[:name])
+      unless @request_shutdown
+        # run time summary
+        run_time = Time.new.to_f - start_time
+        statsd.histogram(
+          dry_run ? 'destinations.run_time.dry_run' : 'destinations.run_time',
+          run_time,
+          :tags => ["destination:#{dest.class.name}"])
+        log.info "#{dest.class.name} : run completed in %.2f seconds" % (run_time)
+
+        # report destination stats
+        dest.report_stats
+      end
 
-            # figure out who to notify
-            people = Set.new(alert[:notify][:people])
-            alert[:notify][:groups].each do |g|
-              people += (groups[g] || [])
-            end
+      if dry_run && !dest.api_errors.empty?
+        raise dest.api_errors.to_s
+      end
+    end
 
-            # queue the alert up for creation; we clone the alert to save the current state
-            alerts_queue[alert[:name]] ||= [alert.clone, people]
-          end
+    def do_dry_run_update(dest, hosts, alerts, existing_alerts, groups)
+      to_remove = existing_alerts.reject{|key, a| !key.start_with?(DRY_RUN_ALERTS_NAME_PREFIX)}
+      alerts_queue = build_alerts_queue(hosts, alerts, groups)
+      alerts_queue.reject!{|name, pair| !Interferon::need_dry_run(pair[0], existing_alerts)}
+      alerts_queue.each do |name, pair|
+        alert = pair[0]
+        alert.change_name(DRY_RUN_ALERTS_NAME_PREFIX + alert['name'])
+      end
 
-          # log some of the counters
-          statsd.gauge('alerts.evaluate.errors', counters[:errors], :tags => ["alert:#{alert}"])
-          statsd.gauge('alerts.evaluate.applies', counters[:applies], :tags => ["alert:#{alert}"])
+      # flush queue
+      created_alerts_key_ids = create_alerts(dest, alerts_queue)
+      created_alerts_ids = created_alerts_key_ids.map{|a| a[1]}
+      to_remove_ids = to_remove.empty? ? [] : to_remove.map{|a| a['id']}
+      # remove existing alerts that shouldn't exist
+      (created_alerts_ids + to_remove_ids).each do |id|
+        break if @request_shutdown
+        dest.remove_alert_by_id(id) unless id.nil?
+      end
+    end
 
-          if counters[:applies] > 0
-            log.info "alert #{alert} applies to #{counters[:applies]} of #{counters[:hosts]} hosts"
-          end
+    def do_regular_update(dest, hosts, alerts, existing_alerts, groups)
+      existing_alerts.each{ |key, existing_alert| existing_alert['still_exists'] = false }
 
-          # did the alert fail to evaluate on all hosts?
-          if counters[:errors] == counters[:hosts]
-            log.error "alert #{alert} failed to evaluate in the context of all hosts!"
-            log.error "last error on alert #{alert}: #{last_eval_error}"
+      alerts_queue = build_alerts_queue(hosts, alerts, groups)
 
-            statsd.gauge('alerts.evaluate.failed_on_all', 1, :tags => ["alert:#{alert}"])
-            log.debug "alert #{alert}: error #{last_eval_error}\n#{last_eval_error.backtrace.join("\n")}"
-          else
-            statsd.gauge('alerts.evaluate.failed_on_all', 0, :tags => ["alert:#{alert}"])
-          end
+      # flush queue
+      created_alerts_keys = create_alerts(dest, alerts_queue).map{|a| a[0]}
+      created_alerts_keys.each do |alert_key|
+        # don't delete alerts we still have defined
+        existing_alerts[alert_key]['still_exists'] = true if existing_alerts.include?(alert_key)
+      end
+
+      # remove existing alerts that shouldn't exist
+      to_delete = existing_alerts.reject{ |key, existing_alert| existing_alert['still_exists'] }
+      to_delete.each do |key, alert|
+        break if @request_shutdown
+        dest.remove_alert(alert)
+      end
+    end
 
-          # did the alert apply to any hosts?
-          if counters[:applies] == 0
-            statsd.gauge('alerts.evaluate.never_applies', 1, :tags => ["alert:#{alert}"])
-            log.warn "alert #{alert} did not apply to any hosts"
-          else
-            statsd.gauge('alerts.evaluate.never_applies', 0, :tags => ["alert:#{alert}"])
+    def create_alerts(dest, alerts_queue)
+      alert_key_ids = []
+      alerts_to_create = alerts_queue.keys
+      concurrency = dest.concurrency || 10
+      unless @request_shutdown
+        threads = concurrency.times.map do |i|
+          log.info "thread #{i} created"
+          t = Thread.new do
+            while name = alerts_to_create.shift
+              break if @request_shutdown
+              cur_alert, people = alerts_queue[name]
+              log.debug "creating alert for #{cur_alert[:name]}"
+              alert_key_ids << dest.create_alert(cur_alert, people)
+            end
           end
+          t.abort_on_exception = true
+          t
         end
+        threads.map(&:join)
+      end
+      alert_key_ids
+    end
 
-        # flush queue
-        alerts_to_create = alerts_queue.keys
-        concurrency = dest.concurrency || 10
-        unless @request_shutdown
-          threads = concurrency.times.map do |i|
-            log.info "thread #{i} created"
-            t = Thread.new do
-              while name = alerts_to_create.shift
-                break if @request_shutdown
-                cur_alert, people = alerts_queue[name]
-
-                log.debug "creating alert for #{cur_alert[:name]}"
-                alert_key = dest.create_alert(cur_alert, people)
-
-                # don't delete alerts we still have defined
-                existing_alerts[alert_key]['still_exists'] = true if existing_alerts.include?(alert_key)
-              end
-            end
-            t.abort_on_exception = true
-            t
+    def build_alerts_queue(hosts, alerts, groups)
+      # create or update alerts; mark when we've done that
+      alerts_queue = Hash.new
+      alerts.each do |alert|
+        break if @request_shutdown
+        counters = {
+          :errors => 0,
+          :evals => 0,
+          :applies => 0,
+          :hosts => hosts.length
+        }
+        last_eval_error = nil
+
+        hosts.each do |hostinfo|
+          begin
+            alert.evaluate(hostinfo)
+            counters[:evals] += 1
+          rescue StandardError => e
+            log.debug "Evaluation of alert #{alert} failed in the context of host #{hostinfo}"
+            counters[:errors] += 1
+            last_eval_error = e
+            next
           end
-          threads.map(&:join)
+
+          # don't define an alert that doesn't apply to this hostinfo
+          unless alert[:applies]
+            log.debug "alert #{alert[:name]} doesn't apply to #{hostinfo.inspect}"
+            next
+          end
+
+          counters[:applies] += 1
+          # don't define alerts twice
+          next if alerts_queue.key?(alert[:name])
+
+          # figure out who to notify
+          people = Set.new(alert[:notify][:people])
+          alert[:notify][:groups].each do |g|
+            people += (groups[g] || [])
+          end
+
+          # queue the alert up for creation; we clone the alert to save the current state
+          alerts_queue[alert[:name]] ||= [alert.clone, people]
         end
 
-        # remove existing alerts that shouldn't exist
-        to_delete = existing_alerts.reject{ |key, existing_alert| existing_alert['still_exists'] }
-        to_delete.each do |key, alert|
-          break if @request_shutdown
-          dest.remove_alert(alert)
+        # log some of the counters
+        statsd.gauge('alerts.evaluate.errors', counters[:errors], :tags => ["alert:#{alert}"])
+        statsd.gauge('alerts.evaluate.applies', counters[:applies], :tags => ["alert:#{alert}"])
+
+        if counters[:applies] > 0
+          log.info "alert #{alert} applies to #{counters[:applies]} of #{counters[:hosts]} hosts"
         end
 
-        unless @request_shutdown
-          # run time summary
-          run_time = Time.new.to_f - start_time
-          statsd.histogram('destinations.run_time', run_time, :tags => ["destination:#{dest.class.name}"])
-          log.info "#{dest.class.name} : run completed in %.2f seconds" % (run_time)
+        # did the alert fail to evaluate on all hosts?
+        if counters[:errors] == counters[:hosts]
+          log.error "alert #{alert} failed to evaluate in the context of all hosts!"
+          log.error "last error on alert #{alert}: #{last_eval_error}"
+
+          statsd.gauge('alerts.evaluate.failed_on_all', 1, :tags => ["alert:#{alert}"])
+          log.debug "alert #{alert}: error #{last_eval_error}\n#{last_eval_error.backtrace.join("\n")}"
+        else
+          statsd.gauge('alerts.evaluate.failed_on_all', 0, :tags => ["alert:#{alert}"])
+        end
 
-          # report destination stats
-          dest.report_stats
+        # did the alert apply to any hosts?
+        if counters[:applies] == 0
+          statsd.gauge('alerts.evaluate.never_applies', 1, :tags => ["alert:#{alert}"])
+          log.warn "alert #{alert} did not apply to any hosts"
+        else
+          statsd.gauge('alerts.evaluate.never_applies', 0, :tags => ["alert:#{alert}"])
         end
       end
+      alerts_queue
+    end
+
+    def self.need_dry_run(alert, existing_alerts_from_api)
+      existing = existing_alerts_from_api[alert['name']]
+      if existing.nil?
+        true
+      else
+        !same_alerts_for_dry_run_purpose(alert, existing)
+      end
+    end
+
+    def self.same_alerts_for_dry_run_purpose(alert, alert_api_json)
+      query1 = alert['metric']['datadog_query']
+      query2 = alert_api_json['query']
+      query1.strip!
+      query2.strip!
+      query1 == query2
     end
   end
 end

data/spec/helpers/dsl_helper.rb

@@ -0,0 +1,39 @@
+module Interferon
+  module MockDSLMixin
+    def initialize
+    end
+
+    def get_or_set(field, val, block, default)
+      @hash ||= Hash.new
+      if val.nil?
+        return @hash[field]
+      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
+  end
+
+  class MockNotifyDSL < NotifyDSL
+    include MockDSLMixin
+  end
+
+  class MockMetricDSL < MetricDSL
+    include MockDSLMixin
+  end
+end

data/spec/helpers/mock_alert.rb

@@ -0,0 +1,11 @@
+module Interferon
+  class MockAlert < Alert
+    def initialize(dsl)
+      @dsl = dsl
+    end
+
+    def []=(key, val)
+      @dsl.get_or_set(("@"+ key).to_sym, val, nil, nil)
+    end
+  end
+end

data/spec/lib/interferon_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'helpers/mock_alert'
+require 'helpers/dsl_helper'
+require 'interferon/destinations/datadog'
+
+include Interferon
+
+describe Interferon::Interferon do
+  it "would not be dry run if only alert message changed" do
+    alert1 = create_test_alert('name1', 'testquery', 'message1')
+    alert2 = mock_alert_json('name2', 'testquery', 'message2')
+
+    expect(Interferon::Interferon.same_alerts_for_dry_run_purpose(alert1, alert2)).to be true
+  end
+
+  it "would be dry run if alert datadog query changed" do
+    alert1 = create_test_alert('name1', 'testquery1', 'message1')
+    alert2 = mock_alert_json('name2', 'testquery2', 'message2')
+
+    expect(Interferon::Interferon.same_alerts_for_dry_run_purpose(alert1, alert2)).to be false
+  end
+
+  context "dry_run_update_alerts_on_destination" do
+    let(:the_existing_alerts) {mock_existing_alerts}
+    let(:dest) {MockDest.new(the_existing_alerts)}
+    before do
+      allow_any_instance_of(MockAlert).to receive(:evaluate)
+      allow(dest).to receive(:remove_alert_by_id)
+      allow(dest).to receive(:report_stats)
+    end
+
+    it 'dry run does not re-run existing alerts' do
+      alerts = mock_existing_alerts
+      interferon = Interferon::Interferon.new(nil,nil,nil,nil)
+      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']], {}, true)
+    end
+
+    it 'dry run runs added alerts' do
+      alerts = mock_existing_alerts
+      interferon = Interferon::Interferon.new(nil,nil,nil,nil)
+      added = create_test_alert('name3', 'testquery3', '')
+      expect(dest).to receive(:create_alert).once.and_call_original
+      expect(dest).to receive(:remove_alert_by_id).with('[-dry-run-]name3').once
+      
+      interferon.update_alerts_on_destination(dest, ['host'], [alerts['name1'], alerts['name2'], added], {}, true)
+    end
+
+    it 'dry run runs updated alerts' do
+      alerts = mock_existing_alerts
+      interferon = Interferon::Interferon.new(nil,nil,nil,nil)
+      added = create_test_alert('name1', 'testquery3', '')
+      expect(dest).to receive(:create_alert).once.and_call_original
+      expect(dest).to receive(:remove_alert_by_id).with('[-dry-run-]name1').once
+      
+      interferon.update_alerts_on_destination(dest, ['host'], [added], {}, true)
+    end
+
+    def mock_existing_alerts
+      alert1 = mock_alert_json('name1', 'testquery1', '')
+      alert2 = mock_alert_json('name2', 'testquery2', '')
+      {'name1'=>alert1, 'name2'=>alert2}
+    end
+
+    class MockDest < Interferon::Destinations::Datadog
+      @existing_alerts
+
+      def initialize(the_existing_alerts)
+        @existing_alerts = the_existing_alerts
+      end
+
+      def create_alert(alert, people)
+        name = alert['name']
+        [name, name]
+      end
+
+      def existing_alerts
+        @existing_alerts
+      end
+    end
+  end
+
+  def mock_alert_json(name, datadog_query, message)
+    {'name'=> name,'query'=> datadog_query,'message'=> message}
+  end
+
+  def create_test_alert(name, datadog_query, message)
+    alert_dsl = MockAlertDSL.new
+    metric_dsl = MockMetricDSL.new
+    metric_dsl.datadog_query(datadog_query)
+    alert_dsl.metric(metric_dsl)
+    alert_dsl.name(name)
+    alert_dsl.applies(true)
+    alert_dsl.message(message)
+    notify_dsl = MockNotifyDSL.new
+    notify_dsl.groups(['a'])
+    alert_dsl.notify(notify_dsl)
+    MockAlert.new(alert_dsl)
+  end
+end

metadata

@@ -1,104 +1,104 @@
 --- !ruby/object:Gem::Specification
 name: interferon
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.12
 platform: ruby
 authors:
 - Igor Serebryany
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-28 00:00:00.000000000 Z
+date: 2016-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dogapi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.11.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.11.1
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.35'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.35.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.35'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.35.1
 - !ruby/object:Gem::Dependency
   name: dogstatsd-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
-description: ': Store metrics alerts in code!'
+description: ": Store metrics alerts in code!"
 email:
 - igor.serebryany@airbnb.com
 executables:
@@ -106,8 +106,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -135,12 +135,15 @@ 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
 - spec/helpers/optica_helper.rb
 - spec/lib/interferon/host_sources/optica_services_spec.rb
 - spec/lib/interferon/host_sources/optica_spec.rb
 - spec/lib/interferon/loaders_spec.rb
+- spec/lib/interferon_spec.rb
 - spec/spec_helper.rb
 homepage: https://www.github.com/airbnb/interferon
 licenses:
@@ -152,20 +155,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: ': Store metrics alerts in code!'
+summary: ": Store metrics alerts in code!"
 test_files:
 - spec/fixtures/loaders/host_sources/test_host_source.rb
 - spec/fixtures/loaders/test_sources/order_test_source.rb
@@ -173,10 +176,13 @@ 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
 - spec/helpers/optica_helper.rb
 - spec/lib/interferon/host_sources/optica_services_spec.rb
 - spec/lib/interferon/host_sources/optica_spec.rb
 - spec/lib/interferon/loaders_spec.rb
+- spec/lib/interferon_spec.rb
 - spec/spec_helper.rb