dogtrainer 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b195d6ba08f5c8305b7bed4f4aaac84f24e678e
-  data.tar.gz: 75d793bc0c14824a1c52b8155684a9cb5ab9b3e1
+  metadata.gz: 8e6664535d42df53717f7e3c2a08f59c1c69d898
+  data.tar.gz: f2dbcdc8d8f59fe052494811e168c577d504ba18
 SHA512:
-  metadata.gz: 1ded76cc831e7c7d291db142fc5233362ce5d42afb05e05c448422eba521d122541c64d797fd6920175bc5ef54711e1fc5f7207d6b5825473a7f150026f1d9af
-  data.tar.gz: d42b5f8d2e501e06f7d40eb297316d85cd295c80a8a89098aff268484d5d6a12e85374123200bf40760575c2a1439a33b3147c62a51a721c4c2aa21dc1a387d3
+  metadata.gz: e2f2dc0c0bde395d17d5f082f42945648ddf778ce381a0a342374c1213dc7fca11da4cdac8e47dfd6537309159a533be2095fe8f77044a9d76ea4f1f2e5b2766
+  data.tar.gz: 5fb760fa4430b82104498e91851059f35306807954d2244f24257184879a8864d6df9c5422b1c7c5bfe3462d78093e2b1600aab7999aaa815f570effb29bf096

data/.rubocop.yml

@@ -4,16 +4,16 @@
 #    - 'spec/unit/api_spec.rb'
 
 Metrics/AbcSize:
-  Max: 50
+  Max: 100
 
 Metrics/ClassLength:
-  Max: 300
+  Max: 999
 
 Metrics/CyclomaticComplexity:
-  Max: 10
+  Max: 100
 
 Metrics/MethodLength:
-  Max: 50
+  Max: 100
 
 Metrics/PerceivedComplexity:
   Max: 20

data/ChangeLog.md

@@ -1,3 +1,13 @@
-Version 0.0.1
+Version 0.1.1
+
+  - add ``message`` and ``escalation_message`` options to ``DogTrainer::API.upsert_monitor``
+    to allow user to easily override either or both of these
+  - handle a ``threshold`` Hash passed to ``DogTrainer::API.upsert_monitor`` and
+    ``DogTrainer::API.params_for_monitor``
+  - expose ``renotify_interval`` as an option on ``DogTrainer::API.upsert_monitor``
+  - pass ``mon_type`` through to ``DogTrainer::API.generate_messages`` and generate
+    different messages for service checks (which have warning or alert)
+
+Version 0.1.0
 
   - initial release

data/README.md

@@ -64,6 +64,10 @@ These examples all rely on the ``require`` and class instantiation above.
 
 #### Monitors
 
+These configurations currently make some assumptions; if those aren't correct
+for you, please open an issue. They also generate alert and escalation messages
+from a template; see the example below to override them.
+
 Event alert on sparse data (lack of data should not trigger an alert):
 
 ```ruby
@@ -107,6 +111,59 @@ dog.upsert_monitor(
 )
 ```
 
+Service Check ("app.ok" on host my.host.name) alert, with separate warning (2),
+critical (5) and OK (1) thresholds, evalulated over the last 6 checks:
+
+```ruby
+dog.upsert_monitor(
+  "App Health on my.host.name",
+  "\"app.ok\".over(\"host:my.host.name\").last(6).count_by_status()",
+  { 'warning' => 2, 'critical' => 5, 'ok' => 1 },
+  '<',
+  alert_no_data: false,
+  mon_type: 'service check'
+)
+```
+
+Override alert and escalation messages with your own:
+
+```ruby
+dog.upsert_monitor(
+  "ASG In-Service Instances",
+  "avg(last_5m):sum:aws.autoscaling.group_in_service_instances{autoscaling_group:MY_ASG_NAME} < 2",
+  2,
+  '>=',
+  message: 'my alert message',
+  escalation_message: 'my escalation message'
+)
+```
+
+Override only the alert message, leaving the default (generated by #generate_messages )
+escalation message:
+
+```ruby
+dog.upsert_monitor(
+  "ASG In-Service Instances",
+  "avg(last_5m):sum:aws.autoscaling.group_in_service_instances{autoscaling_group:MY_ASG_NAME} < 2",
+  2,
+  '>=',
+  message: 'my alert message'
+)
+```
+
+Completely remove the escalation message, leaving the default
+(generated by #generate_messages ) alert message:
+
+```ruby
+dog.upsert_monitor(
+  "ASG In-Service Instances",
+  "avg(last_5m):sum:aws.autoscaling.group_in_service_instances{autoscaling_group:MY_ASG_NAME} < 2",
+  2,
+  '>=',
+  escalation_message: nil
+)
+```
+
 #### Boards
 
 Create a TimeBoard with a handful of graphs about the "MY_ELB_NAME" ELB,

data/lib/dogtrainer/api.rb

@@ -97,7 +97,27 @@ module DogTrainer
     #   monitored.
     # @param comparison [String] comparison operator or description for metric
     #   vs threshold; i.e. ">=", "<=", "=", "<", etc.
-    def generate_messages(metric_desc, comparison)
+    # @option mon_type [String] type of monitor as defined in DataDog
+    #   API docs.
+    def generate_messages(metric_desc, comparison, mon_type)
+      if mon_type == 'service check'
+        message = [
+          "{{#is_alert}}'#{metric_desc}' is FAILING: {{check_message}}",
+          "{{/is_alert}}\n",
+          "{{#is_warning}}'#{metric_desc}' is WARNING: {{check_message}}",
+          "{{/is_warning}}\n",
+          "{{#is_recovery}}'#{metric_desc}' recovered: {{check_message}}",
+          "{{/is_recovery}}\n",
+          "{{#is_no_data}}'#{metric_desc}' is not reporting data",
+          "{{/is_no_data}}\n",
+          # repo path and notify to
+          '(monitor and threshold configuration for this alert is managed by ',
+          "#{@repo_path}) #{@notify_to}"
+        ].join('')
+        escalation = "'#{metric_desc}' is still in error state: " \
+          '{{check_message}}'
+        return [message, escalation]
+      end
       message = [
         "{{#is_alert}}'#{metric_desc}' should be #{comparison} {{threshold}}, ",
         "but is {{value}}.{{/is_alert}}\n",
@@ -119,7 +139,10 @@ module DogTrainer
     #   account
     # @param message [String] alert/notification message for the monitor
     # @param query [String] query for the monitor to evaluate
-    # @param threshold [Float] evaluation threshold for the monitor
+    # @param threshold [Float or Hash] evaluation threshold for the monitor;
+    #   if a Float is passed, it will be provided as the ``critical`` threshold;
+    #   otherise, a Hash in the form taken by the DataDog API should be provided
+    #   (``critical``, ``warning`` and/or ``ok`` keys, Float values)
     # @param [Hash] options
     # @option options [String] :escalation_message optional escalation message
     #   for escalation notifications. Defaults to nil.
@@ -127,6 +150,10 @@ module DogTrainer
     #   of data. Defaults to true.
     # @option options [String] :mon_type type of monitor as defined in DataDog
     #   API docs. Defaults to 'metric alert'.
+    # @option options [Integer] :renotify_interval the number of minutes after
+    #   the last notification before a monitor will re-notify on the current
+    #   status. It will re-notify only if not resolved. Default: 60. Set to nil
+    #   to disable re-notification.
     def params_for_monitor(
       name,
       message,
@@ -135,11 +162,21 @@ module DogTrainer
       options = {
         escalation_message: nil,
         alert_no_data: true,
-        mon_type: 'metric alert'
+        mon_type: 'metric alert',
+        renotify_interval: 60
       }
     )
       options[:alert_no_data] = true unless options.key?(:alert_no_data)
       options[:mon_type] = 'metric alert' unless options.key?(:mon_type)
+      options[:renotify_interval] = 60 unless options.key?(:renotify_interval)
+
+      # handle threshold hash
+      thresh = if threshold.is_a?(Hash)
+                 threshold
+               else
+                 { 'critical' => threshold }
+               end
+
       monitor_data = {
         'name' => name,
         'type' => options[:mon_type],
@@ -151,10 +188,10 @@ module DogTrainer
           'locked' => false,
           'timeout_h' => 0,
           'silenced' => {},
-          'thresholds' => { 'critical' => threshold },
+          'thresholds' => thresh,
           'require_full_window' => false,
           'notify_no_data' => options[:alert_no_data],
-          'renotify_interval' => 60,
+          'renotify_interval' => options[:renotify_interval],
           'no_data_timeframe' => 20
         }
       }
@@ -178,7 +215,10 @@ module DogTrainer
     # @param mon_name [String] name for the monitor; must be unique per DataDog
     #   account
     # @param query [String] query for the monitor to evaluate
-    # @param threshold [Float] evaluation threshold for the monitor
+    # @param threshold [Float or Hash] evaluation threshold for the monitor;
+    #   if a Float is passed, it will be provided as the ``critical`` threshold;
+    #   otherise, a Hash in the form taken by the DataDog API should be provided
+    #   (``critical``, ``warning`` and/or ``ok`` keys, Float values)
     # @param comparator [String] comparison operator for metric vs threshold,
     #   describing the inverse of the query. I.e. if the query is checking for
     #   "< 100", then the comparator would be ">=".
@@ -187,20 +227,50 @@ module DogTrainer
     #   of data. Defaults to true.
     # @option options [String] :mon_type type of monitor as defined in DataDog
     #   API docs. Defaults to 'metric alert'.
+    # @option options [Integer] :renotify_interval the number of minutes after
+    #   the last notification before a monitor will re-notify on the current
+    #   status. It will re-notify only if not resolved. Default: 60. Set to nil
+    #   to disable re-notification.
+    # @option options [String] :message alert/notification message for the
+    #   monitor; if omitted, will be generated by #generate_messages
+    # @option options [String] :escalation_message optional escalation message
+    #   for escalation notifications. If omitted, will be generated by
+    #   #generate_messages; explicitly set to nil to not add an escalation
+    #   message to the monitor.
     def upsert_monitor(
       mon_name,
       query,
       threshold,
       comparator,
-      options = { alert_no_data: true, mon_type: 'metric alert' }
+      options = {
+        alert_no_data: true,
+        mon_type: 'metric alert',
+        renotify_interval: 60,
+        message: nil
+      }
     )
       options[:alert_no_data] = true unless options.key?(:alert_no_data)
       options[:mon_type] = 'metric alert' unless options.key?(:mon_type)
-      message, escalation = generate_messages(mon_name, comparator)
+      options[:renotify_interval] = 60 unless options.key?(:renotify_interval)
+
+      msg, esc = generate_messages(mon_name, comparator, options[:mon_type])
+      message = if options[:message].nil?
+                  msg
+                else
+                  options[:message]
+                end
+      escalation = if options.key?(:escalation_message)
+                     options[:escalation_message]
+                   else
+                     esc
+                   end
+
+      rno = options[:renotify_interval]
       mon_params = params_for_monitor(mon_name, message, query, threshold,
                                       escalation_message: escalation,
                                       alert_no_data: options[:alert_no_data],
-                                      mon_type: options[:mon_type])
+                                      mon_type: options[:mon_type],
+                                      renotify_interval: rno)
       logger.info "Upserting monitor: #{mon_name}"
       monitor = get_existing_monitor_by_name(mon_name)
       return create_monitor(mon_name, mon_params) if monitor.nil?

data/lib/dogtrainer/version.rb

@@ -1,4 +1,4 @@
 module DogTrainer
   # store the verson of the Gem/module; used in the gemspec and in messages
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

data/spec/unit/api_spec.rb

@@ -148,21 +148,44 @@ describe DogTrainer::API do
     end
   end
   describe '#generate_messages' do
-    it 'returns the appropriate message' do
-      expected = "{{#is_alert}}'mydesc' should be comp {{threshold}},"
-      expected += " but is {{value}}.{{/is_alert}}\n"
-      expected += "{{#is_recovery}}'mydesc' recovered  (current value "
-      expected += '{{value}} is comp threshold of {{threshold}}).'
-      expected += "{{/is_recovery}}\n(monitor and threshold configuration "
-      expected += 'for this alert is managed by my_repo_path) @my-notify-to'
-      msg, = subject.generate_messages('mydesc', 'comp')
-      expect(msg).to eq(expected)
+    context 'mon_type metric alert' do
+      it 'returns the appropriate message' do
+        expected = "{{#is_alert}}'mydesc' should be comp {{threshold}},"
+        expected += " but is {{value}}.{{/is_alert}}\n"
+        expected += "{{#is_recovery}}'mydesc' recovered  (current value "
+        expected += '{{value}} is comp threshold of {{threshold}}).'
+        expected += "{{/is_recovery}}\n(monitor and threshold configuration "
+        expected += 'for this alert is managed by my_repo_path) @my-notify-to'
+        msg, = subject.generate_messages('mydesc', 'comp', 'metric alert')
+        expect(msg).to eq(expected)
+      end
+      it 'returns the appropriate message' do
+        escalation = "'mydesc' is still in error state (current value {{value}}"
+        escalation += ' is comp threshold of {{threshold}})'
+        _, esc = subject.generate_messages('mydesc', 'comp', 'metric alert')
+        expect(esc).to eq(escalation)
+      end
     end
-    it 'returns the appropriate message' do
-      escalation = "'mydesc' is still in error state (current value {{value}}"
-      escalation += ' is comp threshold of {{threshold}})'
-      _, esc = subject.generate_messages('mydesc', 'comp')
-      expect(esc).to eq(escalation)
+    context 'mon_type service check' do
+      it 'returns the appropriate message' do
+        expected = "{{#is_alert}}'mydesc' is FAILING: {{check_message}}" \
+          "{{/is_alert}}\n"
+        expected += "{{#is_warning}}'mydesc' is WARNING: {{check_message}}" \
+          "{{/is_warning}}\n"
+        expected += "{{#is_recovery}}'mydesc' recovered: {{check_message}}" \
+          "{{/is_recovery}}\n"
+        expected += "{{#is_no_data}}'mydesc' is not reporting data" \
+          "{{/is_no_data}}\n"
+        expected += '(monitor and threshold configuration '
+        expected += 'for this alert is managed by my_repo_path) @my-notify-to'
+        msg, = subject.generate_messages('mydesc', 'comp', 'service check')
+        expect(msg).to eq(expected)
+      end
+      it 'returns the appropriate message' do
+        escalation = "'mydesc' is still in error state: {{check_message}}"
+        _, esc = subject.generate_messages('mydesc', 'comp', 'service check')
+        expect(esc).to eq(escalation)
+      end
     end
   end
   describe '#params_for_monitor' do
@@ -247,6 +270,68 @@ describe DogTrainer::API do
                mon_type: 'foo'
       )).to eq(expected)
     end
+    it 'sets renotify_interval if provided in options' do
+      expected = {
+        'name' => 'monname',
+        'type' => 'metric alert',
+        'query' => 'my_query',
+        'message' => 'my_msg',
+        'tags' => [],
+        'options' => {
+          'notify_audit' => false,
+          'locked' => false,
+          'timeout_h' => 0,
+          'silenced' => {},
+          'thresholds' => { 'critical' => 123.4 },
+          'require_full_window' => false,
+          'notify_no_data' => true,
+          'renotify_interval' => 120,
+          'no_data_timeframe' => 20
+        }
+      }
+      expect(subject.params_for_monitor(
+               'monname',
+               'my_msg',
+               'my_query',
+               123.4,
+               renotify_interval: 120
+      )).to eq(expected)
+    end
+    it 'passes through a threshold Hash' do
+      expected = {
+        'name' => 'monname',
+        'type' => 'foo',
+        'query' => 'my_query',
+        'message' => 'my_msg',
+        'tags' => [],
+        'options' => {
+          'notify_audit' => false,
+          'locked' => false,
+          'timeout_h' => 0,
+          'silenced' => {},
+          'thresholds' => {
+            'warning' => 50,
+            'critical' => 123.4,
+            'ok' => 20
+          },
+          'require_full_window' => false,
+          'notify_no_data' => true,
+          'renotify_interval' => 60,
+          'no_data_timeframe' => 20
+        }
+      }
+      expect(subject.params_for_monitor(
+               'monname',
+               'my_msg',
+               'my_query',
+               {
+                 'warning' => 50,
+                 'critical' => 123.4,
+                 'ok' => 20
+               },
+               mon_type: 'foo'
+      )).to eq(expected)
+    end
     it 'sets notify_no_data to false if provided in options' do
       expected = {
         'name' => 'monname',
@@ -289,7 +374,7 @@ describe DogTrainer::API do
           'thresholds' => { 'critical' => 123.4 },
           'require_full_window' => false,
           'notify_no_data' => false,
-          'renotify_interval' => 60,
+          'renotify_interval' => 123,
           'no_data_timeframe' => 20,
           'escalation_message' => 'myesc'
         }
@@ -301,7 +386,8 @@ describe DogTrainer::API do
                123.4,
                alert_no_data: false,
                mon_type: 'foo',
-               escalation_message: 'myesc'
+               escalation_message: 'myesc',
+               renotify_interval: 123
       )).to eq(expected)
     end
   end
@@ -321,11 +407,13 @@ describe DogTrainer::API do
         .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: true,
-                                                 mon_type: 'metric alert')
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to receive(:create_monitor).once
@@ -338,6 +426,41 @@ describe DogTrainer::API do
                '>='
       )).to eq('12345')
     end
+    it 'handles a hash threshold' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(nil)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'msg', 'my_query', { 'warning' => 5.3, 'ok' => 1 },
+              escalation_message: 'esc',
+              alert_no_data: true,
+              mon_type: 'metric alert',
+              renotify_interval: 60)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to receive(:create_monitor).once
+        .with('mname', params)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               { 'warning' => 5.3, 'ok' => 1 },
+               '>='
+      )).to eq('12345')
+    end
     it 'does nothing if it already exists with the right params' do
       params = { 'foo' => 'bar', 'baz' => 'blam' }
       existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
@@ -354,11 +477,13 @@ describe DogTrainer::API do
         .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: true,
-                                                 mon_type: 'metric alert')
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to_not receive(:create_monitor)
@@ -398,11 +523,13 @@ describe DogTrainer::API do
 
       expect(dog).to receive(:update_monitor).once
         .with('monid', 'my_query', params)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: true,
-                                                 mon_type: 'metric alert')
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to_not receive(:create_monitor)
@@ -437,11 +564,13 @@ describe DogTrainer::API do
 
       expect(dog).to receive(:update_monitor).once
         .with('monid', 'my_query', params)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: true,
-                                                 mon_type: 'metric alert')
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to_not receive(:create_monitor)
@@ -484,11 +613,13 @@ describe DogTrainer::API do
 
       expect(dog).to receive(:update_monitor).once
         .with('monid', 'my_query', params)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: true,
-                                                 mon_type: 'metric alert')
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to_not receive(:create_monitor)
@@ -518,11 +649,13 @@ describe DogTrainer::API do
         .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: false,
-                                                 mon_type: 'metric alert')
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to_not receive(:create_monitor)
@@ -551,11 +684,13 @@ describe DogTrainer::API do
         .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once.with('mname', '>=')
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'foobar')
       expect(subject).to receive(:params_for_monitor).once
         .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
                                                  alert_no_data: true,
-                                                 mon_type: 'foobar')
+                                                 mon_type: 'foobar',
+                                                 renotify_interval: 60)
       expect(subject).to receive(:get_existing_monitor_by_name).once
         .with('mname')
       expect(subject).to_not receive(:create_monitor)
@@ -568,6 +703,221 @@ describe DogTrainer::API do
                mon_type: 'foobar'
       )).to eq('monid')
     end
+    it 'handles sparse options, with only renotify_interval' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(existing)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'esc',
+                                                 alert_no_data: true,
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 100)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to_not receive(:create_monitor)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               123.4,
+               '>=',
+               renotify_interval: 100
+      )).to eq('monid')
+    end
+    it 'handles sparse options, with only message' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(existing)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'foo', 'my_query', 123.4, escalation_message: 'esc',
+                                                 alert_no_data: true,
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to_not receive(:create_monitor)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               123.4,
+               '>=',
+               message: 'foo'
+      )).to eq('monid')
+    end
+    it 'handles sparse options, with only escalation_message' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(existing)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'msg', 'my_query', 123.4, escalation_message: 'bar',
+                                                 alert_no_data: true,
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to_not receive(:create_monitor)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               123.4,
+               '>=',
+               escalation_message: 'bar'
+      )).to eq('monid')
+    end
+    it 'handles sparse options, with only message and escalation_message' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(existing)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'foo', 'my_query', 123.4, escalation_message: 'bar',
+                                                 alert_no_data: true,
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to_not receive(:create_monitor)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               123.4,
+               '>=',
+               message: 'foo',
+               escalation_message: 'bar'
+      )).to eq('monid')
+    end
+    it 'handles sparse options, with only escalation_message set to nil' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(existing)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'metric alert')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'msg', 'my_query', 123.4, alert_no_data: true,
+                                                 mon_type: 'metric alert',
+                                                 renotify_interval: 60,
+                                                 escalation_message: nil)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to_not receive(:create_monitor)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               123.4,
+               '>=',
+               escalation_message: nil
+      )).to eq('monid')
+    end
+    it 'handles all options' do
+      params = { 'foo' => 'bar', 'baz' => 'blam' }
+      existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
+      dog = double(Dogapi::Client)
+      allow(dog).to receive(:update_monitor).with(any_args)
+      subject.instance_variable_set('@dog', dog)
+      allow(subject).to receive(:generate_messages).with(any_args)
+        .and_return(%w(msg esc))
+      allow(subject).to receive(:params_for_monitor).with(any_args)
+        .and_return(params)
+      allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
+        .and_return(existing)
+      allow(subject).to receive(:create_monitor).with(any_args)
+        .and_return('12345')
+
+      expect(dog).to_not receive(:update_monitor)
+      expect(subject).to receive(:generate_messages).once
+        .with('mname', '>=', 'service check')
+      expect(subject).to receive(:params_for_monitor).once
+        .with('mname', 'foo', 'my_query', 123.4, escalation_message: 'bar',
+                                                 alert_no_data: false,
+                                                 mon_type: 'service check',
+                                                 renotify_interval: 10)
+      expect(subject).to receive(:get_existing_monitor_by_name).once
+        .with('mname')
+      expect(subject).to_not receive(:create_monitor)
+
+      expect(subject.upsert_monitor(
+               'mname',
+               'my_query',
+               123.4,
+               '>=',
+               renotify_interval: 10,
+               alert_no_data: false,
+               mon_type: 'service check',
+               message: 'foo',
+               escalation_message: 'bar'
+      )).to eq('monid')
+    end
   end
   describe '#create_monitor' do
     it 'returns the monitor id if created successfully' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dogtrainer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - jantman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-30 00:00:00.000000000 Z
+date: 2016-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dogapi