dogtrainer 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61ad47a205486a220109a1e79127f4c7e5d13724
-  data.tar.gz: 054eb39e28f43c41599d64840813da35d78210b3
+  metadata.gz: 9d7837f6e54fe84c9f57427f5d2b9e861ef4f877
+  data.tar.gz: b82006e011dddfd1b7824286a4e35e2f386f8037
 SHA512:
-  metadata.gz: 81048ff88866c2439e90d0ff18d46ece9480a73c8b8358a4b975f4b59c38bf6415c9018502b82092ad240c8dc2dbd7a12f38afdda251098287b81a68f12fb84a
-  data.tar.gz: 0cd934673286968e9657102fc9f11c156e4ad8817e3d86ec4c2881601a43e0cbdebb135ebee3c7aeed6ec790abd4442e9795805a277583bdd04e5f6a205e0fd4
+  metadata.gz: 3c107adb47eb154d18d0a82f7cece1ecdb383a7e8978b03c91f0f687e18eaf2b1a552930e0f7c3bece0a3c3646976c44a27484022f9ad8fd8138ab878fe7e322
+  data.tar.gz: 013e429c47d13a91c39cd11ef5a495bd045ec88a2b5fef12bf84a2b35ae2548625e7341201aa3529cc7c286c117479e8bb4de20ff58156768f89a72e7773ba22

data/.rubocop.yml

@@ -27,4 +27,16 @@ Style/PreferredHashMethods:
     - 'lib/dogtrainer/api.rb'
 
 Metrics/BlockLength:
-  Max: 2000
+  Max: 3000
+
+Lint/RescueWithoutErrorClass:
+  Exclude:
+    - 'lib/dogtrainer/api.rb'
+
+Performance/Caller:
+  Exclude:
+    - 'lib/dogtrainer/api.rb'
+
+Performance/HashEachMethods:
+  Exclude:
+    - 'lib/dogtrainer/api.rb'

data/ChangeLog.md

@@ -1,3 +1,8 @@
+Version 0.4.0
+
+  - Added support for ``:no_data_timeframe`` and ``:evaluation_delay`` options
+    on monitors.
+
 Version 0.3.0
 
   - Added ``DogTrainer::DogApiException`` custom exception class, subclass of ``StandardError``.

data/README.md

@@ -102,12 +102,15 @@ puts "aws.ec2.host_ok monitor id: #{id}"
 Metric alert, also alerting on missing data:
 
 ```ruby
-# alert if 'MY_ASG_NAME' ASG in service instances < 2
+# alert if 'MY_ASG_NAME' ASG in service instances < 2; set no_data_timeframe
+# to 60 minutes and evaluation_delay to 900 seconds, for sparse AWS metrics
 dog.upsert_monitor(
   "ASG In-Service Instances",
   "avg(last_5m):sum:aws.autoscaling.group_in_service_instances{autoscaling_group:MY_ASG_NAME} < 2",
   2,
-  '>='
+  '>=',
+  no_data_timeframe: 60,
+  evaluation_delay: 900
 )
 ```
 

data/Rakefile

@@ -36,7 +36,7 @@ namespace :yard do
 end
 
 desc 'Run specs and rubocop before pushing'
-task pre_commit: [:spec, :rubocop]
+task pre_commit: %i[spec rubocop]
 
 desc 'Display the list of available rake tasks'
 task :help do

data/dogtrainer.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+
 require File.expand_path('../lib/dogtrainer/version', __FILE__)
 
 Gem::Specification.new do |gem|

data/lib/dogtrainer/api.rb

@@ -62,7 +62,7 @@ module DogTrainer
     #
     # If none of these are found, an error will be raised.
     def get_repo_path
-      %w(GIT_URL CIRCLE_REPOSITORY_URL).each do |vname|
+      %w[GIT_URL CIRCLE_REPOSITORY_URL].each do |vname|
         return ENV[vname] if ENV.has_key?(vname) && !ENV[vname].empty?
       end
       # try to find git repository
@@ -169,6 +169,16 @@ module DogTrainer
     #   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 [Integer] :no_data_timeframe the number of minutes before
+    #   a monitor will notify when data stops reporting. Must be at least 2x the
+    #   monitor timeframe for metric alerts or 2 minutes for service checks.
+    #   Defaults to 20 minutes; API default is 2x the monitor timeframe.
+    # @option options [Integer] :evaluation_delay (metric monitors only) Time
+    #   (in seconds) to delay evaluation, as a non-negative integer. For
+    #   example, if the value is set to 300 (5min), the timeframe is set to
+    #   last_5m and the time is 7:00, the monitor will evaluate data from 6:50
+    #   to 6:55. This is useful for AWS CloudWatch and other backfilled metrics
+    #   to ensure the monitor will always have data during evaluation.
     def params_for_monitor(
       name,
       message,
@@ -178,12 +188,16 @@ module DogTrainer
         escalation_message: nil,
         alert_no_data: true,
         mon_type: 'metric alert',
-        renotify_interval: 60
+        renotify_interval: 60,
+        no_data_timeframe: 20,
+        evaluation_delay: nil
       }
     )
       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)
+      options[:no_data_timeframe] = 20 unless options.key?(:no_data_timeframe)
+      options[:evaluation_delay] = nil unless options.key?(:evaluation_delay)
 
       # handle threshold hash
       thresh = if threshold.is_a?(Hash)
@@ -207,13 +221,16 @@ module DogTrainer
           'require_full_window' => false,
           'notify_no_data' => options[:alert_no_data],
           'renotify_interval' => options[:renotify_interval],
-          'no_data_timeframe' => 20
+          'no_data_timeframe' => options[:no_data_timeframe]
         }
       }
       unless options[:escalation_message].nil?
         monitor_data['options']['escalation_message'] = \
           options[:escalation_message]
       end
+      unless options[:evaluation_delay].nil?
+        monitor_data['options']['evaluation_delay'] = options[:evaluation_delay]
+      end
       monitor_data
     end
 
@@ -248,6 +265,16 @@ module DogTrainer
     #   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 [Integer] :no_data_timeframe the number of minutes before
+    #   a monitor will notify when data stops reporting. Must be at least 2x the
+    #   monitor timeframe for metric alerts or 2 minutes for service checks.
+    #   Defaults to 20 minutes; API default is 2x the monitor timeframe.
+    # @option options [Integer] :evaluation_delay (metric monitors only) Time
+    #   (in seconds) to delay evaluation, as a non-negative integer. For
+    #   example, if the value is set to 300 (5min), the timeframe is set to
+    #   last_5m and the time is 7:00, the monitor will evaluate data from 6:50
+    #   to 6:55. This is useful for AWS CloudWatch and other backfilled metrics
+    #   to ensure the monitor will always have data during evaluation.
     # @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
@@ -263,12 +290,16 @@ module DogTrainer
         alert_no_data: true,
         mon_type: 'metric alert',
         renotify_interval: 60,
+        no_data_timeframe: 20,
+        evaluation_delay: nil,
         message: nil
       }
     )
       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)
+      options[:no_data_timeframe] = 20 unless options.key?(:no_data_timeframe)
+      options[:evaluation_delay] = nil unless options.key?(:evaluation_delay)
 
       msg, esc = generate_messages(mon_name, comparator, options[:mon_type])
       message = if options[:message].nil?
@@ -283,11 +314,15 @@ module DogTrainer
                    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],
-                                      renotify_interval: rno)
+      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],
+        renotify_interval: rno,
+        no_data_timeframe: options[:no_data_timeframe],
+        evaluation_delay: options[:evaluation_delay]
+      )
       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.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/spec/unit/api_spec.rb

@@ -80,13 +80,13 @@ describe DogTrainer::API do
     context 'with custom accepted_codes' do
       describe 'when code is in accepted array' do
         it 'does not raise an exception' do
-          expect { subject.check_dog_result(['404', response], %w(200 404)) }
+          expect { subject.check_dog_result(['404', response], %w[200 404]) }
             .to_not raise_error
         end
       end
       describe 'when code is not in accepted array' do
         it 'raises an exception' do
-          expect { subject.check_dog_result(['400', response], %w(200 404)) }
+          expect { subject.check_dog_result(['400', response], %w[200 404]) }
             .to raise_error DogTrainer::DogApiException,
                             /Datadog API call returned status 400/
         end
@@ -95,26 +95,34 @@ describe DogTrainer::API do
   end
   describe '#get_repo_path' do
     it 'calls #get_git_url_for_directory if ENV vars are not set' do
-      allow(ENV).to receive(:has_key?).with('GIT_URL').and_return(false)
-      allow(ENV).to receive(:has_key?).with('CIRCLE_REPOSITORY_URL')
+      allow(ENV).to receive(:has_key?)
+        .with('GIT_URL')
+        .and_return(false)
+      allow(ENV).to receive(:has_key?)
+        .with('CIRCLE_REPOSITORY_URL')
         .and_return(false)
       allow(subject).to receive(:caller)
         .and_return(['foo', 'my/path/Rakefile:123'])
-      allow(subject).to receive(:get_git_url_for_directory).with(any_args)
+      allow(subject).to receive(:get_git_url_for_directory)
+        .with(any_args)
         .and_return('my/repo/path')
 
-      expect(subject).to receive(:get_git_url_for_directory).with('my/path')
+      expect(subject).to receive(:get_git_url_for_directory)
+        .with('my/path')
         .once
       expect(subject.get_repo_path).to eq('my/repo/path')
     end
     it 'raises an Exception if #get_git_url_for_directory returns nil' do
-      allow(ENV).to receive(:has_key?).with('GIT_URL').and_return(false)
-      allow(ENV).to receive(:has_key?).with('CIRCLE_REPOSITORY_URL')
+      allow(ENV).to receive(:has_key?)
+        .with('GIT_URL')
+        .and_return(false)
+      allow(ENV).to receive(:has_key?)
+        .with('CIRCLE_REPOSITORY_URL')
         .and_return(false)
       allow(subject).to receive(:caller)
         .and_return(['foo', 'my/path/Rakefile:123'])
       allow(subject).to receive(:get_git_url_for_directory).with(any_args)
-        .and_return(nil)
+                                                           .and_return(nil)
 
       expect(subject).to receive(:get_git_url_for_directory)
         .with('my/path').once
@@ -126,11 +134,11 @@ describe DogTrainer::API do
     it 'returns GIT_URL if set' do
       allow(ENV).to receive(:has_key?).with('GIT_URL').and_return(true)
       allow(ENV).to receive(:has_key?).with('CIRCLE_REPOSITORY_URL')
-        .and_return(true)
+                                      .and_return(true)
 
       allow(ENV).to receive(:[]).with('GIT_URL').and_return('my/git/url')
       allow(ENV).to receive(:[]).with('CIRCLE_REPOSITORY_URL')
-        .and_return('my/circle/url')
+                                .and_return('my/circle/url')
       allow(subject).to receive(:caller)
       allow(subject).to receive(:get_git_url_for_directory)
 
@@ -330,6 +338,61 @@ describe DogTrainer::API do
                renotify_interval: 120
       )).to eq(expected)
     end
+    it 'sets no_data_timeframe 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' => 60,
+          'no_data_timeframe' => 66
+        }
+      }
+      expect(subject.params_for_monitor(
+               'monname',
+               'my_msg',
+               'my_query',
+               123.4,
+               no_data_timeframe: 66
+      )).to eq(expected)
+    end
+    it 'sets evaluation_delay 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' => 60,
+          'no_data_timeframe' => 20,
+          'evaluation_delay' => 900
+        }
+      }
+      expect(subject.params_for_monitor(
+               'monname',
+               'my_msg',
+               'my_query',
+               123.4,
+               evaluation_delay: 900
+      )).to eq(expected)
+    end
     it 'passes through a threshold Hash' do
       expected = {
         'name' => 'monname',
@@ -408,8 +471,9 @@ describe DogTrainer::API do
           'require_full_window' => false,
           'notify_no_data' => false,
           'renotify_interval' => 123,
-          'no_data_timeframe' => 20,
-          'escalation_message' => 'myesc'
+          'no_data_timeframe' => 60,
+          'escalation_message' => 'myesc',
+          'evaluation_delay' => 345
         }
       }
       expect(subject.params_for_monitor(
@@ -420,7 +484,9 @@ describe DogTrainer::API do
                alert_no_data: false,
                mon_type: 'foo',
                escalation_message: 'myesc',
-               renotify_interval: 123
+               renotify_interval: 123,
+               no_data_timeframe: 60,
+               evaluation_delay: 345
       )).to eq(expected)
     end
   end
@@ -431,26 +497,30 @@ describe DogTrainer::API do
       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))
+                                                   .and_return(%w[msg esc])
       allow(subject).to receive(:params_for_monitor).with(any_args)
-        .and_return(params)
+                                                    .and_return(params)
       allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
-        .and_return(nil)
+                                                              .and_return(nil)
       allow(subject).to receive(:create_monitor).with(any_args)
-        .and_return('12345')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to receive(:create_monitor).once
-        .with('mname', params)
+                                                 .with('mname', params)
 
       expect(subject.upsert_monitor(
                'mname',
@@ -465,27 +535,31 @@ describe DogTrainer::API do
       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))
+                                                   .and_return(%w[msg esc])
       allow(subject).to receive(:params_for_monitor).with(any_args)
-        .and_return(params)
+                                                    .and_return(params)
       allow(subject).to receive(:get_existing_monitor_by_name).with(any_args)
-        .and_return(nil)
+                                                              .and_return(nil)
       allow(subject).to receive(:create_monitor).with(any_args)
-        .and_return('12345')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+              renotify_interval: 60,
+              no_data_timeframe: 20,
+              evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to receive(:create_monitor).once
-        .with('mname', params)
+                                                 .with('mname', params)
 
       expect(subject.upsert_monitor(
                'mname',
@@ -501,24 +575,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -543,28 +622,34 @@ describe DogTrainer::API do
       }
       dog = double(Dogapi::Client)
       allow(dog).to receive(:update_monitor).with(any_args)
-        .and_return(['200', {}])
+                                            .and_return(['200', {}])
       subject.instance_variable_set('@dog', dog)
-      allow(subject).to receive(:generate_messages).with(any_args)
-        .and_return(%w(msg esc))
+      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(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')
+                                                .and_return('12345')
 
       expect(dog).to receive(:update_monitor).once
-        .with('monid', 'my_query', params)
-      expect(subject).to receive(:generate_messages).once
+                                             .with('monid', 'my_query', params)
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -584,28 +669,33 @@ describe DogTrainer::API do
       }
       dog = double(Dogapi::Client)
       allow(dog).to receive(:update_monitor).with(any_args)
-        .and_return(['200', {}])
+                                            .and_return(['200', {}])
       subject.instance_variable_set('@dog', dog)
       allow(subject).to receive(:generate_messages).with(any_args)
-        .and_return(%w(msg esc))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to receive(:update_monitor).once
-        .with('monid', 'my_query', params)
-      expect(subject).to receive(:generate_messages).once
+                                             .with('monid', 'my_query', params)
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -633,30 +723,36 @@ describe DogTrainer::API do
       allow(dog).to receive(:update_monitor).with(any_args).and_return(res)
       subject.instance_variable_set('@dog', dog)
       allow(subject).to receive(:generate_messages).with(any_args)
-        .and_return(%w(msg esc))
+                                                   .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(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')
+                                                .and_return('12345')
       allow(subject.logger).to receive(:debug).with(any_args)
       allow(subject.logger).to receive(:info).with(any_args)
       allow(subject.logger).to receive(:error).with(any_args)
 
       expect(dog).to receive(:update_monitor).once
-        .with('monid', 'my_query', params)
-      expect(subject).to receive(:generate_messages).once
+                                             .with('monid', 'my_query', params)
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
-      expect(subject.logger).to receive(:error).once
+      expect(subject.logger).to receive(:error)
+        .once
         .with("\tError updating monitor monid: #{res}")
 
       expect(subject.upsert_monitor(
@@ -673,24 +769,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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',
-                                                 renotify_interval: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -708,24 +809,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'foobar')
-      expect(subject).to receive(:params_for_monitor).once
+      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',
-                                                 renotify_interval: 60)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -743,24 +849,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+                                                 renotify_interval: 100,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -771,6 +882,86 @@ describe DogTrainer::API do
                renotify_interval: 100
       )).to eq('monid')
     end
+    it 'handles sparse options, with only no_data_timeframe' 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: 60,
+                                                 no_data_timeframe: 100,
+                                                 evaluation_delay: 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,
+               '>=',
+               no_data_timeframe: 100
+      )).to eq('monid')
+    end
+    it 'handles sparse options, with only evaluation_delay' 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: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: 234)
+      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,
+               '>=',
+               evaluation_delay: 234
+      )).to eq('monid')
+    end
     it 'handles sparse options, with only message' do
       params = { 'foo' => 'bar', 'baz' => 'blam' }
       existing = { 'foo' => 'bar', 'baz' => 'blam', 'id' => 'monid' }
@@ -778,24 +969,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -813,24 +1009,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -848,24 +1049,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+                                                 renotify_interval: 60,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -884,24 +1090,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'metric alert')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+                                                 escalation_message: nil,
+                                                 no_data_timeframe: 20,
+                                                 evaluation_delay: nil)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -919,24 +1130,29 @@ describe DogTrainer::API do
       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))
+                                                   .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(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')
+                                                .and_return('12345')
 
       expect(dog).to_not receive(:update_monitor)
-      expect(subject).to receive(:generate_messages).once
+      expect(subject).to receive(:generate_messages)
+        .once
         .with('mname', '>=', 'service check')
-      expect(subject).to receive(:params_for_monitor).once
+      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)
+                                                 renotify_interval: 10,
+                                                 no_data_timeframe: 123,
+                                                 evaluation_delay: 456)
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mname')
+                                                               .with('mname')
       expect(subject).to_not receive(:create_monitor)
 
       expect(subject.upsert_monitor(
@@ -948,7 +1164,9 @@ describe DogTrainer::API do
                alert_no_data: false,
                mon_type: 'service check',
                message: 'foo',
-               escalation_message: 'bar'
+               escalation_message: 'bar',
+               no_data_timeframe: 123,
+               evaluation_delay: 456
       )).to eq('monid')
     end
   end
@@ -961,7 +1179,8 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
       allow(subject.logger).to receive(:error).with(any_args)
 
-      expect(dog).to receive(:monitor).once
+      expect(dog).to receive(:monitor)
+        .once
         .with(params['type'], params['query'], params)
       expect(subject.logger).to_not receive(:error)
       expect(subject.create_monitor('foo', params)).to eq('monid')
@@ -974,9 +1193,11 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
       allow(subject.logger).to receive(:error).with(any_args)
 
-      expect(dog).to receive(:monitor).once
+      expect(dog).to receive(:monitor)
+        .once
         .with(params['type'], params['query'], params)
-      expect(subject.logger).to receive(:error).once
+      expect(subject.logger).to receive(:error)
+        .once
         .with("\tError creating monitor: #{res}")
       expect(subject.create_monitor('foo', params)).to be_nil
     end
@@ -992,7 +1213,7 @@ describe DogTrainer::API do
       ]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_monitors).with(any_args)
-        .and_return(monitors)
+                                              .and_return(monitors)
       subject.instance_variable_set('@dog', dog)
 
       expect(dog).to receive(:get_all_monitors).once.with(group_states: 'all')
@@ -1009,7 +1230,7 @@ describe DogTrainer::API do
       ]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_monitors).with(any_args)
-        .and_return(monitors)
+                                              .and_return(monitors)
       subject.instance_variable_set('@dog', dog)
       subject.instance_variable_set('@monitors', monitors)
 
@@ -1021,7 +1242,7 @@ describe DogTrainer::API do
       monitors = ['200', []]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_monitors).with(any_args)
-        .and_return(monitors)
+                                              .and_return(monitors)
       subject.instance_variable_set('@dog', dog)
 
       expect(dog).to receive(:get_all_monitors).once.with(group_states: 'all')
@@ -1050,7 +1271,7 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
 
       expect(dog).to receive(:mute_monitor).once
-        .with(12_345, end: 6_789)
+                                           .with(12_345, end: 6_789)
       expect(subject).to receive(:check_dog_result).once.with(resp)
       subject.mute_monitor_by_id(12_345, end_timestamp: 6_789)
     end
@@ -1067,7 +1288,7 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
 
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mymon')
+                                                               .with('mymon')
       expect(dog).to receive(:mute_monitor).once.with(5_678)
       expect(subject).to receive(:check_dog_result).once.with(resp)
       subject.mute_monitor_by_name('mymon')
@@ -1083,7 +1304,7 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
 
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mymon')
+                                                               .with('mymon')
       expect(dog).to receive(:mute_monitor).once.with(5_678, end: 1_234)
       expect(subject).to receive(:check_dog_result).once.with(resp)
       subject.mute_monitor_by_name('mymon', end_timestamp: 1_234)
@@ -1098,7 +1319,7 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
 
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mymon')
+                                                               .with('mymon')
       expect(dog).to_not receive(:mute_monitor)
       expect(subject).to_not receive(:check_dog_result)
       expect { subject.mute_monitor_by_name('mymon') }
@@ -1118,9 +1339,11 @@ describe DogTrainer::API do
       allow(subject).to receive(:mute_monitor_by_id)
 
       expect(subject).to receive(:get_monitors).once
-      expect(subject).to receive(:mute_monitor_by_id).once
+      expect(subject).to receive(:mute_monitor_by_id)
+        .once
         .with(1, end_timestamp: nil)
-      expect(subject).to receive(:mute_monitor_by_id).once
+      expect(subject).to receive(:mute_monitor_by_id)
+        .once
         .with(4, end_timestamp: nil)
       subject.mute_monitors_by_regex(/monitor/)
     end
@@ -1135,9 +1358,11 @@ describe DogTrainer::API do
       allow(subject).to receive(:mute_monitor_by_id)
 
       expect(subject).to receive(:get_monitors).once
-      expect(subject).to receive(:mute_monitor_by_id).once
+      expect(subject).to receive(:mute_monitor_by_id)
+        .once
         .with(1, end_timestamp: nil)
-      expect(subject).to receive(:mute_monitor_by_id).once
+      expect(subject).to receive(:mute_monitor_by_id)
+        .once
         .with(4, end_timestamp: nil)
       subject.mute_monitors_by_regex('monitor')
     end
@@ -1152,9 +1377,11 @@ describe DogTrainer::API do
       allow(subject).to receive(:mute_monitor_by_id)
 
       expect(subject).to receive(:get_monitors).once
-      expect(subject).to receive(:mute_monitor_by_id).once
+      expect(subject).to receive(:mute_monitor_by_id)
+        .once
         .with(1, end_timestamp: 1_234)
-      expect(subject).to receive(:mute_monitor_by_id).once
+      expect(subject).to receive(:mute_monitor_by_id)
+        .once
         .with(4, end_timestamp: 1_234)
       subject.mute_monitors_by_regex('monitor', end_timestamp: 1_234)
     end
@@ -1180,7 +1407,7 @@ describe DogTrainer::API do
       subject.instance_variable_set('@dog', dog)
 
       expect(dog).to receive(:unmute_monitor).once
-        .with(12_345, all_scopes: true)
+                                             .with(12_345, all_scopes: true)
       expect(subject).to receive(:check_dog_result).once.with(resp)
       subject.unmute_monitor_by_id(12_345)
     end
@@ -1193,9 +1420,9 @@ describe DogTrainer::API do
         .and_return(monitor)
 
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mymon')
+                                                               .with('mymon')
       expect(subject).to receive(:unmute_monitor_by_id).once
-        .with(5_678)
+                                                       .with(5_678)
       subject.unmute_monitor_by_name('mymon')
     end
     it 'raises error if monitor cannot be found' do
@@ -1204,7 +1431,7 @@ describe DogTrainer::API do
         .and_return(nil)
 
       expect(subject).to receive(:get_existing_monitor_by_name).once
-        .with('mymon')
+                                                               .with('mymon')
       expect(subject).to_not receive(:unmute_monitor_by_id)
       expect { subject.unmute_monitor_by_name('mymon') }
         .to raise_error(RuntimeError,
@@ -1320,7 +1547,7 @@ describe DogTrainer::API do
         'title' => 'gtitle'
       }
       expect(
-        subject.graphdef('gtitle', %w(query1 query2 query3))
+        subject.graphdef('gtitle', %w[query1 query2 query3])
       ).to eq(expected)
     end
     it 'adds markers if specified' do
@@ -1375,13 +1602,14 @@ describe DogTrainer::API do
       allow(dog).to receive(:update_dashboard).with(any_args)
       subject.instance_variable_set('@dog', dog)
       allow(subject).to receive(:get_existing_timeboard_by_name).with(any_args)
-        .and_return(nil)
+                                                                .and_return(nil)
       allow(subject.logger).to receive(:info).with(any_args)
       allow(subject).to receive(:check_dog_result)
 
       expect(subject).to receive(:get_existing_timeboard_by_name).once
-        .with('t')
-      expect(dog).to receive(:create_dashboard).once
+                                                                 .with('t')
+      expect(dog).to receive(:create_dashboard)
+        .once
         .with(
           't',
           'created by DogTrainer RubyGem via my_repo_path',
@@ -1409,13 +1637,14 @@ describe DogTrainer::API do
       allow(dog).to receive(:create_dashboard).with(any_args)
       allow(dog).to receive(:update_dashboard).with(any_args)
       subject.instance_variable_set('@dog', dog)
-      allow(subject).to receive(:get_existing_timeboard_by_name).with(any_args)
+      allow(subject).to receive(:get_existing_timeboard_by_name)
+        .with(any_args)
         .and_return(res[1])
       allow(subject.logger).to receive(:info).with(any_args)
       allow(subject).to receive(:check_dog_result)
 
       expect(subject).to receive(:get_existing_timeboard_by_name).once
-        .with('t')
+                                                                 .with('t')
       expect(dog).to_not receive(:create_dashboard)
       expect(dog).to_not receive(:update_dashboard)
       expect(subject.logger).to receive(:info).with("\tTimeboard is up-to-date")
@@ -1439,13 +1668,14 @@ describe DogTrainer::API do
       allow(dog).to receive(:create_dashboard).with(any_args)
       allow(dog).to receive(:update_dashboard).with(any_args).and_return(res)
       subject.instance_variable_set('@dog', dog)
-      allow(subject).to receive(:get_existing_timeboard_by_name).with(any_args)
+      allow(subject).to receive(:get_existing_timeboard_by_name)
+        .with(any_args)
         .and_return(res[1])
       allow(subject.logger).to receive(:info).with(any_args)
       allow(subject).to receive(:check_dog_result)
 
       expect(subject).to receive(:get_existing_timeboard_by_name).once
-        .with('t')
+                                                                 .with('t')
       expect(dog).to_not receive(:create_dashboard)
       expect(dog).to receive(:update_dashboard).once.with(
         res[1]['dash']['id'],
@@ -1475,13 +1705,14 @@ describe DogTrainer::API do
       allow(dog).to receive(:create_dashboard).with(any_args)
       allow(dog).to receive(:update_dashboard).with(any_args).and_return(res)
       subject.instance_variable_set('@dog', dog)
-      allow(subject).to receive(:get_existing_timeboard_by_name).with(any_args)
+      allow(subject).to receive(:get_existing_timeboard_by_name)
+        .with(any_args)
         .and_return(res[1])
       allow(subject.logger).to receive(:info).with(any_args)
       allow(subject).to receive(:check_dog_result)
 
       expect(subject).to receive(:get_existing_timeboard_by_name).once
-        .with('t')
+                                                                 .with('t')
       expect(dog).to_not receive(:create_dashboard)
       expect(dog).to receive(:update_dashboard).once.with(
         res[1]['dash']['id'],
@@ -1511,13 +1742,14 @@ describe DogTrainer::API do
       allow(dog).to receive(:create_dashboard).with(any_args)
       allow(dog).to receive(:update_dashboard).with(any_args).and_return(res)
       subject.instance_variable_set('@dog', dog)
-      allow(subject).to receive(:get_existing_timeboard_by_name).with(any_args)
+      allow(subject).to receive(:get_existing_timeboard_by_name)
+        .with(any_args)
         .and_return(res[1])
       allow(subject.logger).to receive(:info).with(any_args)
       allow(subject).to receive(:check_dog_result)
 
       expect(subject).to receive(:get_existing_timeboard_by_name).once
-        .with('t')
+                                                                 .with('t')
       expect(dog).to_not receive(:create_dashboard)
       expect(dog).to receive(:update_dashboard).once.with(
         res[1]['dash']['id'],
@@ -1552,8 +1784,9 @@ describe DogTrainer::API do
       allow(subject.logger).to receive(:info).with(any_args)
 
       expect(subject).to receive(:get_existing_screenboard_by_name).once
-        .with('t')
-      expect(dog).to receive(:create_screenboard).once
+                                                                   .with('t')
+      expect(dog).to receive(:create_screenboard)
+        .once
         .with(
           board_title: 't',
           description: 'created by DogTrainer RubyGem via my_repo_path',
@@ -1584,7 +1817,7 @@ describe DogTrainer::API do
       allow(subject.logger).to receive(:info).with(any_args)
 
       expect(subject).to receive(:get_existing_screenboard_by_name).once
-        .with('t')
+                                                                   .with('t')
       expect(dog).to_not receive(:create_screenboard)
       expect(dog).to_not receive(:update_screenboard)
       expect(subject.logger).to receive(:info)
@@ -1612,9 +1845,10 @@ describe DogTrainer::API do
       allow(subject.logger).to receive(:info).with(any_args)
 
       expect(subject).to receive(:get_existing_screenboard_by_name).once
-        .with('t')
+                                                                   .with('t')
       expect(dog).to_not receive(:create_screenboard)
-      expect(dog).to_not receive(:update_screenboard).once
+      expect(dog).to_not receive(:update_screenboard)
+        .once
         .with(
           'id1',
           board_title: 't',
@@ -1645,9 +1879,10 @@ describe DogTrainer::API do
       allow(subject.logger).to receive(:info).with(any_args)
 
       expect(subject).to receive(:get_existing_screenboard_by_name).once
-        .with('t')
+                                                                   .with('t')
       expect(dog).to_not receive(:create_screenboard)
-      expect(dog).to_not receive(:update_screenboard).once
+      expect(dog).to_not receive(:update_screenboard)
+        .once
         .with(
           'id1',
           board_title: 't',
@@ -1678,9 +1913,10 @@ describe DogTrainer::API do
       allow(subject.logger).to receive(:info).with(any_args)
 
       expect(subject).to receive(:get_existing_screenboard_by_name).once
-        .with('t')
+                                                                   .with('t')
       expect(dog).to_not receive(:create_screenboard)
-      expect(dog).to_not receive(:update_screenboard).once
+      expect(dog).to_not receive(:update_screenboard)
+        .once
         .with(
           'id1',
           board_title: 't',
@@ -1706,7 +1942,7 @@ describe DogTrainer::API do
       board = ['200', { 'foo' => 'bar', 'baz' => 'blam' }]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_dashboards).with(any_args)
-        .and_return(boards)
+                                            .and_return(boards)
       allow(dog).to receive(:get_dashboard).with(any_args).and_return(board)
       subject.instance_variable_set('@dog', dog)
 
@@ -1729,7 +1965,7 @@ describe DogTrainer::API do
       board = ['200', { 'foo' => 'bar', 'baz' => 'blam' }]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_dashboards).with(any_args)
-        .and_return(boards)
+                                            .and_return(boards)
       allow(dog).to receive(:get_dashboard).with(any_args).and_return(board)
       subject.instance_variable_set('@dog', dog)
       subject.instance_variable_set('@timeboards', boards)
@@ -1753,7 +1989,7 @@ describe DogTrainer::API do
       board = ['200', { 'foo' => 'bar', 'baz' => 'blam' }]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_dashboards).with(any_args)
-        .and_return(boards)
+                                            .and_return(boards)
       allow(dog).to receive(:get_dashboard).with(any_args).and_return(board)
       subject.instance_variable_set('@dog', dog)
       subject.instance_variable_set('@timeboards', boards)
@@ -1773,7 +2009,7 @@ describe DogTrainer::API do
       ]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_dashboards).with(any_args)
-        .and_return(boards)
+                                            .and_return(boards)
       allow(dog).to receive(:get_dashboard).with(any_args)
       subject.instance_variable_set('@dog', dog)
 
@@ -1797,7 +2033,7 @@ describe DogTrainer::API do
       board = ['200', { 'foo' => 'bar', 'baz' => 'blam' }]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_screenboards).with(any_args)
-        .and_return(boards)
+                                                  .and_return(boards)
       allow(dog).to receive(:get_screenboard).with(any_args).and_return(board)
       subject.instance_variable_set('@dog', dog)
 
@@ -1820,7 +2056,7 @@ describe DogTrainer::API do
       board = ['200', { 'foo' => 'bar', 'baz' => 'blam' }]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_screenboards).with(any_args)
-        .and_return(boards)
+                                                  .and_return(boards)
       allow(dog).to receive(:get_screenboard).with(any_args).and_return(board)
       subject.instance_variable_set('@dog', dog)
       subject.instance_variable_set('@screenboards', boards)
@@ -1844,7 +2080,7 @@ describe DogTrainer::API do
       board = ['200', { 'foo' => 'bar', 'baz' => 'blam' }]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_screenboards).with(any_args)
-        .and_return(boards)
+                                                  .and_return(boards)
       allow(dog).to receive(:get_screenboard).with(any_args).and_return(board)
       subject.instance_variable_set('@dog', dog)
       subject.instance_variable_set('@screenboards', boards)
@@ -1864,7 +2100,7 @@ describe DogTrainer::API do
       ]
       dog = double(Dogapi::Client)
       allow(dog).to receive(:get_all_screenboards).with(any_args)
-        .and_return(boards)
+                                                  .and_return(boards)
       allow(dog).to receive(:get_screenboard).with(any_args)
       subject.instance_variable_set('@dog', dog)