chef 14.15.6 → 15.0.293

data/lib/chef/data_bag_item.rb

@@ -20,13 +20,13 @@
 
 require "forwardable"
 
-require "chef/config"
-require "chef/mixin/params_validate"
-require "chef/mixin/from_file"
-require "chef/data_bag"
-require "chef/mash"
-require "chef/server_api"
-require "chef/json_compat"
+require_relative "config"
+require_relative "mixin/params_validate"
+require_relative "mixin/from_file"
+require_relative "data_bag"
+require_relative "mash"
+require_relative "server_api"
+require_relative "json_compat"
 
 class Chef
   class DataBagItem
@@ -36,7 +36,7 @@ class Chef
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
 
-    VALID_ID = /^[\.\-[:alnum:]_]+$/
+    VALID_ID = /^[\.\-[:alnum:]_]+$/.freeze
 
     def self.validate_id!(id_str)
       if id_str.nil? || ( id_str !~ VALID_ID )
@@ -113,11 +113,11 @@ class Chef
     # Serialize this object as a hash
     def to_json(*a)
       result = {
-        "name"       => object_name,
+        "name" => object_name,
         "json_class" => self.class.name,
-        "chef_type"  => "data_bag_item",
-        "data_bag"   => data_bag,
-        "raw_data"   => raw_data,
+        "chef_type" => "data_bag_item",
+        "data_bag" => data_bag,
+        "raw_data" => raw_data,
       }
       Chef::JSONCompat.to_json(result, *a)
     end

data/lib/chef/data_collector.rb

@@ -2,7 +2,7 @@
 # Author:: Adam Leff (<adamleff@chef.io>)
 # Author:: Ryan Cragun (<ryan@chef.io>)
 #
-# Copyright:: Copyright 2012-2018, Chef Software Inc.
+# Copyright:: Copyright 2012-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,321 +18,174 @@
 # limitations under the License.
 #
 
-require "uri"
-require "chef/server_api"
-require "chef/http/simple_json"
-require "chef/event_dispatch/base"
-require "chef/data_collector/messages"
-require "chef/data_collector/resource_report"
-require "ostruct"
+require_relative "server_api"
+require_relative "http/simple_json"
+require_relative "event_dispatch/base"
 require "set"
+require_relative "data_collector/run_end_message"
+require_relative "data_collector/run_start_message"
+require_relative "data_collector/config_validation"
+require_relative "data_collector/error_handlers"
+require_relative "dist"
 
 class Chef
-
-  # == Chef::DataCollector
-  # Provides methods for determinine whether a reporter should be registered.
   class DataCollector
+    # The DataCollector is mode-agnostic reporting tool which can be used with
+    # server-based and solo-based clients.  It can report to a file, to an
+    # authenticated Chef Automate reporting endpoint, or to a user-supplied
+    # webhook.  It sends two messages:  one at the start of the run and one
+    # at the end of the run.  Most early failures in the actual Chef::Client itself
+    # are reported, but parsing of the client.rb must have succeeded and some code
+    # in Chef::Application could throw so early as to prevent reporting.  If
+    # exceptions are thrown both run-start and run-end messages are still sent in
+    # pairs.
+    #
+    class Reporter < EventDispatch::Base
+      include Chef::DataCollector::ErrorHandlers
 
-    # Whether or not to enable data collection:
-    # * always disabled for why run mode
-    # * disabled when the user sets `Chef::Config[:data_collector][:mode]` to a
-    #   value that excludes the mode (client or solo) that we are running as
-    # * disabled in solo mode if the user did not configure the auth token
-    # * disabled if `Chef::Config[:data_collector][:server_url]` is set to a
-    #   falsey value
-    def self.register_reporter?
-      if why_run?
-        Chef::Log.trace("data collector is disabled for why run mode")
-        return false
-      end
-      unless reporter_enabled_for_current_mode?
-        Chef::Log.trace("data collector is configured to only run in " \
-                        "#{Chef::Config[:data_collector][:mode].inspect} modes, disabling it")
-        return false
-      end
-      unless data_collector_url_configured? || data_collector_output_locations_configured?
-        Chef::Log.trace("Neither data collector URL or output locations have been configured, disabling data collector")
-        return false
-      end
-      if solo? && !token_auth_configured?
-        Chef::Log.trace("Data collector token must be configured to use Chef Automate data collector with Chef Solo")
-      end
-      if !solo? && token_auth_configured?
-        Chef::Log.warn("Data collector token authentication is not recommended for client-server mode" \
-                       "Please upgrade Chef Server to 12.11.0 and remove the token from your config file " \
-                       "to use key based authentication instead")
-      end
-      true
-    end
-
-    def self.data_collector_url_configured?
-      !!Chef::Config[:data_collector][:server_url]
-    end
-
-    def self.data_collector_output_locations_configured?
-      !!Chef::Config[:data_collector][:output_locations]
-    end
+      # @return [Chef::RunList::RunListExpansion] the expanded run list
+      attr_reader :expanded_run_list
 
-    def self.why_run?
-      !!Chef::Config[:why_run]
-    end
+      # @return [Chef::RunStatus] the run status
+      attr_reader :run_status
 
-    def self.token_auth_configured?
-      !!Chef::Config[:data_collector][:token]
-    end
+      # @return [Chef::Node] the chef node
+      attr_reader :node
 
-    def self.solo?
-      !!Chef::Config[:solo] || !!Chef::Config[:local_mode]
-    end
+      # @return [Set<Hash>] the acculumated list of deprecation warnings
+      attr_reader :deprecations
 
-    def self.reporter_enabled_for_current_mode?
-      if Chef::Config[:solo] || Chef::Config[:local_mode]
-        acceptable_modes = [:solo, :both]
-      else
-        acceptable_modes = [:client, :both]
-      end
+      # @return [Chef::ActionCollection] the action collection object
+      attr_reader :action_collection
 
-      acceptable_modes.include?(Chef::Config[:data_collector][:mode])
-    end
+      # @return [Chef::EventDispatch::Dispatcher] the event dispatcher
+      attr_reader :events
 
-    # == Chef::DataCollector::Reporter
-    # Provides an event handler that can be registered to report on Chef
-    # run data. Unlike the existing Chef::ResourceReporter event handler,
-    # the DataCollector handler is not tied to a Chef Server / Chef Reporting
-    # and exports its data through a webhook-like mechanism to a configured
-    # endpoint.
-    class Reporter < EventDispatch::Base
-      attr_reader :all_resource_reports, :status, :exception, :error_descriptions,
-                  :expanded_run_list, :run_context, :run_status, :http,
-                  :current_resource_report, :enabled, :deprecations
-
-      def initialize
-        validate_data_collector_server_url!
-        validate_data_collector_output_locations! if data_collector_output_locations
-        @all_resource_reports    = []
-        @current_resource_loaded = nil
-        @error_descriptions      = {}
+      # @param events [Chef::EventDispatch::Dispatcher] the event dispatcher
+      def initialize(events)
+        @events = events
         @expanded_run_list       = {}
         @deprecations            = Set.new
-        @enabled                 = true
-
-        @http = setup_http_client(data_collector_server_url)
-        if data_collector_output_locations
-          @http_output_locations = setup_http_output_locations if data_collector_output_locations[:urls]
-        end
-      end
-
-      # see EventDispatch::Base#run_started
-      # Upon receipt, we will send our run start message to the
-      # configured DataCollector endpoint. Depending on whether
-      # the user has configured raise_on_failure, if we cannot
-      # send the message, we will either disable the DataCollector
-      # Reporter for the duration of this run, or we'll raise an
-      # exception.
-      def run_started(current_run_status)
-        update_run_status(current_run_status)
-
-        message = Chef::DataCollector::Messages.run_start_message(current_run_status)
-        disable_reporter_on_error do
-          send_to_data_collector(message)
-        end
-        send_to_output_locations(message) if data_collector_output_locations
-      end
-
-      # see EventDispatch::Base#run_completed
-      # Upon receipt, we will send our run completion message to the
-      # configured DataCollector endpoint.
-      def run_completed(node)
-        send_run_completion(status: "success")
-      end
-
-      # see EventDispatch::Base#run_failed
-      def run_failed(exception)
-        send_run_completion(status: "failure")
       end
 
-      # see EventDispatch::Base#converge_start
-      # Upon receipt, we stash the run_context for use at the
-      # end of the run in order to determine what resource+action
-      # combinations have not yet fired so we can report on
-      # unprocessed resources.
-      def converge_start(run_context)
-        @run_context = run_context
-      end
-
-      # see EventDispatch::Base#converge_complete
-      # At the end of the converge, we add any unprocessed resources
-      # to our report list.
-      def converge_complete
-        detect_unprocessed_resources
-      end
-
-      # see EventDispatch::Base#converge_failed
-      # At the end of the converge, we add any unprocessed resources
-      # to our report list
-      def converge_failed(exception)
-        detect_unprocessed_resources
-      end
-
-      # see EventDispatch::Base#resource_current_state_loaded
-      # Create a new ResourceReport instance that we'll use to track
-      # the state of this resource during the run. Nested resources are
-      # ignored as they are assumed to be an inline resource of a custom
-      # resource, and we only care about tracking top-level resources.
-      def resource_current_state_loaded(new_resource, action, current_resource)
-        return if nested_resource?(new_resource)
-        initialize_resource_report_if_needed(new_resource, action, current_resource)
-      end
-
-      # see EventDispatch::Base#resource_up_to_date
-      # Mark our ResourceReport status accordingly
-      def resource_up_to_date(new_resource, action)
-        initialize_resource_report_if_needed(new_resource, action)
-        current_resource_report.up_to_date unless nested_resource?(new_resource)
-      end
-
-      # see EventDispatch::Base#resource_skipped
-      # If this is a top-level resource, we create a ResourceReport
-      # instance (because a skipped resource does not trigger the
-      # resource_current_state_loaded event), and flag it as skipped.
-      def resource_skipped(new_resource, action, conditional)
-        return if nested_resource?(new_resource)
-
-        initialize_resource_report_if_needed(new_resource, action)
-        current_resource_report.skipped(conditional)
-      end
-
-      # see EventDispatch::Base#resource_updated
-      # Flag the current ResourceReport instance as updated (as long as it's
-      # a top-level resource).
-      def resource_updated(new_resource, action)
-        initialize_resource_report_if_needed(new_resource, action)
-        current_resource_report.updated unless nested_resource?(new_resource)
-      end
-
-      # see EventDispatch::Base#resource_failed
-      # Flag the current ResourceReport as failed and supply the exception as
-      # long as it's a top-level resource, and update the run error text
-      # with the proper Formatter.
-      def resource_failed(new_resource, action, exception)
-        initialize_resource_report_if_needed(new_resource, action)
-        current_resource_report.failed(exception) unless nested_resource?(new_resource)
-        update_error_description(
-          Formatters::ErrorMapper.resource_failed(
-            new_resource,
-            action,
-            exception
-          ).for_json
-        )
+      # Hook to grab the run_status.  We also make the decision to run or not run here (our
+      # config has been parsed so we should know if we need to run, we unregister if we do
+      # not want to run).
+      #
+      # (see EventDispatch::Base#run_start)
+      #
+      def run_start(chef_version, run_status)
+        events.unregister(self) unless should_be_enabled?
+        @run_status = run_status
       end
 
-      # see EventDispatch::Base#resource_completed
-      # Mark the ResourceReport instance as finished (for timing details).
-      # This marks the end of this resource during this run.
-      def resource_completed(new_resource)
-        if current_resource_report && !nested_resource?(new_resource)
-          current_resource_report.finish
-          add_resource_report(current_resource_report)
-          clear_current_resource_report
-        end
+      # Hook to grab the node object after it has been successfully loaded
+      #
+      # (see EventDispatch::Base#node_load_success)
+      #
+      def node_load_success(node)
+        @node = node
       end
 
-      # see EventDispatch::Base#run_list_expanded
       # The expanded run list is stored for later use by the run_completed
       # event and message.
+      #
+      # (see EventDispatch::Base#run_list_expanded)
+      #
       def run_list_expanded(run_list_expansion)
         @expanded_run_list = run_list_expansion
       end
 
-      # see EventDispatch::Base#run_list_expand_failed
-      # The run error text is updated with the output of the appropriate
-      # formatter.
-      def run_list_expand_failed(node, exception)
-        update_error_description(
-          Formatters::ErrorMapper.run_list_expand_failed(
-            node,
-            exception
-          ).for_json
-        )
+      # Hook event to register with the action_collection if we are still enabled.
+      #
+      # This is also how we wire up to the action_collection since it passes itself as the argument.
+      #
+      # (see EventDispatch::Base#action_collection_registration)
+      #
+      def action_collection_registration(action_collection)
+        @action_collection = action_collection
+        action_collection.register(self)
       end
 
-      # see EventDispatch::Base#cookbook_resolution_failed
-      # The run error text is updated with the output of the appropriate
-      # formatter.
-      def cookbook_resolution_failed(expanded_run_list, exception)
-        update_error_description(
-          Formatters::ErrorMapper.cookbook_resolution_failed(
-            expanded_run_list,
-            exception
-          ).for_json
-        )
-      end
+      # - Creates and writes our NodeUUID back to the node object
+      # - Sanity checks the data collector
+      # - Sends the run start message
+      # - If the run_start message fails, this may disable the rest of data collection or fail hard
+      #
+      # (see EventDispatch::Base#run_started)
+      #
+      def run_started(run_status)
+        Chef::DataCollector::ConfigValidation.validate_server_url!
+        Chef::DataCollector::ConfigValidation.validate_output_locations!
 
-      # see EventDispatch::Base#cookbook_sync_failed
-      # The run error text is updated with the output of the appropriate
-      # formatter.
-      def cookbook_sync_failed(cookbooks, exception)
-        update_error_description(
-          Formatters::ErrorMapper.cookbook_sync_failed(
-            cookbooks,
-            exception
-          ).for_json
-        )
+        send_run_start
       end
 
-      # see EventDispatch::Base#deprecation
-      # Append a received deprecation to the list of deprecations
+      # Hook event to accumulating deprecation messages
+      #
+      # (see EventDispatch::Base#deprecation)
+      #
       def deprecation(message, location = caller(2..2)[0])
-        add_deprecation(message.message, message.url, location)
+        @deprecations << { message: message.message, url: message.url, location: message.location }
+      end
+
+      # Hook to send the run completion message with a status of success
+      #
+      # (see EventDispatch::Base#run_completed)
+      #
+      def run_completed(node)
+        send_run_completion("success")
+      end
+
+      # Hook to send the run completion message with a status of failed
+      #
+      # (see EventDispatch::Base#run_failed)
+      #
+      def run_failed(exception)
+        send_run_completion("failure")
       end
 
       private
 
-      # Selects the type of HTTP client to use based on whether we are using
-      # token-based or signed header authentication. Token authentication is
-      # intended to be used primarily for Chef Solo in which case no signing
-      # key will be available (in which case `Chef::ServerAPI.new()` would
-      # raise an exception.
+      # Construct a http client for either the main data collector or for the http output_locations.
+      #
+      # Note that based on the token setting either the main data collector and all the http output_locations
+      # are going to all require chef-server authentication or not.  There is no facility to mix-and-match on
+      # a per-url basis.
+      #
+      # @param url [String] the string url to connect to
+      # @returns [Chef::HTTP] the appropriate Chef::HTTP subclass instance to use
+      #
       def setup_http_client(url)
-        if data_collector_token.nil?
+        if Chef::Config[:data_collector][:token].nil?
           Chef::ServerAPI.new(url, validate_utf8: false)
         else
           Chef::HTTP::SimpleJSON.new(url, validate_utf8: false)
         end
       end
 
-      def setup_http_output_locations
-        Chef::Config[:data_collector][:output_locations][:urls].each_with_object({}) do |location_url, http_output_locations|
-          http_output_locations[location_url] = setup_http_client(location_url)
-        end
-      end
-
+      # Handle POST'ing data to the data collector.  Note that this is a totally separate concern
+      # from the array of URI's in the extra configured output_locations.
       #
-      # Yields to the passed-in block (which is expected to be some interaction
-      # with the DataCollector endpoint). If some communication failure occurs,
-      # either disable any future communications to the DataCollector endpoint, or
-      # raise an exception (if the user has set
-      # Chef::Config.data_collector.raise_on_failure to true.)
+      # On failure this will unregister the data collector (if there are no other configured output_locations)
+      # and optionally will either silently continue or fail hard depending on configuration.
       #
-      # @param block [Proc] A ruby block to run. Ignored if a command is given.
+      # @param message [Hash] message to send
       #
-      def disable_reporter_on_error
-        yield
+      def send_to_data_collector(message)
+        return unless Chef::Config[:data_collector][:server_url]
+        @http ||= setup_http_client(Chef::Config[:data_collector][:server_url])
+        @http.post(nil, message, headers)
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
-             Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
-             Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError,
-             Errno::EHOSTDOWN => e
+        Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError,
+        Errno::EHOSTDOWN => e
         # Do not disable data collector reporter if additional output_locations have been specified
-        disable_data_collector_reporter unless data_collector_output_locations
-        code = if e.respond_to?(:response) && e.response.code
-                 e.response.code.to_s
-               else
-                 "Exception Code Empty"
-               end
+        events.unregister(self) unless Chef::Config[:data_collector][:output_locations]
+
+        code = e&.response&.code&.to_s || "Exception Code Empty"
 
-        msg = "Error while reporting run start to Data Collector. " \
-              "URL: #{data_collector_server_url} " \
-              "Exception: #{code} -- #{e.message} "
+        msg = "Error while reporting run start to Data Collector. URL: #{Chef::Config[:data_collector][:server_url]} Exception: #{code} -- #{e.message} "
 
         if Chef::Config[:data_collector][:raise_on_failure]
           Chef::Log.error(msg)
@@ -344,222 +197,128 @@ class Chef
         end
       end
 
-      def send_to_data_collector(message)
-        return unless data_collector_accessible?
-        http.post(nil, message, headers) if data_collector_server_url
-      end
-
+      # Process sending the configured message to all the extra output locations.
+      #
+      # @param message [Hash] message to send
+      #
       def send_to_output_locations(message)
-        data_collector_output_locations.each do |type, location_list|
-          location_list.each do |l|
-            handle_output_location(type, l, message)
+        return unless Chef::Config[:data_collector][:output_locations]
+
+        Chef::Config[:data_collector][:output_locations].each do |type, locations|
+          locations.each do |location|
+            send_to_file_location(location, message) if type == :files
+            send_to_http_location(location, message) if type == :urls
           end
         end
       end
 
-      def handle_output_location(type, loc, message)
-        type == :urls ? send_to_http_location(loc, message) : send_to_file_location(loc, message)
-      end
-
+      # Sends a single message to a file, rendered as JSON.
+      #
+      # @param file_name [String] the file to write to
+      # @param message [Hash] the message to render as JSON
+      #
       def send_to_file_location(file_name, message)
-        open(file_name, "a") { |f| f.puts message }
+        File.open(file_name, "a") do |fh|
+          fh.puts Chef::JSONCompat.to_json(message, validate_utf8: false)
+        end
       end
 
+      # Sends a single message to a http uri, rendered as JSON.  Maintains a cache of Chef::HTTP
+      # objects to use on subsequent requests.
+      #
+      # @param http_url [String] the configured http uri string endpoint to send to
+      # @param message [Hash] the message to render as JSON
+      #
       def send_to_http_location(http_url, message)
-        @http_output_locations[http_url].post(nil, message, headers) if @http_output_locations[http_url]
+        @http_output_locations_clients[http_url] ||= setup_http_client(http_url)
+        @http_output_locations_clients[http_url].post(nil, message, headers)
       rescue
-        Chef::Log.trace("Data collector failed to send to URL location #{http_url}. Please check your configured data_collector.output_locations")
+        # FIXME: we do all kinds of complexity to deal with errors in send_to_data_collector and we just don't care here, which feels like
+        # like poor behavior on several different levels, at least its a warn now... (I don't quite understand why it was written this way)
+        Chef::Log.warn("Data collector failed to send to URL location #{http_url}. Please check your configured data_collector.output_locations")
       end
 
+      # @return [Boolean] if we've sent a run_start message yet
+      def sent_run_start?
+        !!@sent_run_start
+      end
+
+      # Send the run start message to the configured server or output locations
       #
-      # Send any messages to the DataCollector endpoint that are necessary to
-      # indicate the run has completed. Currently, two messages are sent:
-      #
-      # - An "action" message with the node object indicating it's been updated
-      # - An "run_converge" (i.e. RunEnd) message with details about the run,
-      #   what resources were modified/up-to-date/skipped, etc.
+      def send_run_start
+        message = Chef::DataCollector::RunStartMessage.construct_message(self)
+        send_to_data_collector(message)
+        send_to_output_locations(message)
+        @sent_run_start = true
+      end
+
+      # Send the run completion message to the configured server or output locations
       #
-      # @param opts [Hash] Additional details about the run, such as its success/failure.
+      # @param status [String] Either "success" or "failed"
       #
-      def send_run_completion(opts)
-        # If run_status is nil we probably failed before the client triggered
-        # the run_started callback. In this case we'll skip updating because
-        # we have nothing to report.
-        return unless run_status
+      def send_run_completion(status)
+        # this is necessary to send a run_start message when we fail before the run_started chef event.
+        # we adhere to a contract that run_start + run_completion events happen in pairs.
+        send_run_start unless sent_run_start?
 
-        message = Chef::DataCollector::Messages.run_end_message(
-                   run_status: run_status,
-                   expanded_run_list: expanded_run_list,
-                   resources: all_resource_reports,
-                   status: opts[:status],
-                   error_descriptions: error_descriptions,
-                   deprecations: deprecations.to_a
-                  )
-        disable_reporter_on_error do
-          send_to_data_collector(message)
-        end
-        send_to_output_locations(message) if data_collector_output_locations
+        message = Chef::DataCollector::RunEndMessage.construct_message(self, status)
+        send_to_data_collector(message)
+        send_to_output_locations(message)
       end
 
+      # @return [Hash] HTTP headers for the data collector endpoint
       def headers
         headers = { "Content-Type" => "application/json" }
 
-        unless data_collector_token.nil?
-          headers["x-data-collector-token"] = data_collector_token
+        unless Chef::Config[:data_collector][:token].nil?
+          headers["x-data-collector-token"] = Chef::Config[:data_collector][:token]
           headers["x-data-collector-auth"]  = "version=1.0"
         end
 
         headers
       end
 
-      def data_collector_server_url
-        Chef::Config[:data_collector][:server_url]
-      end
-
-      def data_collector_output_locations
-        Chef::Config[:data_collector][:output_locations]
-      end
-
-      def data_collector_token
-        Chef::Config[:data_collector][:token]
-      end
-
-      def add_resource_report(resource_report)
-        @all_resource_reports << OpenStruct.new(
-          resource: resource_report.new_resource,
-          action: resource_report.action,
-          report_data: resource_report.to_h
-        )
-      end
-
-      def disable_data_collector_reporter
-        @enabled = false
-      end
-
-      def data_collector_accessible?
-        @enabled
-      end
-
-      def update_run_status(run_status)
-        @run_status = run_status
-      end
-
-      def update_error_description(discription_hash)
-        @error_descriptions = discription_hash
-      end
-
-      def add_deprecation(message, url, location)
-        @deprecations << { message: message, url: url, location: location }
-      end
-
-      def initialize_resource_report_if_needed(new_resource, action, current_resource = nil)
-        return unless current_resource_report.nil?
-        @current_resource_report = create_resource_report(new_resource, action, current_resource)
-      end
-
-      def create_resource_report(new_resource, action, current_resource = nil)
-        Chef::DataCollector::ResourceReport.new(
-          new_resource,
-          action,
-          current_resource
-        )
-      end
-
-      def clear_current_resource_report
-        @current_resource_report = nil
-      end
-
-      def detect_unprocessed_resources
-        # create a Hash (for performance reasons, rather than an Array) containing all
-        # resource+action combinations from the Resource Collection
-        #
-        # We use the object ID instead of the resource itself in the Hash key because
-        # we currently allow users to create a property called "hash" which creates
-        # a #hash instance method on the resource. Ruby expects that to be a Fixnum,
-        # so bad things happen when adding an object to an Array or a Hash if it's not.
-        collection_resources = {}
-        run_context.resource_collection.all_resources.each do |resource|
-          Array(resource.action).each do |action|
-            collection_resources[[resource.__id__, action]] = resource
-          end
-        end
-
-        # Delete from the Hash any resource+action combination we have
-        # already processed.
-        all_resource_reports.each do |report|
-          collection_resources.delete([report.resource.__id__, report.action])
-        end
-
-        # The items remaining in the Hash are unprocessed resource+actions,
-        # so we'll create new resource reports for them which default to
-        # a state of "unprocessed".
-        collection_resources.each do |key, resource|
-          # The Hash key is an array of the Resource's object ID and the action.
-          # We need to pluck out the action.
-          add_resource_report(create_resource_report(resource, key[1]))
-        end
-      end
-
-      # If we are getting messages about a resource while we are in the middle of
-      # another resource's update, we assume that the nested resource is just the
-      # implementation of a provider, and we want to hide it from the reporting
-      # output.
-      def nested_resource?(new_resource)
-        @current_resource_report && @current_resource_report.new_resource != new_resource
-      end
-
-      def validate_and_return_uri(uri)
-        URI(uri)
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      def validate_and_create_file(file)
-        send_to_file_location(file, "")
-        true
-      # Rescue exceptions raised by the file path being non-existent or not writeable and re-raise them to the user
-      # with clearer explanatory text.
-      rescue Errno::ENOENT
-        raise Chef::Exceptions::ConfigurationError,
-              "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which is a non existent file path."
-      rescue Errno::EACCES
-        raise Chef::Exceptions::ConfigurationError,
-              "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which cannnot be written to by Chef."
-      end
-
-      def validate_data_collector_server_url!
-        unless !data_collector_server_url && data_collector_output_locations
-          uri = validate_and_return_uri(data_collector_server_url)
-          unless uri
-            raise Chef::Exceptions::ConfigurationError, "Chef::Config[:data_collector][:server_url] (#{data_collector_server_url}) is not a valid URI."
-          end
-
-          if uri.host.nil?
-            raise Chef::Exceptions::ConfigurationError,
-              "Chef::Config[:data_collector][:server_url] (#{data_collector_server_url}) is a URI with no host. Please supply a valid URL."
-          end
+      # Main logic controlling the data collector being enabled or disabled:
+      #
+      # * disabled in why-run mode
+      # * disabled when `Chef::Config[:data_collector][:mode]` excludes the solo-vs-client mode
+      # * disabled if there is no server_url or no output_locations to log to
+      # * enabled if there is a configured output_location even without a token
+      # * disabled in solo mode if the user did not configure the auth token
+      #
+      # @return [Boolean] true if the data collector should be enabled
+      #
+      def should_be_enabled?
+        running_mode = ( Chef::Config[:solo_legacy_mode] || Chef::Config[:local_mode] ) ? :solo : :client
+        want_mode = Chef::Config[:data_collector][:mode]
+
+        case
+        when Chef::Config[:why_run]
+          Chef::Log.trace("data collector is disabled for why run mode")
+          return false
+        when (want_mode != :both) && running_mode != want_mode
+          Chef::Log.trace("data collector is configured to only run in #{Chef::Config[:data_collector][:mode]} modes, disabling it")
+          return false
+        when !(Chef::Config[:data_collector][:server_url] || Chef::Config[:data_collector][:output_locations])
+          Chef::Log.trace("Neither data collector URL or output locations have been configured, disabling data collector")
+          return false
+        when running_mode == :client && Chef::Config[:data_collector][:token]
+          Chef::Log.warn("Data collector token authentication is not recommended for client-server mode. " \
+                         "Please upgrade #{Chef::Dist::SERVER_PRODUCT} to 12.11 or later and remove the token from your config file " \
+                         "to use key based authentication instead")
+          return true
+        when Chef::Config[:data_collector][:output_locations] && Chef::Config[:data_collector][:output_locations][:files] && !Chef::Config[:data_collector][:output_locations][:files].empty?
+          # we can run fine to a file without a token, even in solo mode.
+          return true
+        when running_mode == :solo && !Chef::Config[:data_collector][:token]
+          # we are in solo mode and are not logging to a file, so must have a token
+          Chef::Log.trace("Data collector token must be configured to use Chef Automate data collector with #{Chef::Dist::PRODUCT} Solo")
+          return false
+        else
+          return true
         end
       end
 
-      def handle_type(type, loc)
-        type == :urls ? validate_and_return_uri(loc) : validate_and_create_file(loc)
-      end
-
-      def validate_data_collector_output_locations!
-        if data_collector_output_locations.empty?
-          raise Chef::Exceptions::ConfigurationError,
-                "Chef::Config[:data_collector][:output_locations] is empty. Please supply an hash of valid URLs and / or local file paths."
-        end
-
-        data_collector_output_locations.each do |type, locations|
-          locations.each do |l|
-            unless handle_type(type, l)
-              raise Chef::Exceptions::ConfigurationError,
-                      "Chef::Config[:data_collector][:output_locations] contains the location #{l} which is not valid."
-            end
-          end
-        end
-      end
     end
   end
 end