lita-datadog 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 674d744f8af8eef3c2124caf7fe6f330edfed54d
-  data.tar.gz: dd9e912e13bb4ce44fd3ba42991301c68b2c8790
+  metadata.gz: 9e93b235ba1458b7bafd84b79fc69a0dacd5b4da
+  data.tar.gz: fe1a7a633fab19e2720c502c781ac26b5e7e12d8
 SHA512:
-  metadata.gz: 1e331d216b2083724b8ee65a9c939a7be060200b8a86720362b653175315a424aae3698e292830b3c3d8a1248969f1f22d867a9647a4babd959a23c9fefc000f
-  data.tar.gz: fe96cea3e2fd8a0040f81e0be28da1a0da91ec463be3890eb137ce8ac6784c5d68f08b1f7095293f26baa29d33318f1736d5ff2de816fc6e50ec1c61060b7bb6
+  metadata.gz: f7f2bfd6595bee7e7684856418e1bd8d5e7f2a98125c21068c88c9cb5e64b10938593964a7b87ab12a791ab23c496a99e2771e2807e7a1ec881821248e9de162
+  data.tar.gz: d029ea15a656fd46da382aee1cbd008b10ccf63bee0d3600d1d60f16b25828d8d4716209214bef96b31ecbcc6fef9e3009c6306eb582cc8a43209463b49c1fb2

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 *.swp
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color --profile 5

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
   - 2.1
-script: bundle exec rake
-before_install:
-  - gem update --system
+  - 2.2
 services:
   - redis-server
+sudo: false
+cache: bundler

data/README.md

@@ -81,6 +81,20 @@ to:"<time description>"
 
 Time descriptions are parsed by https://github.com/mojombo/chronic
 
+### Muting
+
+Muting a host:
+
+```
+Lita dd mute <hostname> [message:"Some reason"]
+```
+
+Unmuting a host:
+
+```
+Lita dd unmute <hostname>
+```
+
 ## License
 
 [MIT](http://opensource.org/licenses/MIT)

data/lib/lita-datadog.rb

@@ -4,6 +4,8 @@ Lita.load_locales Dir[File.expand_path(
   File.join('..', '..', 'locales', '*.yml'), __FILE__
 )]
 
+require 'lita/helpers/utilities'
+require 'lita/helpers/graphs'
 require 'lita/handlers/datadog'
 
 require 'dogapi'

data/lib/lita/handlers/datadog.rb

@@ -6,68 +6,60 @@ module Lita
       config :timerange, default: 3600
       config :waittime, default: 0
 
+      include Lita::Helpers::Utilities
+      include Lita::Helpers::Graphs
+
       route(
-        /^graph\s(.*)$/,
+        /^graph\s(?<args>.*)$/,
         :graph,
         command: true,
-        help: { t('help.graph.syntax') => t('help.graph.desc') }
+        help: {
+          t('help.graph.syntax') => t('help.graph.desc')
+        }
       )
 
-      def graph(response)
-        args = parse_arguments(response.matches[0][0])
-        response.reply(get_response(args))
-      end
+      route(
+        /^dd\smute\s(?<hostname>\S*)(\smessage:"(?<message>.*)")?$/,
+        :mute,
+        command: true,
+        help: {
+          t('help.mute.syntax') => t('help.mute.desc')
+        }
+      )
 
-      private
+      route(
+        /^dd\sunmute\s(?<hostname>\S*)$/,
+        :unmute,
+        command: true,
+        help: {
+          t('help.unmute.syntax') => t('help.unmute.desc')
+        }
+      )
 
-      def get_response(args)
-        return_code, snapshot = get_graph_url(args[:metric],
-                                              args[:start],
-                                              args[:end],
-                                              args[:event])
+      def graph(response)
+        content = snapshot(parse_arguments(response.match_data['args']))
+        response.reply(content)
+      end
 
-        if return_code.to_s == '200'
-          sleep config.waittime
-          return snapshot['snapshot_url']
+      def mute(response)
+        hostname = response.match_data['hostname']
+        message = response.match_data['message']
+        args = {}
+        args['message'] = message unless message.nil?
+        if mute_host(hostname, args)
+          response.reply(t('mute.success', host: hostname))
         else
-          t('errors.request')
+          response.reply(t('errors.request'))
         end
       end
 
-      def get_graph_url(metric_query, start_ts, end_ts, event_query)
-        client = Dogapi::Client.new(config.api_key, config.application_key)
-
-        return nil unless client
-
-        client.graph_snapshot(metric_query, start_ts, end_ts, event_query)
-      end
-
-      def parse_arguments(arg_string)
-        end_ts   = parse_end(arg_string)
-        start_ts = parse_start(arg_string, end_ts)
-        metric   = parse_metric(arg_string)
-        event    = parse_event(arg_string)
-        { metric: metric, start: start_ts, end: end_ts, event: event }
-      end
-
-      def parse_end(string)
-        found = /(to|end):"(.+?)"/.match(string)
-        found ? Chronic.parse(found[2]).to_i : Time.now.to_i
-      end
-
-      def parse_start(string, end_ts)
-        found = /(from|start):"(.+?)"/.match(string)
-        found ? Chronic.parse(found[2]).to_i : end_ts - config.timerange
-      end
-
-      def parse_metric(string)
-        found = /metric:"(.+?)"/.match(string)
-        found ? found[1] : 'system.load.1{*}'
-      end
-
-      def parse_event(string)
-        found = /event:"(.+?)"/.match(string)
-        found ? found[1] : ''
+      def unmute(response)
+        hostname = response.match_data['hostname']
+        if unmute_host(hostname)
+          response.reply(t('unmute.success', host: hostname))
+        else
+          response.reply(t('errors.request'))
+        end
       end
     end
 

data/lib/lita/helpers/graphs.rb

@@ -0,0 +1,18 @@
+module Lita
+  module Helpers
+    # Helpers for different ways to generate a graph
+    module Graphs
+      def snapshot(args)
+        url = get_graph_url(args[:metric],
+                            args[:start],
+                            args[:end],
+                            args[:event])
+
+        return t('errors.request') if url.nil?
+        # NOTE: Is this still needed?
+        sleep config.waittime
+        url['snapshot_url']
+      end
+    end
+  end
+end

data/lib/lita/helpers/utilities.rb

@@ -0,0 +1,78 @@
+module Lita
+  module Helpers
+    # Helpers to go alongside fetching & parsing things
+    module Utilities
+      def mute_host(hostname, args)
+        client = Dogapi::Client.new(config.api_key, config.application_key)
+        return false unless client
+
+        return_code, contents = client.mute_host(hostname, args)
+
+        if return_code.to_s != '200'
+          log.warning("URL (#{return_code}): #{contents['errors'].join('\n')}")
+          return false
+        end
+
+        true
+      end
+
+      def unmute_host(hostname)
+        client = Dogapi::Client.new(config.api_key, config.application_key)
+        return false unless client
+
+        return_code, contents = client.unmute_host(hostname)
+
+        if return_code.to_s != '200'
+          log.warning("URL (#{return_code}): #{contents['errors'].join('\n')}")
+          return false
+        end
+
+        true
+      end
+
+      def get_graph_url(metric_query, start_ts, end_ts, event_query)
+        client = Dogapi::Client.new(config.api_key, config.application_key)
+
+        return nil unless client
+
+        return_code, contents = client.graph_snapshot(metric_query, start_ts,
+                                                      end_ts, event_query)
+
+        if return_code.to_s != '200'
+          log.warning("URL (#{return_code}): #{contents['errors'].join('\n')}")
+          return nil
+        end
+
+        contents
+      end
+
+      def parse_arguments(arg_string)
+        end_ts   = parse_end(arg_string)
+        start_ts = parse_start(arg_string, end_ts)
+        metric   = parse_metric(arg_string)
+        event    = parse_event(arg_string)
+        { metric: metric, start: start_ts, end: end_ts, event: event }
+      end
+
+      def parse_end(string)
+        found = /(to|end):"(.+?)"/.match(string)
+        found ? Chronic.parse(found[2]).to_i : Time.now.to_i
+      end
+
+      def parse_start(string, end_ts)
+        found = /(from|start):"(.+?)"/.match(string)
+        found ? Chronic.parse(found[2]).to_i : end_ts - config.timerange
+      end
+
+      def parse_metric(string)
+        found = /metric:"(.+?)"/.match(string)
+        found ? found[1] : 'system.load.1{*}'
+      end
+
+      def parse_event(string)
+        found = /event:"(.+?)"/.match(string)
+        found ? found[1] : ''
+      end
+    end
+  end
+end

data/lita-datadog.gemspec

@@ -1,17 +1,17 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lita-datadog'
-  spec.version       = '0.9.0'
+  spec.version       = '0.10.0'
   spec.authors       = ['Eric Sigler']
   spec.email         = ['me@esigler.com']
   spec.description   = 'A Datadog plugin for Lita'
-  spec.summary       = 'A Datadog plugin for Lita'
+  spec.summary       = spec.description
   spec.homepage      = 'http://github.com/esigler/lita-datadog'
   spec.license       = 'MIT'
   spec.metadata      = { 'lita_plugin_type' => 'handler' }
 
   spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'lita', '>= 4.0'

data/locales/en.yml

@@ -3,8 +3,18 @@ en:
     handlers:
       datadog:
         errors:
-          request: Error requesting Datadog graph
+          request: Error making DataDog request
         help:
           graph:
             syntax: 'graph metric:"simple.metric.1{*},simple.metric.5{*}'
             desc: 'Graph those metrics, for the default time range'
+          mute:
+            syntax: 'dd mute <hostname> [message:"Some reason"]'
+            desc: 'Mute a host in DataDog, optionally with a message'
+          unmute:
+            syntax: 'dd unmute <hostname>'
+            desc: 'Unmute a host in DataDog'
+        mute:
+          success: "Host %{host} muted"
+        unmute:
+          success: "Host %{host} unmuted"

data/spec/lita/handlers/datadog_spec.rb

@@ -1,20 +1,28 @@
 require 'spec_helper'
 
 describe Lita::Handlers::Datadog, lita_handler: true do
-  EXAMPLE_IMAGE_URL = 'http://www.example.com/path/that/ends/in.png'
-  EXAMPLE_ERROR_MSG = 'Error requesting Datadog graph'
+  EXAMPLE_IMAGE_URL = 'http://www.example.com/path/that/ends/in.png'.freeze
+  EXAMPLE_ERROR_MSG = 'Error making DataDog request'.freeze
 
   let(:success) do
     client = double
     allow(client).to receive(:graph_snapshot) {
       [200, { 'snapshot_url' => EXAMPLE_IMAGE_URL }]
     }
+    allow(client).to receive(:mute_host) {
+      [200, { 'hostname' => 'host01' }]
+    }
+    allow(client).to receive(:unmute_host) {
+      [200, { 'hostname' => 'host01' }]
+    }
     client
   end
 
   let(:error) do
     client = double
-    allow(client).to receive(:graph_snapshot) { [500, {}] }
+    allow(client).to receive(:graph_snapshot) { [500, { 'errors' => ['foo'] }] }
+    allow(client).to receive(:mute_host) { [500, { 'errors' => ['foo'] }] }
+    allow(client).to receive(:unmute_host) { [500, { 'errors' => ['foo'] }] }
     client
   end
 
@@ -31,24 +39,10 @@ describe Lita::Handlers::Datadog, lita_handler: true do
     is_expected.to route_command(
       'graph metric:"system.load.1{*}" event:"sources:something"')
       .to(:graph)
-  end
-
-  describe '.default_config' do
-    it 'sets the api_key to nil' do
-      expect(Lita.config.handlers.datadog.api_key).to be_nil
-    end
-
-    it 'sets the application_key to nil' do
-      expect(Lita.config.handlers.datadog.application_key).to be_nil
-    end
 
-    it 'sets the timerange to 3600' do
-      expect(Lita.config.handlers.datadog.timerange).to eq(3600)
-    end
-
-    it 'sets the waittime to 0' do
-      expect(Lita.config.handlers.datadog.waittime).to eq(0)
-    end
+    is_expected.to route_command('dd mute host01').to(:mute)
+    is_expected.to route_command('dd mute host01 message:"Foo Bar"').to(:mute)
+    is_expected.to route_command('dd unmute host01')
   end
 
   describe '#graph' do
@@ -82,4 +76,38 @@ describe Lita::Handlers::Datadog, lita_handler: true do
       expect(replies.last).to eq(EXAMPLE_ERROR_MSG)
     end
   end
+
+  describe '#mute' do
+    it 'mutes a hostname' do
+      expect(Dogapi::Client).to receive(:new) { success }
+      send_command('dd mute host01')
+      expect(replies.last).to eq('Host host01 muted')
+    end
+
+    it 'mutes a hostname with a message' do
+      expect(Dogapi::Client).to receive(:new) { success }
+      send_command('dd mute host01 message:"Foo Bar"')
+      expect(replies.last).to eq('Host host01 muted')
+    end
+
+    it 'reports an error if there was a problem with the request' do
+      expect(Dogapi::Client).to receive(:new) { error }
+      send_command('dd mute host01')
+      expect(replies.last).to eq(EXAMPLE_ERROR_MSG)
+    end
+  end
+
+  describe '#unmute' do
+    it 'unmutes a hostname' do
+      expect(Dogapi::Client).to receive(:new) { success }
+      send_command('dd unmute host01')
+      expect(replies.last).to eq('Host host01 unmuted')
+    end
+
+    it 'reports an error if there was a problem with the request' do
+      expect(Dogapi::Client).to receive(:new) { error }
+      send_command('dd unmute host01')
+      expect(replies.last).to eq(EXAMPLE_ERROR_MSG)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -10,3 +10,20 @@ require 'lita-datadog'
 require 'lita/rspec'
 
 Lita.version_3_compatibility_mode = false
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.default_formatter = 'doc' if config.files_to_run.one?
+  config.order = :random
+
+  Kernel.srand config.seed
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-datadog
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Eric Sigler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2016-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -144,6 +144,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
 - CONTRIBUTING.md
@@ -153,6 +154,8 @@ files:
 - Rakefile
 - lib/lita-datadog.rb
 - lib/lita/handlers/datadog.rb
+- lib/lita/helpers/graphs.rb
+- lib/lita/helpers/utilities.rb
 - lita-datadog.gemspec
 - locales/en.yml
 - spec/lita/handlers/datadog_spec.rb
@@ -178,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A Datadog plugin for Lita