puppet_litmus 0.15.0 → 0.18.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5910db3eed130389c917cfb64116897400905e1d66851f57e16be04d1070b95a
-  data.tar.gz: 01066623755c8b944f4362c0829fd46e3aaa13866a206fe17c74a19da3ed8143
+  metadata.gz: c9148f5cf259702d6b12f875555b4cbef8fdbc4ff78081e495ca1b9b8948d082
+  data.tar.gz: 3b002919bfff6ce6cb794ed9bd3d8b6b5712ba76d1cceceba1c8d205488f9057
 SHA512:
-  metadata.gz: 4ce37bbfc92942ee4a50c4cc0831ccd8deac29ec092001c1c82dc3b7a8c57cd1bdb745bb64e224fc0fbc220c458b990b4ea429908a6548a7d18195a63873b3d3
-  data.tar.gz: 49b0a06fdf5772a2ed5104108cc4163b96b6eb500f1bf70259052099ab9231ee7d6b7c56bdfdc3af2708229600eda0c9bd41fb53cf5438db8c5f17309e24728a
+  metadata.gz: 458f9935cf9148d839f0a2ac3cb3851a85ef18df7a7e99a0b216adafb9d33999a1d672da95f5450c1b371794cd6ecf7d92131778d79cdb47ea0cd0788e1901c4
+  data.tar.gz: 4c1c40a1b40865ff788af2f52c6766a5f5d159674ce3f62173da91713dd96f5e1e78f1fb41234e5a7d82aa89c1cb1b2f35a29c841bf2e3307719506c4a130793

data/README.md

@@ -8,27 +8,23 @@
 </div>
 
 ## Overview
-Litmus provides a simple command line tool for Puppet content creators, to enable both simple and complex test deployments against specifically configured target systems. It is available as a gem, and can be installed by running ```gem install puppet_litmus```.
 
-Litmus allows Puppet module developers to:
-* provision targets to test against,
-* install the Puppet Agent, 
-* install a module,
-* run tests, and
-* tear down the infrastructure.
+Litmus is a command line tool that allows you to run acceptance tests against Puppet modules.
 
-The tool facilitates parallel test runs, running tests in isolation, and each step is standalone, allowing other operations between test runs, such as debugging, or configuration updates on the test targets.
+Litmus allows you to:
+* Provision targets to test against
+* Install a Puppet agent
+* Install a module
+* Run tests
+* Tear down the infrastructure
 
-## Documentation
+Litmus also facilitates parallel test runs and running tests in isolation. Each step is standalone, allowing other operations between test runs, such as debugging or configuration updates on the test targets.
+
+Install Litmus as a gem by running ```gem install puppet_litmus```.
 
-All our documentation is currently available in the [Wiki](https://github.com/puppetlabs/puppet_litmus/wiki).
+## Documentation
 
-* [Overview](https://github.com/puppetlabs/puppet_litmus/wiki/Overview-of-Litmus) of the main functions
-* [Architecture](https://github.com/puppetlabs/puppet_litmus/wiki/Architecture-of-puppet-litmus) with an explanation of what's going on under the hood
-* [Step-by-step guide](https://github.com/puppetlabs/puppet_litmus/wiki/Tutorial:-use-Litmus-to-execute-acceptance-tests-with-a-sample-module-(MoTD)) of how to use Litmus with the popular and simple [MoTD Puppet module](https://forge.puppet.com/puppetlabs/motd).
-* [How to guide](https://github.com/puppetlabs/puppet_litmus/wiki/Converting-a-module-to-use-Litmus) walking through how to use Litmus in a module
-* [Helper functions](https://github.com/puppetlabs/puppet_litmus/wiki/Helper-Functions-for-Litmus) a guide to the various helper functions within Litmus.
-## Known issues
+For documentation, see our [Litmus Wiki](https://github.com/puppetlabs/puppet_litmus/wiki).
 
 ## Other Resources
 

data/lib/puppet_litmus.rb

@@ -8,7 +8,6 @@ require 'puppet_litmus/inventory_manipulation'
 require 'puppet_litmus/puppet_helpers'
 require 'puppet_litmus/rake_helper'
 require 'puppet_litmus/spec_helper_acceptance'
-require 'honeycomb-beeline'
 
 # Helper methods for testing puppet content
 module PuppetLitmus
@@ -16,23 +15,4 @@ module PuppetLitmus
   include PuppetLitmus::InventoryManipulation
   include PuppetLitmus::PuppetHelpers
   include PuppetLitmus::RakeHelper
-  Honeycomb.configure do |config|
-  end
-  process_span = Honeycomb.start_span(name: 'Litmus Testing')
-  if ENV['CI'] == 'true' && ENV['TRAVIS'] == 'true'
-    process_span.add_field('module_name', ENV['TRAVIS_REPO_SLUG'])
-    process_span.add_field('travis_build_id', ENV['TRAVIS_BUILD_ID'])
-    process_span.add_field('travis_build_web_url', ENV['TRAVIS_BUILD_WEB_URL'])
-    process_span.add_field('travis_commit_message', ENV['TRAVIS_COMMIT_MESSAGE'])
-    process_span.add_field('travis_pull_request_sha', ENV['TRAVIS_PULL_REQUEST_SHA'])
-  elsif ENV['CI'] == 'True' && ENV['APPVEYOR'] == 'True'
-    process_span.add_field('module_name', ENV['APPVEYOR_PROJECT_SLUG'])
-    process_span.add_field('appveyor_build_id', ENV['APPVEYOR_BUILD_ID'])
-    process_span.add_field('appveyor_url', "https://ci.appveyor.com/project/#{ENV['APPVEYOR_REPO_NAME']}/builds/#{ENV['APPVEYOR_BUILD_ID']}")
-    process_span.add_field('appveyor_repo_commit_message', ENV['APPVEYOR_REPO_COMMIT_MESSAGE'])
-    process_span.add_field('appveyor_pull_request_head_commit', ENV['APPVEYOR_PULL_REQUEST_HEAD_COMMIT'])
-  end
-  at_exit do
-    process_span.send
-  end
 end

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+module PuppetLitmus; end # rubocop:disable Style/Documentation
+
 # helper functions for manipulating and reading a bolt inventory file
 module PuppetLitmus::InventoryManipulation
   # Creates an inventory hash from the inventory.yaml.
@@ -233,7 +235,7 @@ module PuppetLitmus::InventoryManipulation
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file
   # @param feature_name [String] feature to locate in the node
-  # node_name [String] node of nodes to limit the search for the node_name in
+  # @param node_name [String] node of nodes to limit the search for the node_name in
   # @return inventory.yaml file with feature removed from the node.
   # @return [Hash] inventory_hash with feature added to node if node_name exists in inventory hash.
   def remove_feature_from_node(inventory_hash, feature_name, node_name)
@@ -255,4 +257,13 @@ module PuppetLitmus::InventoryManipulation
   def write_to_inventory_file(inventory_hash, inventory_full_path)
     File.open(inventory_full_path, 'wb+') { |f| f.write(inventory_hash.to_yaml) }
   end
+
+  # Add the `litmus.platform` with platform information for the target
+  #
+  # @param inventory_hash [Hash] hash of the inventory.yaml file
+  # @param node_name [String] node of nodes to limit the search for the node_name in
+  def add_platform_field(inventory_hash, node_name)
+    facts = facts_from_node(inventory_hash, node_name)
+    Honeycomb.current_span.add_field('litmus.platform', facts&.dig('platform'))
+  end
 end

data/lib/puppet_litmus/puppet_helpers.rb

@@ -8,87 +8,107 @@ module PuppetLitmus::PuppetHelpers
   # @param manifest [String] puppet manifest code to be applied.
   # @return [Boolean] The result of the 2 apply manifests.
   def idempotent_apply(manifest)
-    manifest_file_location = create_manifest_file(manifest)
-    apply_manifest(nil, expect_failures: false, manifest_file_location: manifest_file_location)
-    apply_manifest(nil, catch_changes: true, manifest_file_location: manifest_file_location)
+    Honeycomb.start_span(name: 'litmus.idempotent_apply') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      manifest_file_location = create_manifest_file(manifest)
+      apply_manifest(nil, expect_failures: false, manifest_file_location: manifest_file_location)
+      apply_manifest(nil, catch_changes: true, manifest_file_location: manifest_file_location)
+    end
   end
 
-  # rubocop:disable Layout/TrailingWhitespace
-
   # Applies a manifest. returning the result of that apply. Mimics the apply_manifest from beaker
-  # 
+  #
   # When you set the environment variable RSPEC_DEBUG, the output of your
   # puppet run will be displayed. If you have set the :debug flag, you will see the
   # full debug log. If you have **not** set the :debug flag, it will display the regular
   # output.
   #
   # @param manifest [String] puppet manifest code to be applied.
-  # @param opts [Hash] Alters the behaviour of the command. Valid options are:  
-  #  :catch_changes [Boolean] (false) We're after idempotency so allow exit code 0 only.  
-  #  :expect_changes [Boolean] (false) We're after changes specifically so allow exit code 2 only.  
-  #  :catch_failures [Boolean] (false) We're after only complete success so allow exit codes 0 and 2 only.  
-  #  :expect_failures [Boolean] (false) We're after failures specifically so allow exit codes 1, 4, and 6 only.  
-  #  :manifest_file_location [Path] The place on the target system.  
+  # @param opts [Hash] Alters the behaviour of the command. Valid options are:
+  #  :catch_changes [Boolean] (false) We're after idempotency so allow exit code 0 only.
+  #  :expect_changes [Boolean] (false) We're after changes specifically so allow exit code 2 only.
+  #  :catch_failures [Boolean] (false) We're after only complete success so allow exit codes 0 and 2 only.
+  #  :expect_failures [Boolean] (false) We're after failures specifically so allow exit codes 1, 4, and 6 only.
+  #  :manifest_file_location [Path] The place on the target system.
   #  :hiera_config [Path] The path to the hiera.yaml configuration on the runner.
-  #  :prefix_command [String] prefixes the puppet apply command; eg "export LANGUAGE='ja'".  
-  #  :debug [Boolean] run puppet apply with the debug flag.  
-  #  :noop [Boolean] run puppet apply with the noop flag.  
+  #  :prefix_command [String] prefixes the puppet apply command; eg "export LANGUAGE='ja'".
+  #  :trace [Boolean] run puppet apply with the trace flag (defaults to `true`).
+  #  :debug [Boolean] run puppet apply with the debug flag.
+  #  :noop [Boolean] run puppet apply with the noop flag.
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the apply.
   def apply_manifest(manifest, opts = {})
-    # rubocop:enable Layout/TrailingWhitespace
-    target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
-    raise 'manifest and manifest_file_location in the opts hash are mutually exclusive arguments, pick one' if !manifest.nil? && !opts[:manifest_file_location].nil?
-    raise 'please pass a manifest or the manifest_file_location in the opts hash' if (manifest.nil? || manifest == '') && opts[:manifest_file_location].nil?
-    raise 'please specify only one of `catch_changes`, `expect_changes`, `catch_failures` or `expect_failures`' if
-      [opts[:catch_changes], opts[:expect_changes], opts[:catch_failures], opts[:expect_failures]].compact.length > 1
-
-    if opts[:catch_changes]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [0]
-    elsif opts[:catch_failures]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [0, 2]
-    elsif opts[:expect_failures]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [1, 4, 6]
-    elsif opts[:expect_changes]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [2]
-    else
-      use_detailed_exit_codes = false
-      acceptable_exit_codes = [0]
-    end
+    Honeycomb.start_span(name: 'litmus.apply_manifest') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.manifest', manifest)
+      span.add_field('litmus.opts', opts)
 
-    manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
-    inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-    raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-
-    command_to_run = "#{opts[:prefix_command]} puppet apply #{manifest_file_location}"
-    command_to_run += " --modulepath #{Dir.pwd}/spec/fixtures/modules" if target_node_name == 'litmus_localhost'
-    command_to_run += " --hiera_config='#{opts[:hiera_config]}'" unless opts[:hiera_config].nil?
-    command_to_run += ' --debug' if !opts[:debug].nil? && (opts[:debug] == true)
-    command_to_run += ' --noop' if !opts[:noop].nil? && (opts[:noop] == true)
-    command_to_run += ' --detailed-exitcodes' if use_detailed_exit_codes == true
-
-    result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
-    status = result.first['result']['exit_code']
-    if opts[:catch_changes] && !acceptable_exit_codes.include?(status)
-      report_puppet_apply_change(command_to_run, result)
-    elsif !acceptable_exit_codes.include?(status)
-      report_puppet_apply_error(command_to_run, result, acceptable_exit_codes)
-    end
+      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
+      raise 'manifest and manifest_file_location in the opts hash are mutually exclusive arguments, pick one' if !manifest.nil? && !opts[:manifest_file_location].nil?
+      raise 'please pass a manifest or the manifest_file_location in the opts hash' if (manifest.nil? || manifest == '') && opts[:manifest_file_location].nil?
+      raise 'please specify only one of `catch_changes`, `expect_changes`, `catch_failures` or `expect_failures`' if
+        [opts[:catch_changes], opts[:expect_changes], opts[:catch_failures], opts[:expect_failures]].compact.length > 1
+
+      opts = { trace: true }.merge(opts)
+
+      if opts[:catch_changes]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [0]
+      elsif opts[:catch_failures]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [0, 2]
+      elsif opts[:expect_failures]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [1, 4, 6]
+      elsif opts[:expect_changes]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [2]
+      else
+        use_detailed_exit_codes = false
+        acceptable_exit_codes = [0]
+      end
 
-    result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
-                            stdout: result.first['result']['stdout'],
-                            stderr: result.first['result']['stderr'])
-    yield result if block_given?
-    if ENV['RSPEC_DEBUG']
-      puts "apply manifest succeded\n #{command_to_run}\n======\nwith status #{result.exit_code}"
-      puts result.stderr
-      puts result.stdout
+      manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
+      inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
+      raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+
+      span.add_field('litmus.node_name', target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
+
+      command_to_run = "#{opts[:prefix_command]} puppet apply #{manifest_file_location}"
+      command_to_run += ' --trace' if !opts[:trace].nil? && (opts[:trace] == true)
+      command_to_run += " --modulepath #{Dir.pwd}/spec/fixtures/modules" if target_node_name == 'litmus_localhost'
+      command_to_run += " --hiera_config='#{opts[:hiera_config]}'" unless opts[:hiera_config].nil?
+      command_to_run += ' --debug' if !opts[:debug].nil? && (opts[:debug] == true)
+      command_to_run += ' --noop' if !opts[:noop].nil? && (opts[:noop] == true)
+      command_to_run += ' --detailed-exitcodes' if use_detailed_exit_codes == true
+
+      span.add_field('litmus.command_to_run', command_to_run)
+      span.add_field('litmus.target_node_name', target_node_name)
+      bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', bolt_result)
+
+      result = OpenStruct.new(exit_code: bolt_result.first['value']['exit_code'],
+                              stdout: bolt_result.first['value']['stdout'],
+                              stderr: bolt_result.first['value']['stderr'])
+      span.add_field('litmus.result', result.to_h)
+
+      status = result.exit_code
+      if opts[:catch_changes] && !acceptable_exit_codes.include?(status)
+        report_puppet_apply_change(command_to_run, bolt_result)
+      elsif !acceptable_exit_codes.include?(status)
+        report_puppet_apply_error(command_to_run, bolt_result, acceptable_exit_codes)
+      end
+
+      yield result if block_given?
+
+      if ENV['RSPEC_DEBUG']
+        puts "apply manifest succeded\n #{command_to_run}\n======\nwith status #{result.exit_code}"
+        puts result.stderr
+        puts result.stdout
+      end
+      result
     end
-    result
   end
 
   # Creates a manifest file locally in a temp location, if its a remote target copy it to there.
@@ -96,23 +116,35 @@ module PuppetLitmus::PuppetHelpers
   # @param manifest [String] puppet manifest code.
   # @return [String] The path to the location of the manifest.
   def create_manifest_file(manifest)
-    require 'tmpdir'
-    target_node_name = ENV['TARGET_HOST']
-    tmp_filename = File.join(Dir.tmpdir, "manifest_#{Time.now.strftime('%Y%m%d')}_#{Process.pid}_#{rand(0x100000000).to_s(36)}.pp")
-    manifest_file = File.open(tmp_filename, 'w')
-    manifest_file.write(manifest)
-    manifest_file.close
-    if target_node_name.nil? || target_node_name == 'localhost'
-      # no need to transfer
-      manifest_file_location = manifest_file.path
-    else
-      # transfer to TARGET_HOST
-      inventory_hash = inventory_hash_from_inventory_file
-      manifest_file_location = "/tmp/#{File.basename(manifest_file)}"
-      result = upload_file(manifest_file.path, manifest_file_location, target_node_name, options: {}, config: nil, inventory: inventory_hash)
-      raise result.first['result'].to_s unless result.first['status'] == 'success'
+    Honeycomb.start_span(name: 'litmus.create_manifest_file') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.manifest', manifest)
+
+      require 'tmpdir'
+      target_node_name = ENV['TARGET_HOST']
+      tmp_filename = File.join(Dir.tmpdir, "manifest_#{Time.now.strftime('%Y%m%d')}_#{Process.pid}_#{rand(0x100000000).to_s(36)}.pp")
+      manifest_file = File.open(tmp_filename, 'w')
+      manifest_file.write(manifest)
+      manifest_file.close
+      if target_node_name.nil? || target_node_name == 'localhost'
+        # no need to transfer
+        manifest_file_location = manifest_file.path
+      else
+        # transfer to TARGET_HOST
+        inventory_hash = inventory_hash_from_inventory_file
+        span.add_field('litmus.node_name', target_node_name)
+        add_platform_field(inventory_hash, target_node_name)
+
+        manifest_file_location = File.basename(manifest_file)
+        bolt_result = upload_file(manifest_file.path, manifest_file_location, target_node_name, options: {}, config: nil, inventory: inventory_hash)
+        span.add_field('litmus.bolt_result', bolt_result)
+        raise bolt_result.first['value'].to_s unless bolt_result.first['status'] == 'success'
+      end
+
+      span.add_field('litmus.manifest_file_location', manifest_file_location)
+
+      manifest_file_location
     end
-    manifest_file_location
   end
 
   # Runs a command against the target system
@@ -122,23 +154,31 @@ module PuppetLitmus::PuppetHelpers
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the command.
   def run_shell(command_to_run, opts = {})
-    Honeycomb.start_span(name: 'litmus_runshell') do |span|
+    Honeycomb.start_span(name: 'litmus.run_shell') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.command_to_run', command_to_run)
+      span.add_field('litmus.opts', opts)
+
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
-      if result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
-        span.add_field('litmus_runshellfailure', result)
-        raise "shell failed\n`#{command_to_run}`\n======\n#{result}"
+      span.add_field('litmus.node_name', target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
+
+      bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', bolt_result)
+
+      if bolt_result.first['value']['exit_code'] != 0 && opts[:expect_failures] != true
+        raise "shell failed\n`#{command_to_run}`\n======\n#{bolt_result}"
       end
 
-      result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
-                              exit_status: result.first['result']['exit_code'],
-                              stdout: result.first['result']['stdout'],
-                              stderr: result.first['result']['stderr'])
+      result = OpenStruct.new(exit_code: bolt_result.first['value']['exit_code'],
+                              exit_status: bolt_result.first['value']['exit_code'],
+                              stdout: bolt_result.first['value']['stdout'],
+                              stderr: bolt_result.first['value']['stderr'])
+      span.add_field('litmus.result', result.to_h)
       yield result if block_given?
-      span.add_field('litmus_runshellsuccess', result)
       result
     end
   end
@@ -151,52 +191,64 @@ module PuppetLitmus::PuppetHelpers
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the command.
   def bolt_upload_file(source, destination, opts = {}, options = {})
-    Honeycomb.start_span(name: 'litmus_uploadfile') do |span|
+    Honeycomb.start_span(name: 'litmus.bolt_upload_file') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.source', source)
+      span.add_field('litmus.destination', destination)
+      span.add_field('litmus.opts', opts)
+      span.add_field('litmus.options', options)
+
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.node_name', target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
+
+      bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', bolt_result)
 
       result_obj = {
         exit_code: 0,
-        stdout: result.first['result']['_output'],
+        stdout: bolt_result.first['value']['_output'],
         stderr: nil,
-        result: result.first['result'],
+        result: bolt_result.first['value'],
       }
 
-      if result.first['status'] != 'success'
+      if bolt_result.first['status'] != 'success'
         if opts[:expect_failures] != true
-          span.add_field('litmus_uploadfilefailure', result)
-          raise "upload file failed\n======\n#{result}"
+          span.add_field('litmus_uploadfilefailure', bolt_result)
+          raise "upload file failed\n======\n#{bolt_result}"
         end
 
         result_obj[:exit_code] = 255
-        result_obj[:stderr]    = result.first['result']['_error']['msg']
+        result_obj[:stderr]    = bolt_result.first['value']['_error']['msg']
       end
 
       result = OpenStruct.new(exit_code: result_obj[:exit_code],
                               stdout: result_obj[:stdout],
                               stderr: result_obj[:stderr])
+      span.add_field('litmus.result', result.to_h)
       yield result if block_given?
-      span.add_field('litmus_uploadfilesucess', result)
       result
     end
   end
 
-  # rubocop:disable Layout/TrailingWhitespace
-
   # Runs a task against the target system.
   #
   # @param task_name [String] The name of the task to run.
   # @param params [Hash] key : value pairs to be passed to the task.
-  # @param opts [Hash] Alters the behaviour of the command. Valid options are  
-  #  :expect_failures [Boolean] doesnt return an exit code of non-zero if the command failed.  
+  # @param opts [Hash] Alters the behaviour of the command. Valid options are
+  #  :expect_failures [Boolean] doesnt return an exit code of non-zero if the command failed.
   #  :inventory_file [String] path to the inventory file to use with the task.
   # @return [Object] A result object from the task.The values available are stdout, stderr and result.
-  # rubocop:enable Layout/TrailingWhitespace
   def run_bolt_task(task_name, params = {}, opts = {})
-    Honeycomb.start_span(name: 'litmus_runtask') do |span|
+    Honeycomb.start_span(name: 'litmus.run_task') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.task_name', task_name)
+      span.add_field('litmus.params', params)
+      span.add_field('litmus.opts', opts)
+
       config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = if !opts[:inventory_file].nil? && File.exist?(opts[:inventory_file])
@@ -208,34 +260,37 @@ module PuppetLitmus::PuppetHelpers
                        end
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
+      span.add_field('litmus.node_name', target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
+
+      bolt_result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
       result_obj = {
         exit_code: 0,
         stdout: nil,
         stderr: nil,
-        result: result.first['result'],
+        result: bolt_result.first['value'],
       }
 
-      if result.first['status'] == 'success'
+      if bolt_result.first['status'] == 'success'
         # stdout returns unstructured data if structured data is not available
-        result_obj[:stdout] = if result.first['result']['_output'].nil?
-                                result.first['result'].to_s
+        result_obj[:stdout] = if bolt_result.first['value']['_output'].nil?
+                                bolt_result.first['value'].to_s
                               else
-                                result.first['result']['_output']
+                                bolt_result.first['value']['_output']
                               end
 
       else
         if opts[:expect_failures] != true
-          span.add_field('litmus_runtaskfailure', result)
-          raise "task failed\n`#{task_name}`\n======\n#{result}"
+          span.add_field('litmus_runtaskfailure', bolt_result)
+          raise "task failed\n`#{task_name}`\n======\n#{bolt_result}"
         end
 
-        result_obj[:exit_code] = if result.first['result']['_error']['details'].nil?
+        result_obj[:exit_code] = if bolt_result.first['value']['_error']['details'].nil?
                                    255
                                  else
-                                   result.first['result']['_error']['details'].fetch('exitcode', 255)
+                                   bolt_result.first['value']['_error']['details'].fetch('exitcode', 255)
                                  end
-        result_obj[:stderr]    = result.first['result']['_error']['msg']
+        result_obj[:stderr]    = bolt_result.first['value']['_error']['msg']
       end
 
       result = OpenStruct.new(exit_code: result_obj[:exit_code],
@@ -243,7 +298,7 @@ module PuppetLitmus::PuppetHelpers
                               stderr: result_obj[:stderr],
                               result: result_obj[:result])
       yield result if block_given?
-      span.add_field('litmus_runtasksuccess', result)
+      span.add_field('litmus.result', result.to_h)
       result
     end
   end
@@ -256,23 +311,31 @@ module PuppetLitmus::PuppetHelpers
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the script run.
   def bolt_run_script(script, opts = {}, arguments: [])
-    Honeycomb.start_span(name: 'litmus_runscript') do |span|
+    Honeycomb.start_span(name: 'litmus.bolt_run_script') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.script', script)
+      span.add_field('litmus.opts', opts)
+      span.add_field('litmus.arguments', arguments)
+
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.node_name', target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
+
+      bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
 
-      if result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
-        span.add_field('litmus_runscriptfailure', result)
-        raise "script run failed\n`#{script}`\n======\n#{result}"
+      if bolt_result.first['value']['exit_code'] != 0 && opts[:expect_failures] != true
+        span.add_field('litmus_runscriptfailure', bolt_result)
+        raise "script run failed\n`#{script}`\n======\n#{bolt_result}"
       end
 
-      result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
-                              stdout: result.first['result']['stdout'],
-                              stderr: result.first['result']['stderr'])
+      result = OpenStruct.new(exit_code: bolt_result.first['value']['exit_code'],
+                              stdout: bolt_result.first['value']['stdout'],
+                              stderr: bolt_result.first['value']['stderr'])
       yield result if block_given?
-      span.add_field('litmus_runscriptsuccess', result)
+      span.add_field('litmus.result', result.to_h)
       result
     end
   end
@@ -289,14 +352,14 @@ module PuppetLitmus::PuppetHelpers
   # Report an error in the puppet run
   #
   # @param command [String] The puppet command causing the error.
-  # @param result  [Array] The result struct containing the result
-  def report_puppet_apply_error(command, result, acceptable_exit_codes)
+  # @param bolt_result  [Array] The result object from bolt
+  def report_puppet_apply_error(command, bolt_result, acceptable_exit_codes)
     puppet_apply_error = <<~ERROR
       apply manifest failed
       `#{command}`
-      with exit code #{result.first['result']['exit_code']} (expected: #{acceptable_exit_codes})
+      with exit code #{bolt_result.first['value']['exit_code']} (expected: #{acceptable_exit_codes})
       ====== Start output of failed Puppet apply ======
-      #{puppet_output(result)}
+      #{puppet_output(bolt_result)}
       ====== End output of failed Puppet apply ======
     ERROR
     raise puppet_apply_error
@@ -305,22 +368,22 @@ module PuppetLitmus::PuppetHelpers
   # Report an unexpected change in the puppet run
   #
   # @param command [String] The puppet command causing the error.
-  # @param result  [Array] The result struct containing the result
-  def report_puppet_apply_change(command, result)
+  # @param bolt_result  [Array] The result object from bolt
+  def report_puppet_apply_change(command, bolt_result)
     puppet_apply_changes = <<~ERROR
       apply manifest expected no changes
       `#{command}`
       ====== Start output of Puppet apply with unexpected changes ======
-      #{puppet_output(result)}
+      #{puppet_output(bolt_result)}
       ====== End output of Puppet apply with unexpected changes ======
     ERROR
     raise puppet_apply_changes
   end
 
   # Return the stdout of the puppet run
-  def puppet_output(result)
-    result.dig(0, 'result', 'stderr').to_s << \
-      result.dig(0, 'result', 'stdout').to_s
+  def puppet_output(bolt_result)
+    bolt_result.dig(0, 'value', 'stderr').to_s << \
+      bolt_result.dig(0, 'value', 'stdout').to_s
   end
 
   # Checks a puppet return status and returns true if it both