chef-handler-datadog 0.9.0 → 0.10.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79a5cd52c38bd2ea660a477778dc45fc24672bb6
-  data.tar.gz: e2fbe94dc27216f97ceaebab7021bb17f5c013dc
+  metadata.gz: f22fc0a3aee09aa96893c748ed07af486d6d20b1
+  data.tar.gz: a0cc1fb8210e79b63b4426cb3698403e7b4c4e72
 SHA512:
-  metadata.gz: 467c6a353533afc854f8e23bed60847d050a0f34f5d2ead72e692ca9e946868b5c2ef83d35fafe05e56993952cabd1b2da25b458015d62e0e615d22c287d2ff4
-  data.tar.gz: c42c73edaa05e589240b59c1971901fdc7d48297be5d06a3901e82a51ac23002692ead16bfca3f3be94125ccd6455968d9dd11f941fc180d6ecdc913341f21f6
+  metadata.gz: c1f2f15ac30d0c56271703fe698f3a03b09b2654df96edc87bc744ec6b4702d59590a84455f28398663059cff19419d3372b5b09520dcea7d4ddb17c0dce2be7
+  data.tar.gz: bbb290f4667294fb9c9e03fbaa4c652877a5b44f6904083aee69d8aca7b8a7e3b9c9da29ab8336d833242ac7fda4bc1589fd8ec4312f83ae7c3beef0f8f16515

data/.travis.yml

@@ -6,6 +6,12 @@ rvm:
   - 1.9.3
   - 2.1.5
 
+before_install:
+  - gem update --system
+  - gem --version
+  # Use a stable version once 1.13.0 is released
+  - gem install bundler --version 1.13.0.rc.1
+
 bundler_args: --without=localdev
 
 gemfile:

data/Appraisals

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 # Latest release of mainline Chef versions here.
-%w(10 11 12).each do |tv|
+%w(10 12).each do |tv|
   appraise "chef-#{tv}" do
     gem 'chef', "~> #{tv}.0"
   end
@@ -14,3 +14,11 @@ appraise 'chef-10.14.4' do
   # See: http://git.io/vecAn
   gem 'ohai', '< 8.0'
 end
+
+appraise 'chef-11' do
+  gem 'chef', '~> 11.0'
+  # for some reason bundler installs json 2.x and rack 2.x even when they don't support the version of
+  # ruby installed, so let's force compatible versions here
+  gem 'json', '< 2.0'
+  gem 'rack', '< 2.0'
+end

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 Changes
 =======
 
+# 0.10.0 / Unreleased
+
+* [FEATURE] Allow passing `scope_prefix` param that prefixes env and role tags [#82][] [@DanielMuller][]
+* [FEATURE] Support regex tag blacklist [#86][] [@ABrehm264][]
+* [FEATURE] Support multiple endpoints [#87][] [@degemer][]
+* [OPTIMIZE] Always emit success and failure metrics [#89][] [@devonbleak][]
+
 # 0.9.0 / 2016-03-22
 
 * [FEATURE] Enable users to select tag prefix [#81][] [@mstepniowski][]
@@ -89,9 +96,17 @@ And all other versions were prior to this. See git history for more.
 [#78]: https://github.com/DataDog/chef-handler-datadog/issues/78
 [#80]: https://github.com/DataDog/chef-handler-datadog/issues/80
 [#81]: https://github.com/DataDog/chef-handler-datadog/issues/81
+[#82]: https://github.com/DataDog/chef-handler-datadog/issues/82
+[#86]: https://github.com/DataDog/chef-handler-datadog/issues/86
+[#87]: https://github.com/DataDog/chef-handler-datadog/issues/87
+[#89]: https://github.com/DataDog/chef-handler-datadog/issues/89
+[@ABrehm264]: https://github.com/ABrehm264
+[@DanielMuller]: https://github.com/DanielMuller
 [@alq]: https://github.com/alq
 [@bigbam505]: https://github.com/bigbam505
 [@datwiz]: https://github.com/datwiz
+[@degemer]: https://github.com/degemer
+[@devonbleak]: https://github.com/devonbleak
 [@dwradcliffe]: https://github.com/dwradcliffe
 [@jhulten]: https://github.com/jhulten
 [@miketheman]: https://github.com/miketheman

data/chef-handler-datadog.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
   gem.extra_rdoc_files = ['README.md', 'LICENSE.txt']
 
-  gem.add_dependency 'dogapi', '>= 1.6'
+  gem.add_dependency 'dogapi', '>= 1.23'
 
   gem.add_development_dependency 'appraisal', '~> 2.0.1'
   gem.add_development_dependency 'bundler'

data/gemfiles/chef_11.gemfile

@@ -3,6 +3,8 @@
 source "http://rubygems.org"
 
 gem "chef", "~> 11.0"
+gem "json", "< 2.0"
+gem "rack", "< 2.0"
 
 group :localdev do
   gem "guard"

data/lib/chef/handler/datadog.rb

@@ -18,8 +18,8 @@ class Chef
       # It should be passed along from the node/role/environemnt attributes, as the default is nil.
       def initialize(config = {})
         @config = Mash.new(config)
-        # If *any* api_key is not provided, this will fail immediately.
-        @dog = Dogapi::Client.new(@config[:api_key], @config[:application_key])
+
+        @dogs = prepare_the_pack
       end
 
       def report
@@ -28,8 +28,11 @@ class Chef
 
         # prepare the metrics, event, and tags information to be reported
         prepare_report_for_datadog
-        # post the report information to the datadog service
-        send_report_to_datadog
+
+        @dogs.each do |dog|
+          # post the report information to the datadog service
+          send_report_to_datadog dog
+        end
       ensure
         # restore the env proxy settings before leaving to avoid downstream side-effects
         restore_env_proxies unless ENV['DATADOG_PROXY'].nil?
@@ -44,24 +47,22 @@ class Chef
         # prepare chef run metrics
         @metrics =
             DatadogChefMetrics.new
-            .with_dogapi_client(@dog)
             .with_hostname(hostname)
             .with_run_status(run_status)
 
         # Collect and prepare tags
         @tags =
             DatadogChefTags.new
-            .with_dogapi_client(@dog)
             .with_hostname(hostname)
             .with_run_status(run_status)
-            .with_application_key(config[:application_key])
             .with_tag_prefix(config[:tag_prefix])
             .with_retries(config[:tags_submission_retries])
+            .with_tag_blacklist(config[:tags_blacklist_regex])
+            .with_scope_prefix(config[:scope_prefix])
 
         # Build the chef event information
         @event =
             DatadogChefEvents.new
-            .with_dogapi_client(@dog)
             .with_hostname(hostname)
             .with_run_status(run_status)
             .with_failure_notifications(@config['notify_on_failure'])
@@ -69,10 +70,12 @@ class Chef
       end
 
       # Submit metrics, event, and tags information to datadog
-      def send_report_to_datadog
-        @metrics.emit_to_datadog
-        @event.emit_to_datadog
-        @tags.send_update_to_datadog
+      #
+      # @param dog [Dogapi::Client] Dogapi Client to be used
+      def send_report_to_datadog(dog)
+        @metrics.emit_to_datadog dog
+        @event.emit_to_datadog dog
+        @tags.send_update_to_datadog dog
       rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
         Chef::Log.error("Could not connect to Datadog. Connection error:\n" + e)
         Chef::Log.error('Data to be submitted was:')
@@ -118,6 +121,61 @@ class Chef
         ENV['http_proxy'] = @env_http_proxy
         ENV['https_proxy'] = @env_https_proxy
       end
+
+      # create and configure all the Dogapi Clients to be used
+      #
+      # @return [Array] all Dogapi::Client to be used
+      def prepare_the_pack
+        dogs = []
+        endpoints.each do |url, api_key, app_key|
+          dogs.push(Dogapi::Client.new(
+                      api_key,
+                      app_key,
+                      nil,   # host
+                      nil,   # device
+                      true,  # silent
+                      nil,   # timeout
+                      url
+          ))
+        end
+        dogs
+      end
+
+      # return all endpoints as a list of triplets [url, api_key, application_key]
+      def endpoints
+        validate_keys(@config[:api_key], @config[:application_key], true)
+
+        endpoints = [[@config[:url], @config[:api_key], @config[:application_key]]]
+
+        extra_endpoints = @config[:extra_endpoints] || []
+
+        extra_endpoints.each do |endpoint|
+          url = endpoint[:url] || @config[:url]
+          api_key = endpoint[:api_key]
+          app_key = endpoint[:application_key]
+          endpoints << [url, api_key, app_key] if validate_keys(api_key, app_key, false)
+        end
+        endpoints
+      end
+
+      # Validate endpoints config (api_key and application key)
+      # fails if incorrect and should_fail is true (needed for the default)
+      # Doesn't fail for the other endpoints but logs a warning
+      def validate_keys(api_key, app_key, should_fail)
+        if api_key.nil?
+          Chef::Log.warn('You need an API key to communicate with Datadog')
+          fail ArgumentError, 'Missing Datadog Api Key' if should_fail
+          return false
+        end
+        if app_key.nil?
+          Chef::Log.warn('You need an application key to let Chef tag your nodes ' \
+                         'in Datadog. Visit https://app.datadoghq.com/account/settings#api to ' \
+                         'create one and update your datadog attributes in the datadog cookbook.')
+          fail ArgumentError, 'Missing Datadog Application Key' if should_fail
+          return false
+        end
+        true
+      end
     end # end class Datadog
   end # end class Handler
 end # end class Chef

data/lib/chef/handler/datadog_chef_events.rb

@@ -7,7 +7,6 @@ require 'dogapi'
 # helper class for sending events about chef runs
 class DatadogChefEvents
   def initialize
-    @dog = nil
     @hostname = nil
     @run_status = nil
     @failure_notfications = nil
@@ -21,15 +20,6 @@ class DatadogChefEvents
     @event_body = ''
   end
 
-  # set the dogapi client handle
-  #
-  # @param dogapi_client [Dogapi::Client] datadog api client handle
-  # @return [DatadogChefTags] instance reference to self enabling method chaining
-  def with_dogapi_client(dogapi_client)
-    @dog = dogapi_client
-    self
-  end
-
   # set the target hostname (chef node name)
   #
   # @param hostname [String] hostname to use for the handler report
@@ -67,18 +57,20 @@ class DatadogChefEvents
   end
 
   # Emit Chef event to Datadog
-  def emit_to_datadog
+  #
+  # @param dog [Dogapi::Client] Dogapi Client to be used
+  def emit_to_datadog(dog)
     @event_body = ''
     build_event_data
-    evt = @dog.emit_event(Dogapi::Event.new(@event_body,
-                                            msg_title: @event_title,
-                                            event_type: 'config_management.run',
-                                            event_object: @hostname,
-                                            alert_type: @alert_type,
-                                            priority: @event_priority,
-                                            source_type_name: 'chef',
-                                            tags: @tags
-                                           ), host: @hostname)
+    evt = dog.emit_event(Dogapi::Event.new(@event_body,
+                                           msg_title: @event_title,
+                                           event_type: 'config_management.run',
+                                           event_object: @hostname,
+                                           alert_type: @alert_type,
+                                           priority: @event_priority,
+                                           source_type_name: 'chef',
+                                           tags: @tags
+                                          ), host: @hostname)
 
     begin
       # FIXME: nice-to-have: abstract format of return value away a bit

data/lib/chef/handler/datadog_chef_metrics.rb

@@ -4,20 +4,10 @@ require 'dogapi'
 # helper class for sending datadog metrics from a chef run
 class DatadogChefMetrics
   def initialize
-    @dog = nil
     @hostname = ''
     @run_status = nil
   end
 
-  # set the dogapi client handle
-  #
-  # @param dogapi_client [Dogapi::Client] datadog api client
-  # @return [DatadogChefMetrics] instance reference to self enabling method chaining
-  def with_dogapi_client(dogapi_client)
-    @dog = dogapi_client
-    self
-  end
-
   # set the target hostname (chef node name)
   #
   # @param hostname [String] hostname used for reporting metrics
@@ -37,18 +27,21 @@ class DatadogChefMetrics
   end
 
   # Emit Chef metrics to Datadog
-  def emit_to_datadog
+  #
+  # @param dog [Dogapi::Client] Dogapi Client to be used
+  def emit_to_datadog(dog)
     # Send base success/failure metric
-    @dog.emit_point(@run_status.success? ? 'chef.run.success' : 'chef.run.failure', 1, host: @hostname, type: 'counter')
+    dog.emit_point('chef.run.success', @run_status.success? ? 1 : 0, host: @hostname, type: 'counter')
+    dog.emit_point('chef.run.failure', @run_status.success? ? 0 : 1, host: @hostname, type: 'counter')
 
     # If there is a failure during compile phase, a large portion of
     # run_status may be unavailable. Bail out here
     warn_msg = 'Error during compile phase, no Datadog metrics available.'
     return Chef::Log.warn(warn_msg) if compile_error?
 
-    @dog.emit_point('chef.resources.total', @run_status.all_resources.length, host: @hostname)
-    @dog.emit_point('chef.resources.updated', @run_status.updated_resources.length, host: @hostname)
-    @dog.emit_point('chef.resources.elapsed_time', @run_status.elapsed_time, host: @hostname)
+    dog.emit_point('chef.resources.total', @run_status.all_resources.length, host: @hostname)
+    dog.emit_point('chef.resources.updated', @run_status.updated_resources.length, host: @hostname)
+    dog.emit_point('chef.resources.elapsed_time', @run_status.elapsed_time, host: @hostname)
     Chef::Log.debug('Submitted Chef metrics back to Datadog')
   rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
     Chef::Log.error("Could not send metrics to Datadog. Connection error:\n" + e)

data/lib/chef/handler/datadog_chef_tags.rb

@@ -11,17 +11,10 @@ class DatadogChefTags
     @run_status = nil
     @application_key = nil
     @tag_prefix = 'tag:'
+    @scope_prefix = nil
     @retries = 0
     @combined_host_tags = nil
-  end
-
-  # set the dogapi client handle
-  #
-  # @param dogapi_client [Dogapi::Client] datadog api client handle
-  # @return [DatadogChefTags] instance reference to self enabling method chaining
-  def with_dogapi_client(dogapi_client)
-    @dog = dogapi_client
-    self
+    @regex_black_list = nil
   end
 
   # set the chef run status used for the report
@@ -46,26 +39,6 @@ class DatadogChefTags
     self
   end
 
-  # set the datadog application key
-  #
-  # TODO: the application key is only needed for error checking, e.g. an app key exists
-  #   would be cleaner to push this check up to the data prep method in the
-  #   calling handler class
-  #
-  # @param application_key [String] datadog application key used for chef reports
-  # @return [DatadogChefTags] instance reference to self enabling method chaining
-  def with_application_key(application_key)
-    @application_key = application_key
-    if @application_key.nil?
-      Chef::Log.warn('You need an application key to let Chef tag your nodes ' \
-              'in Datadog. Visit https://app.datadoghq.com/account/settings#api to ' \
-                'create one and update your datadog attributes in the datadog cookbook.'
-                    )
-      fail ArgumentError, 'Missing Datadog Application Key'
-    end
-    self
-  end
-
   # set the prefix to be added to all Chef tags
   #
   # @param tag_prefix [String] prefix to be added to all Chef tags
@@ -85,14 +58,34 @@ class DatadogChefTags
     self
   end
 
+  # set the blacklist regexp, node tags matching this regex won't be sent
+  #
+  # @param tags_blacklist_regex [String] regexp-formatted string
+  # @return [DatadogChefTags] instance reference to self enabling method chaining
+  def with_tag_blacklist(tags_blacklist_regex)
+    @regex_black_list = Regexp.new(tags_blacklist_regex, Regexp::IGNORECASE) unless tags_blacklist_regex.nil? || tags_blacklist_regex.empty?
+    self
+  end
+
+  # set the prefix to be added to Datadog tags (Role, Env)
+  #
+  # @param scope_prefix [String] prefix to be added to Datadog tags
+  # @return [DatadogChefTags] instance reference to self enabling method chaining
+  def with_scope_prefix(scope_prefix)
+    @scope_prefix = scope_prefix unless scope_prefix.nil?
+    self
+  end
+
   # send updated chef run generated tags to Datadog
-  def send_update_to_datadog
+  #
+  # @param dog [Dogapi::Client] Dogapi Client to be used
+  def send_update_to_datadog(dog)
     tags = combined_host_tags
     retries = @retries
     begin
       loop do
         should_retry = false
-        rc = @dog.update_tags(@hostname, tags, 'chef')
+        rc = dog.update_tags(@hostname, tags, 'chef')
         # See FIXME in DatadogChefEvents::emit_to_datadog about why I feel dirty repeating this code here
         if rc.length < 2
           Chef::Log.warn("Unexpected response from Datadog Tags API: #{rc}")
@@ -126,15 +119,21 @@ class DatadogChefTags
   private
 
   def node_roles
-    @node.run_list.roles.map! { |role| 'role:' + role }
+    @node.run_list.roles.map! { |role| "#{@scope_prefix}role:#{role}" }
   end
 
   def node_env
-    'env:' + @node.chef_environment if @node.respond_to?('chef_environment')
+    "#{@scope_prefix}env:#{@node.chef_environment}" if @node.respond_to?('chef_environment')
   end
 
   def node_tags
     return [] unless @node.tags
-    @node.tags.map { |tag| "#{@tag_prefix}#{tag}" }
+    output = @node.tags.map { |tag| "#{@tag_prefix}#{tag}" }
+
+    # No blacklist, return all results
+    return output if @regex_black_list.nil?
+
+    # The blacklist is set, so return the items which are not filtered by it.
+    output.select { |t| !@regex_black_list.match(t) }
   end
 end # end class DatadogChefTags

data/lib/chef_handler_datadog.rb

@@ -2,5 +2,5 @@
 # Helper module for version number only.
 # Real deal in 'chef/handler/datadog.rb'
 module ChefHandlerDatadog
-  VERSION = '0.9.0'
+  VERSION = '0.10.0.rc1'
 end

data/spec/datadog_spec.rb

@@ -29,6 +29,7 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
         'api_key'         => API_KEY,
         'application_key' => APPLICATION_KEY,
         'tag_prefix'      => 'tag',
+        'scope_prefix'    => nil
       )
     end
   end
@@ -57,7 +58,7 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
       it 'reports metrics' do
         expect(a_request(:post, METRICS_ENDPOINT).with(
           :query => { 'api_key' => @handler.config[:api_key] }
-        )).to have_been_made.times(4)
+        )).to have_been_made.times(5)
       end
     end
 
@@ -246,6 +247,34 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
             ]),
          )).to have_been_made.times(1)
       end
+
+      it 'allows for user-specified scope prefix' do
+        @handler.config[:scope_prefix] = 'custom-prefix-'
+        @handler.run_report_unsafe(@run_status)
+
+        expect(a_request(:put, HOST_TAG_ENDPOINT + @node.name).with(
+          :query => { 'api_key' => @handler.config[:api_key],
+                      'application_key' => @handler.config[:application_key],
+                      'source' => 'chef' },
+          :body => hash_including(:tags => [
+            'custom-prefix-env:hostile', 'custom-prefix-role:highlander'
+            ]),
+         )).to have_been_made.times(1)
+      end
+
+      it 'allows for empty scope prefix' do
+        @handler.config[:scope_prefix] = ''
+        @handler.run_report_unsafe(@run_status)
+
+        expect(a_request(:put, HOST_TAG_ENDPOINT + @node.name).with(
+          :query => { 'api_key' => @handler.config[:api_key],
+                      'application_key' => @handler.config[:application_key],
+                      'source' => 'chef' },
+          :body => hash_including(:tags => [
+            'env:hostile', 'role:highlander'
+            ]),
+         )).to have_been_made.times(1)
+      end
     end
 
     describe 'when unspecified' do
@@ -262,6 +291,39 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
         )).to have_been_made.times(1)
       end
     end
+
+    describe 'when tag blacklist is specified' do
+      it 'does not include the tag(s) specified' do
+        @node.normal.tags = ['allowed_tag', 'not_allowed_tag']
+        @handler.config[:tags_blacklist_regex] = 'not_allowed.*'
+        @handler.run_report_unsafe(@run_status)
+
+        expect(a_request(:put, HOST_TAG_ENDPOINT + @node.name).with(
+          :query => { 'api_key' => @handler.config[:api_key],
+                      'application_key' => @handler.config[:application_key],
+                      'source' => 'chef' },
+          :body => hash_including(:tags => [
+              'env:hostile', 'role:highlander', 'tag:allowed_tag'
+            ]),
+        )).to have_been_made.times(1)
+      end
+    end
+
+    describe 'when tag blacklist is unspecified' do
+      it 'should include all of the tag(s)' do
+        @node.normal.tags = ['allowed_tag', 'not_allowed_tag']
+        @handler.run_report_unsafe(@run_status)
+
+        expect(a_request(:put, HOST_TAG_ENDPOINT + @node.name).with(
+          :query => { 'api_key' => @handler.config[:api_key],
+                      'application_key' => @handler.config[:application_key],
+                      'source' => 'chef' },
+          :body => hash_including(:tags => [
+              'env:hostile', 'role:highlander', 'tag:allowed_tag', 'tag:not_allowed_tag'
+            ]),
+        )).to have_been_made.times(1)
+      end
+    end
   end
 
   context 'tags submission retries' do
@@ -355,11 +417,9 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
     end
 
     it 'fails when no application key is provided' do
-      @handler.config[:application_key] = nil
-
       # TODO: figure out how to capture output of Chef::Log
       # Run the report, catch the error
-      expect { @handler.run_report_unsafe(@run_status) }.to raise_error
+      expect { Chef::Handler::Datadog.new(api_key: API_KEY, application_key: nil) }.to raise_error
     end
   end
 
@@ -382,7 +442,7 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
         Chef::Resource.new('nose'),
         Chef::Resource.new('tail'),
         Chef::Resource.new('fur')
-        ]
+      ]
       all_resources.map { |r| r.updated_by_last_action(true) }
       @run_context.resource_collection.all_resources.replace(all_resources)
 
@@ -474,10 +534,10 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
         @handler.run_report_unsafe(@run_status)
       end
 
-      it 'only emits a failure metric' do
+      it 'only emits the run status metrics' do
         expect(a_request(:post, METRICS_ENDPOINT).with(
           :query => { 'api_key' => @handler.config[:api_key] }
-        )).to have_been_made.times(1)
+        )).to have_been_made.times(2)
       end
 
       it 'posts an event' do
@@ -490,6 +550,205 @@ describe Chef::Handler::Datadog, :vcr => :new_episodes do
     end
   end
 
+  describe '#endpoints' do
+    context 'with a basic config' do
+      it 'returns the correct triplet' do
+        handler = Chef::Handler::Datadog.new api_key: API_KEY, application_key: APPLICATION_KEY
+        expect(handler.send(:endpoints)).to eq([[nil, API_KEY, APPLICATION_KEY]])
+      end
+    end
+
+    context 'with no url and two pairs of keys' do
+      it 'returns the correct triplets' do
+        triplets = [
+          [nil, API_KEY, APPLICATION_KEY],
+          [nil, 'api_key_2', 'app_key_2'],
+          [nil, 'api_key_3', 'app_key_3']
+        ]
+        handler = Chef::Handler::Datadog.new api_key: triplets[0][1],
+                                             application_key: triplets[0][2],
+                                             extra_endpoints: [{
+                                               api_key: triplets[1][1],
+                                               application_key: triplets[1][2]
+                                             }, {
+                                               api_key: triplets[2][1],
+                                               application_key: triplets[2][2]
+                                             }]
+        expect(handler.send(:endpoints)).to eq(triplets)
+      end
+    end
+
+    context 'with one url and two pairs of keys' do
+      it 'returns the correct triplets' do
+        triplets = [
+          ['https://app.example.com', API_KEY, APPLICATION_KEY],
+          ['https://app.example.com', 'api_key_2', 'app_key_2'],
+          ['https://app.example.com', 'api_key_3', 'app_key_3']
+        ]
+        handler = Chef::Handler::Datadog.new api_key: triplets[0][1],
+                                             application_key: triplets[0][2],
+                                             url: triplets[0][0],
+                                             extra_endpoints: [{
+                                               api_key: triplets[1][1],
+                                               application_key: triplets[1][2]
+                                             }, {
+                                               api_key: triplets[2][1],
+                                               application_key: triplets[2][2]
+                                             }]
+        expect(handler.send(:endpoints)).to eq(triplets)
+      end
+    end
+
+    context 'with multiple urls' do
+      it 'returns the correct triplets' do
+        triplets = [
+          ['https://app.datadoghq.com', 'api_key_2', 'app_key_2'],
+          ['https://app.example.com', 'api_key_3', 'app_key_3'],
+          ['https://app.example.com', 'api_key_4', 'app_key_4']
+        ]
+        handler = Chef::Handler::Datadog.new api_key: triplets[0][1],
+                                             application_key: triplets[0][2],
+                                             url: triplets[0][0],
+                                             extra_endpoints: [{
+                                               url: triplets[1][0],
+                                               api_key: triplets[1][1],
+                                               application_key: triplets[1][2]
+                                             }, {
+                                               url: triplets[2][0],
+                                               api_key: triplets[2][1],
+                                               application_key: triplets[2][2]
+                                             }]
+        expect(handler.send(:endpoints)).to eq(triplets)
+      end
+    end
+
+    context 'when missing application keys' do
+      it 'returns available triplets' do
+        triplets = [
+          [nil, API_KEY, APPLICATION_KEY],
+          [nil, 'api_key_2', 'app_key_2'],
+          [nil, 'api_key_3', 'app_key_3']
+        ]
+        handler = Chef::Handler::Datadog.new api_key: triplets[0][1],
+                                             application_key: triplets[0][2],
+                                             extra_endpoints: [{
+                                               api_key: triplets[1][1],
+                                               application_key: triplets[1][2]
+                                             }, {
+                                               api_key: triplets[2][1]
+                                             }]
+        expect(handler.send(:endpoints)).to eq(triplets[0..1])
+      end
+    end
+
+    context 'when missing api keys' do
+      it 'returns available triplets' do
+        triplets = [
+          ['https://app.datadoghq.com', 'api_key_2', 'app_key_2'],
+          ['https://app.example.com', 'api_key_3', 'app_key_3'],
+          ['https://app.example.com', 'api_key_4', 'app_key_4']
+        ]
+        handler = Chef::Handler::Datadog.new api_key: triplets[0][1],
+                                             application_key: triplets[0][2],
+                                             url: triplets[0][0],
+                                             extra_endpoints: [{
+                                               url: triplets[1][0],
+                                               api_key: triplets[1][1],
+                                               application_key: triplets[1][2]
+                                             }, {
+                                               url: triplets[2][0],
+                                               application_key: triplets[2][2]
+                                             }]
+        expect(handler.send(:endpoints)).to eq(triplets[0..1])
+      end
+    end
+  end
+
+  context 'when reporting to multiple endpoints' do
+    let(:api_key2) { 'api_key_example' }
+    let(:application_key2) { 'application_key_example' }
+    let(:base_url2) { 'https://app.example.com' }
+    let(:events_endpoint2) { base_url2 + '/api/v1/events' }
+    let(:host_tag_endpoint2) { base_url2 + '/api/v1/tags/hosts/' }
+    let(:metrics_endpoint2) { base_url2 + '/api/v1/series' }
+    let(:handler) do
+      Chef::Handler::Datadog.new api_key: API_KEY,
+                                 application_key: APPLICATION_KEY,
+                                 url: BASE_URL,
+                                 extra_endpoints: [{
+                                   api_key: api_key2,
+                                   application_key: application_key2,
+                                   url: base_url2
+                                 }]
+    end
+    # Construct a good run_status
+    before(:each) do
+      @node = Chef::Node.build('chef.handler.datadog.test')
+      @node.send(:chef_environment, 'testing')
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(@node, {}, @events)
+      @run_status = Chef::RunStatus.new(@node, @events)
+
+      @expected_time = Time.now
+      allow(Time).to receive(:now).and_return(@expected_time, @expected_time + 5)
+      @run_status.start_clock
+      @run_status.stop_clock
+
+      @run_status.run_context = @run_context
+
+      # Run the report
+      handler.run_report_unsafe(@run_status)
+    end
+
+    context 'emits metrics' do
+      it 'reports metrics' do
+        expect(a_request(:post, METRICS_ENDPOINT).with(
+          :query => { 'api_key' => API_KEY }
+        )).to have_been_made.times(5)
+
+        expect(a_request(:post, metrics_endpoint2).with(
+          :query => { 'api_key' => api_key2 }
+        )).to have_been_made.times(5)
+      end
+    end
+
+    context 'emits events' do
+      it 'posts an event' do
+        expect(a_request(:post, EVENTS_ENDPOINT).with(
+          :query => { 'api_key' => API_KEY },
+          :body => hash_including(:msg_text => 'Chef updated 0 resources out of 0 resources total.'),
+          :body => hash_including(:msg_title => "Chef completed in 5 seconds on #{@node.name} "),
+          :body => hash_including(:tags => ['env:testing']),
+        )).to have_been_made.times(1)
+
+        expect(a_request(:post, events_endpoint2).with(
+          :query => { 'api_key' => api_key2 },
+          :body => hash_including(:msg_text => 'Chef updated 0 resources out of 0 resources total.'),
+          :body => hash_including(:msg_title => "Chef completed in 5 seconds on #{@node.name} "),
+          :body => hash_including(:tags => ['env:testing']),
+        )).to have_been_made.times(1)
+      end
+    end
+
+    context 'sets tags' do
+      it 'puts the tags for the current node' do
+        expect(a_request(:put, HOST_TAG_ENDPOINT + @node.name).with(
+          :query => { 'api_key' => API_KEY,
+                      'application_key' => APPLICATION_KEY,
+                      'source' => 'chef' },
+          :body => { 'tags' => ['env:testing'] },
+        )).to have_been_made.times(1)
+
+        expect(a_request(:put, host_tag_endpoint2 + @node.name).with(
+          :query => { 'api_key' => api_key2,
+                      'application_key' => application_key2,
+                      'source' => 'chef' },
+          :body => { 'tags' => ['env:testing'] },
+        )).to have_been_made.times(1)
+      end
+    end
+  end
+
     # TODO: test failures:
     # @run_status.exception = Exception.new('Boy howdy!')
 end