puppet_litmus 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2693612b3ed4ca88a6ea03742ea115b658d888635f7302a9b8ee36d447d8994
-  data.tar.gz: 0a2826a635e4ae9619de7a8b7c138506924896fc2ee7d297c78a5b430890150b
+  metadata.gz: f42320bf296d7e6efb9370a3e39b775a868417f9dc337aa7c5dee5052b055c6f
+  data.tar.gz: 607ab4fe445eb6f8b29d758212e84065b3e15b0273af85debec7676ea70c9115
 SHA512:
-  metadata.gz: 3b842feacbc47aa91f9b2f8aee6a81e37f7f58a06b73560ba4b5e61a0a798db4558b51823832a585233e224da8f594de0cb06f38cd1a3e25da83866687210975
-  data.tar.gz: baf2be2e9f64f2c0f8e60807494d109b82ce86bafaa33f2b1b46ecb9ad30a11393972b2fbad069528a9d8fe7dc3516afa0eb8cf90f443e1d210f93ba10942168
+  metadata.gz: 6abadc5c20561dd3f0db0b0bfcd96b55ba0df2e2fdfa97576fb48caabe538287ccb86750264fe10c0831b23e20f89d34946d4df2dd3cdf2e1e0adccb7d3f6538
+  data.tar.gz: f500ac82345c2c05abddf4e50d8c3492e37ef711b5c20a14fcda8d16ad6d5cecb13b64b43d343bd9e11eba242d80ef9584fa73f60fb36329c1b078d3c72f86bd

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -323,35 +323,9 @@ module PuppetLitmus::InventoryManipulation
   # @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 = begin
-      facts_from_node(inventory_hash, node_name)
-    rescue StandardError => e
-      warn e
-      {}
-    end
-    Honeycomb.current_span.add_field('litmus.platform', facts&.dig('platform'))
-  end
-
-  # Add platform custom information field to the current span for each node being targeted.
-  # If more than one node is being targeted, each node will be given a separate custom field.
-  #
-  # @param span [Honeycomb::Span] The current span
-  # @param target_node_names [Array[String]] Nodes being targeted
-  # @param inventory_hash [Hash] Hash of the inventory.yaml file
-  def add_node_fields_to_span(span, target_node_names, inventory_hash)
-    node_counter = 1
-    Array(target_node_names).each do |target_name|
-      name_field     = 'litmus.node_name'
-      platform_field = 'litmus.platform'
-
-      name_field = "#{name_field}_#{node_counter}"
-      platform_field = "#{platform_field}_#{node_counter}"
-      span.add_field(name_field, target_name)
-      if target_in_inventory?(inventory_hash, target_name)
-        facts = facts_from_node(inventory_hash, target_name)
-        span.add_field(platform_field, facts&.dig('platform')) unless facts.nil?
-      end
-      node_counter += 1
-    end
+    facts_from_node(inventory_hash, node_name)
+  rescue StandardError => e
+    warn e
+    {}
   end
 end

data/lib/puppet_litmus/puppet_helpers.rb

@@ -19,12 +19,9 @@ module PuppetLitmus::PuppetHelpers
   #  :noop [Boolean] run puppet apply with the noop flag.
   # @return [Boolean] The result of the 2 apply manifests.
   def idempotent_apply(manifest, opts = {})
-    Honeycomb.start_span(name: 'litmus.idempotent_apply') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      manifest_file_location = create_manifest_file(manifest)
-      apply_manifest(nil, **opts, catch_failures: true, manifest_file_location: manifest_file_location)
-      apply_manifest(nil, **opts, catch_changes: true, manifest_file_location: manifest_file_location)
-    end
+    manifest_file_location = create_manifest_file(manifest)
+    apply_manifest(nil, **opts, catch_failures: true, manifest_file_location: manifest_file_location)
+    apply_manifest(nil, **opts, catch_changes: true, manifest_file_location: manifest_file_location)
   end
 
   # Applies a manifest. returning the result of that apply. Mimics the apply_manifest from beaker
@@ -49,99 +46,85 @@ 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 apply.
   def apply_manifest(manifest, opts = {})
-    Honeycomb.start_span(name: 'litmus.apply_manifest') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.manifest', manifest)
-      span.add_field('litmus.opts', opts)
-
-      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
-      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
+    target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
+    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
 
-      manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
-      inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
+    manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
+    inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
 
-      target_option = opts['targets'] || opts[:targets]
-      if target_option.nil?
-        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      else
-        target_node_name = search_for_target(target_option, inventory_hash)
-      end
+    target_option = opts['targets'] || opts[:targets]
+    if target_option.nil?
+      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+    else
+      target_node_name = search_for_target(target_option, inventory_hash)
+    end
 
-      add_node_fields_to_span(span, target_node_name, inventory_hash)
-
-      # Forcibly set the locale of the command
-      locale = if os[:family] == 'windows'
-                 ''
-               else
-                 'LC_ALL=en_US.UTF-8 '
-               end
-      command_to_run = "#{locale}#{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.target_node_name', target_node_name)
-
-      if os[:family] == 'windows'
-        # IAC-1365 - Workaround for BOLT-1535 and bolt issue #1650
-        command_to_run = "try { #{command_to_run}; exit $LASTEXITCODE } catch { write-error $_ ; exit 1 }"
-        span.add_field('litmus.command_to_run', command_to_run)
-        bolt_result = Tempfile.open(['temp', '.ps1']) do |script|
-          script.write(command_to_run)
-          script.close
-          run_script(script.path, target_node_name, [], options: {}, config: nil, inventory: inventory_hash)
-        end
-      else
-        span.add_field('litmus.command_to_run', command_to_run)
-        bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
-      end
-      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)
+    # Forcibly set the locale of the command
+    locale = if os[:family] == 'windows'
+               ''
+             else
+               'LC_ALL=en_US.UTF-8 '
+             end
+    command_to_run = "#{locale}#{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
+
+    if os[:family] == 'windows'
+      # IAC-1365 - Workaround for BOLT-1535 and bolt issue #1650
+      command_to_run = "try { #{command_to_run}; exit $LASTEXITCODE } catch { write-error $_ ; exit 1 }"
+      bolt_result = Tempfile.open(['temp', '.ps1']) do |script|
+        script.write(command_to_run)
+        script.close
+        run_script(script.path, target_node_name, [], options: {}, config: nil, inventory: inventory_hash)
       end
+    else
+      bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+    end
+    result = OpenStruct.new(exit_code: bolt_result.first['value']['exit_code'],
+                            stdout: bolt_result.first['value']['stdout'],
+                            stderr: bolt_result.first['value']['stderr'])
+
+    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?
+    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
+    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
 
   # Creates a manifest file locally in a temp location, if its a remote target copy it to there.
@@ -149,36 +132,27 @@ module PuppetLitmus::PuppetHelpers
   # @param manifest [String] puppet manifest code.
   # @return [String] The path to the location of the manifest.
   def create_manifest_file(manifest, opts = {})
-    Honeycomb.start_span(name: 'litmus.create_manifest_file') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.manifest', manifest)
-
-      require 'tmpdir'
-      target_node_name = ENV.fetch('TARGET_HOST', nil)
-      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
-        target_option = opts['targets'] || opts[:targets]
-        target_node_name = search_for_target(target_option, inventory_hash) unless target_option.nil?
-        add_node_fields_to_span(span, target_node_name, inventory_hash)
-
-        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)
+    require 'tmpdir'
+    target_node_name = ENV.fetch('TARGET_HOST', nil)
+    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
+      target_option = opts['targets'] || opts[:targets]
+      target_node_name = search_for_target(target_option, inventory_hash) unless target_option.nil?
 
-      manifest_file_location
+      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)
+      raise bolt_result.first['value'].to_s unless bolt_result.first['status'] == 'success'
     end
+
+    manifest_file_location
   end
 
   # Writes a string variable to a file on a target node at a specified path.
@@ -187,35 +161,27 @@ module PuppetLitmus::PuppetHelpers
   # @param destination [String] The path on the target node to write the file.
   # @return [Bool] Success. The file was succesfully writtne on the target.
   def write_file(content, destination, opts = {})
-    Honeycomb.start_span(name: 'litmus.write_file') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.destination', destination)
-
-      require 'tmpdir'
-      inventory_hash = inventory_hash_from_inventory_file
-      target_node_name = ENV.fetch('TARGET_HOST', nil)
-      target_option = opts['targets'] || opts[:targets]
-      target_node_name = search_for_target(target_option, inventory_hash) unless target_option.nil?
-
-      Tempfile.create('litmus') do |tmp_file|
-        tmp_file.write(content)
-        tmp_file.flush
-        if target_node_name.nil? || target_node_name == 'localhost'
-          require 'fileutils'
-          # no need to transfer
-          FileUtils.cp(tmp_file.path, destination)
-        else
-          # transfer to TARGET_HOST
-          add_node_fields_to_span(span, target_node_name, inventory_hash)
-
-          bolt_result = upload_file(tmp_file.path, destination, target_node_name, options: {}, config: nil, inventory: inventory_hash)
-          span.add_field('litmus.bolt_result.file_upload', bolt_result)
-          raise bolt_result.first['value'].to_s unless bolt_result.first['status'] == 'success'
-        end
+    require 'tmpdir'
+    inventory_hash = inventory_hash_from_inventory_file
+    target_node_name = ENV.fetch('TARGET_HOST', nil)
+    target_option = opts['targets'] || opts[:targets]
+    target_node_name = search_for_target(target_option, inventory_hash) unless target_option.nil?
+
+    Tempfile.create('litmus') do |tmp_file|
+      tmp_file.write(content)
+      tmp_file.flush
+      if target_node_name.nil? || target_node_name == 'localhost'
+        require 'fileutils'
+        # no need to transfer
+        FileUtils.cp(tmp_file.path, destination)
+      else
+        # transfer to TARGET_HOST
+        bolt_result = upload_file(tmp_file.path, destination, target_node_name, options: {}, config: nil, inventory: inventory_hash)
+        raise bolt_result.first['value'].to_s unless bolt_result.first['status'] == 'success'
       end
-
-      true
     end
+
+    true
   end
 
   # Runs a command against the target system
@@ -225,36 +191,26 @@ 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.run_shell') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.command_to_run', command_to_run)
-      span.add_field('litmus.opts', opts)
-
-      inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
+    inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
 
-      target_option = opts['targets'] || opts[:targets]
-      if target_option.nil?
-        target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
-        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      else
-        target_node_name = search_for_target(target_option, inventory_hash)
-      end
-
-      add_node_fields_to_span(span, target_node_name, inventory_hash)
+    target_option = opts['targets'] || opts[:targets]
+    if target_option.nil?
+      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
+      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+    else
+      target_node_name = search_for_target(target_option, inventory_hash)
+    end
 
-      bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
-      span.add_field('litmus.bolt_result', bolt_result)
+    bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
 
-      raise "shell failed\n`#{command_to_run}`\n======\n#{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}" if bolt_result.first['value']['exit_code'] != 0 && opts[:expect_failures] != true
 
-      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?
-      result
-    end
+    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'])
+    yield result if block_given?
+    result
   end
 
   # Copies file to the target, using its respective transport
@@ -265,51 +221,36 @@ 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.bolt_upload_file') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.source', source)
-      span.add_field('litmus.destination', destination)
-      span.add_field('litmus.opts', opts)
-      span.add_field('litmus.options', options)
-
-      inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-      target_option = opts['targets'] || opts[:targets]
-      if target_option.nil?
-        target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
-        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      else
-        target_node_name = search_for_target(target_option, inventory_hash)
-      end
-
-      add_node_fields_to_span(span, target_node_name, inventory_hash)
-
-      bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
-      span.add_field('litmus.bolt_result', bolt_result)
+    inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
+    target_option = opts['targets'] || opts[:targets]
+    if target_option.nil?
+      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
+      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+    else
+      target_node_name = search_for_target(target_option, inventory_hash)
+    end
 
-      result_obj = {
-        exit_code: 0,
-        stdout: bolt_result.first['value']['_output'],
-        stderr: nil,
-        result: bolt_result.first['value']
-      }
+    bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
 
-      if bolt_result.first['status'] != 'success'
-        if opts[:expect_failures] != true
-          span.add_field('litmus_uploadfilefailure', bolt_result)
-          raise "upload file failed\n======\n#{bolt_result}"
-        end
+    result_obj = {
+      exit_code: 0,
+      stdout: bolt_result.first['value']['_output'],
+      stderr: nil,
+      result: bolt_result.first['value']
+    }
 
-        result_obj[:exit_code] = 255
-        result_obj[:stderr]    = bolt_result.first['value']['_error']['msg']
-      end
+    if bolt_result.first['status'] != 'success'
+      raise "upload file failed\n======\n#{bolt_result}" if opts[:expect_failures] != true
 
-      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?
-      result
+      result_obj[:exit_code] = 255
+      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])
+    yield result if block_given?
+    result
   end
 
   # Runs a task against the target system.
@@ -321,69 +262,56 @@ module PuppetLitmus::PuppetHelpers
   #  :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.
   def run_bolt_task(task_name, params = {}, opts = {})
-    Honeycomb.start_span(name: 'litmus.run_task') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      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.fetch('TARGET_HOST', nil)
-      inventory_hash = if !opts[:inventory_file].nil? && File.exist?(opts[:inventory_file])
-                         inventory_hash_from_inventory_file(opts[:inventory_file])
-                       elsif File.exist?('spec/fixtures/litmus_inventory.yaml')
-                         inventory_hash_from_inventory_file('spec/fixtures/litmus_inventory.yaml')
-                       else
-                         localhost_inventory_hash
-                       end
-
-      target_option = opts['targets'] || opts[:targets]
-      if target_option.nil?
-        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      else
-        target_node_name = search_for_target(target_option, inventory_hash)
-      end
-
-      add_node_fields_to_span(span, target_node_name, inventory_hash)
-
-      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: bolt_result.first['value']
-      }
-
-      if bolt_result.first['status'] == 'success'
-        # stdout returns unstructured data if structured data is not available
-        result_obj[:stdout] = if bolt_result.first['value']['_output'].nil?
-                                bolt_result.first['value'].to_s
-                              else
-                                bolt_result.first['value']['_output']
-                              end
-
-      else
-        if opts[:expect_failures] != true
-          span.add_field('litmus_runtaskfailure', bolt_result)
-          raise "task failed\n`#{task_name}`\n======\n#{bolt_result}"
-        end
-
-        result_obj[:exit_code] = if bolt_result.first['value']['_error']['details'].nil?
-                                   255
-                                 else
-                                   bolt_result.first['value']['_error']['details'].fetch('exitcode', 255)
-                                 end
-        result_obj[:stderr]    = bolt_result.first['value']['_error']['msg']
-      end
+    config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
+    target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
+    inventory_hash = if !opts[:inventory_file].nil? && File.exist?(opts[:inventory_file])
+                       inventory_hash_from_inventory_file(opts[:inventory_file])
+                     elsif File.exist?('spec/fixtures/litmus_inventory.yaml')
+                       inventory_hash_from_inventory_file('spec/fixtures/litmus_inventory.yaml')
+                     else
+                       localhost_inventory_hash
+                     end
+
+    target_option = opts['targets'] || opts[:targets]
+    if target_option.nil?
+      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+    else
+      target_node_name = search_for_target(target_option, inventory_hash)
+    end
 
-      result = OpenStruct.new(exit_code: result_obj[:exit_code],
-                              stdout: result_obj[:stdout],
-                              stderr: result_obj[:stderr],
-                              result: result_obj[:result])
-      yield result if block_given?
-      span.add_field('litmus.result', result.to_h)
-      result
+    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: bolt_result.first['value']
+    }
+
+    if bolt_result.first['status'] == 'success'
+      # stdout returns unstructured data if structured data is not available
+      result_obj[:stdout] = if bolt_result.first['value']['_output'].nil?
+                              bolt_result.first['value'].to_s
+                            else
+                              bolt_result.first['value']['_output']
+                            end
+
+    else
+      raise "task failed\n`#{task_name}`\n======\n#{bolt_result}" if opts[:expect_failures] != true
+
+      result_obj[:exit_code] = if bolt_result.first['value']['_error']['details'].nil?
+                                 255
+                               else
+                                 bolt_result.first['value']['_error']['details'].fetch('exitcode', 255)
+                               end
+      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],
+                            result: result_obj[:result])
+    yield result if block_given?
+    result
   end
 
   # Runs a script against the target system.
@@ -394,37 +322,24 @@ 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.bolt_run_script') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      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.fetch('TARGET_HOST', nil)
-      inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-      target_option = opts['targets'] || opts[:targets]
-      if target_option.nil?
-        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      else
-        target_node_name = search_for_target(target_option, inventory_hash)
-      end
+    target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV.fetch('TARGET_HOST', nil)
+    inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
+    target_option = opts['targets'] || opts[:targets]
+    if target_option.nil?
+      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+    else
+      target_node_name = search_for_target(target_option, inventory_hash)
+    end
 
-      add_node_fields_to_span(span, target_node_name, inventory_hash)
+    bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
 
-      bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
+    raise "script run failed\n`#{script}`\n======\n#{bolt_result}" if bolt_result.first['value']['exit_code'] != 0 && opts[:expect_failures] != true
 
-      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: 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.result', result.to_h)
-      result
-    end
+    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?
+    result
   end
 
   # Determines if the current execution is targeting localhost or not

data/lib/puppet_litmus/rake_helper.rb

@@ -1,53 +1,7 @@
 # frozen_string_literal: true
 
 require 'bolt_spec/run'
-require 'honeycomb-beeline'
 require 'puppet_litmus/version'
-Honeycomb.configure do |config|
-  # override client if no configuration is provided, so that the pesky libhoney warning about lack of configuration is not shown
-  config.client = Libhoney::NullClient.new unless ENV['HONEYCOMB_WRITEKEY'] && ENV['HONEYCOMB_DATASET']
-end
-process_span = Honeycomb.start_span(name: "litmus: #{([$PROGRAM_NAME] + ($ARGV || [])).join(' ')}", serialized_trace: ENV.fetch('HONEYCOMB_TRACE', nil))
-ENV['HONEYCOMB_TRACE'] = process_span.to_trace_header
-Honeycomb.add_field_to_trace('litmus.pid', Process.pid)
-if defined? PuppetLitmus::VERSION
-  Honeycomb.add_field_to_trace('litmus.version', PuppetLitmus::VERSION)
-else
-  Honeycomb.add_field_to_trace('litmus.version', 'undefined')
-end
-if ENV['CI'] == 'true' && ENV['TRAVIS'] == 'true'
-  Honeycomb.add_field_to_trace('module_name', ENV.fetch('TRAVIS_REPO_SLUG', nil))
-  Honeycomb.add_field_to_trace('ci.provider', 'travis')
-  Honeycomb.add_field_to_trace('ci.build_id', ENV.fetch('TRAVIS_BUILD_ID', nil))
-  Honeycomb.add_field_to_trace('ci.build_url', ENV.fetch('TRAVIS_BUILD_WEB_URL', nil))
-  Honeycomb.add_field_to_trace('ci.job_url', ENV.fetch('TRAVIS_JOB_WEB_URL', nil))
-  Honeycomb.add_field_to_trace('ci.commit_message', ENV.fetch('TRAVIS_COMMIT_MESSAGE', nil))
-  Honeycomb.add_field_to_trace('ci.sha', ENV['TRAVIS_PULL_REQUEST_SHA'] || ENV.fetch('TRAVIS_COMMIT', nil))
-elsif ENV['CI'] == 'True' && ENV['APPVEYOR'] == 'True'
-  Honeycomb.add_field_to_trace('module_name', ENV.fetch('APPVEYOR_PROJECT_SLUG', nil))
-  Honeycomb.add_field_to_trace('ci.provider', 'appveyor')
-  Honeycomb.add_field_to_trace('ci.build_id', ENV.fetch('APPVEYOR_BUILD_ID', nil))
-  Honeycomb.add_field_to_trace('ci.build_url', "https://ci.appveyor.com/project/#{ENV.fetch('APPVEYOR_REPO_NAME', nil)}/builds/#{ENV.fetch('APPVEYOR_BUILD_ID', nil)}")
-  Honeycomb.add_field_to_trace('ci.job_url', "https://ci.appveyor.com/project/#{ENV.fetch('APPVEYOR_REPO_NAME', nil)}/build/job/#{ENV.fetch('APPVEYOR_JOB_ID', nil)}")
-  Honeycomb.add_field_to_trace('ci.commit_message', ENV.fetch('APPVEYOR_REPO_COMMIT_MESSAGE', nil))
-  Honeycomb.add_field_to_trace('ci.sha', ENV['APPVEYOR_PULL_REQUEST_HEAD_COMMIT'] || ENV.fetch('APPVEYOR_REPO_COMMIT', nil))
-elsif ENV['GITHUB_ACTIONS'] == 'true'
-  Honeycomb.add_field_to_trace('module_name', ENV.fetch('GITHUB_REPOSITORY', nil))
-  Honeycomb.add_field_to_trace('ci.provider', 'github')
-  Honeycomb.add_field_to_trace('ci.build_id', ENV.fetch('GITHUB_RUN_ID', nil))
-  Honeycomb.add_field_to_trace('ci.build_url', "https://github.com/#{ENV.fetch('GITHUB_REPOSITORY', nil)}/actions/runs/#{ENV.fetch('GITHUB_RUN_ID', nil)}")
-  Honeycomb.add_field_to_trace('ci.sha', ENV.fetch('GITHUB_SHA', nil))
-end
-at_exit do
-  if $ERROR_INFO.is_a?(SystemExit)
-    process_span.add_field('process.exit_code', $ERROR_INFO.status)
-  elsif $ERROR_INFO
-    process_span.add_field('process.exit_code', $ERROR_INFO.class.name)
-  else
-    process_span.add_field('process.exit_code', 'unknown')
-  end
-  process_span.send
-end
 
 # helper methods for the litmus rake tasks
 module PuppetLitmus::RakeHelper
@@ -100,18 +54,13 @@ module PuppetLitmus::RakeHelper
   # @param command [String] command to execute.
   # @return [Object] the standard out stream.
   def run_local_command(command)
-    Honeycomb.start_span(name: 'litmus.run_local_command') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.command', command)
+    require 'open3'
+    stdout, stderr, status = Open3.capture3(command)
+    error_message = "Attempted to run\ncommand:'#{command}'\nstdout:#{stdout}\nstderr:#{stderr}"
 
-      require 'open3'
-      stdout, stderr, status = Open3.capture3(command)
-      error_message = "Attempted to run\ncommand:'#{command}'\nstdout:#{stdout}\nstderr:#{stderr}"
+    raise error_message unless status.to_i.zero?
 
-      raise error_message unless status.to_i.zero?
-
-      stdout
-    end
+    stdout
   end
 
   def provision(provisioner, platform, inventory_vars)
@@ -122,24 +71,11 @@ module PuppetLitmus::RakeHelper
     params = { 'action' => 'provision', 'platform' => platform, 'inventory' => Dir.pwd }
     params['vars'] = inventory_vars unless inventory_vars.nil?
 
-    Honeycomb.add_field_to_trace('litmus.provisioner', provisioner)
-    Honeycomb.start_span(name: 'litmus.provision') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.platform', platform)
-
-      task_name = provisioner_task(provisioner)
-      span.add_field('litmus.task_name', task_name)
-      span.add_field('litmus.params', params)
-      span.add_field('litmus.config', DEFAULT_CONFIG_DATA)
-
-      bolt_result = run_task(task_name, 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
-      span.add_field('litmus.result', bolt_result)
-      span.add_field('litmus.node_name', bolt_result&.first&.dig('value', 'node_name'))
+    task_name = provisioner_task(provisioner)
+    bolt_result = run_task(task_name, 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+    raise_bolt_errors(bolt_result, "provisioning of #{platform} failed.")
 
-      raise_bolt_errors(bolt_result, "provisioning of #{platform} failed.")
-
-      bolt_result
-    end
+    bolt_result
   end
 
   def provision_list(provision_hash, key)
@@ -149,7 +85,6 @@ module PuppetLitmus::RakeHelper
     provision_hash[key]['params']&.each { |k, value| ENV[k.upcase] = value.to_s }
     results = []
 
-    Honeycomb.current_span.add_field('litmus.images', provision_hash[key]['images'])
     provision_hash[key]['images'].each do |image|
       results << provision(provisioner, image, inventory_vars)
     end
@@ -157,73 +92,57 @@ module PuppetLitmus::RakeHelper
   end
 
   def tear_down_nodes(targets, inventory_hash)
-    Honeycomb.start_span(name: 'litmus.tear_down_nodes') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.targets', targets)
-
-      include ::BoltSpec::Run
-      config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
-      raise "the provision module was not found in #{config_data['modulepath']}, please amend the .fixtures.yml file" unless File.directory?(File.join(config_data['modulepath'], 'provision'))
-
-      results = {}
-      targets.each do |node_name|
-        next if node_name == 'litmus_localhost'
-
-        result = tear_down(node_name, inventory_hash)
-        # Some provisioners tear_down targets that were created as a batch job.
-        # These provisioners should return the list of additional targets
-        # removed so that we do not attempt to process them.
-        if result != [] && result[0]['value'].key?('removed')
-          removed_targets = result[0]['value']['removed']
-          result[0]['value'].delete('removed')
-          removed_targets.each do |removed_target|
-            targets.delete(removed_target)
-            results[removed_target] = result
-          end
+    include ::BoltSpec::Run
+    config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
+    raise "the provision module was not found in #{config_data['modulepath']}, please amend the .fixtures.yml file" unless File.directory?(File.join(config_data['modulepath'], 'provision'))
+
+    results = {}
+    targets.each do |node_name|
+      next if node_name == 'litmus_localhost'
+
+      result = tear_down(node_name, inventory_hash)
+      # Some provisioners tear_down targets that were created as a batch job.
+      # These provisioners should return the list of additional targets
+      # removed so that we do not attempt to process them.
+      if result != [] && result[0]['value'].key?('removed')
+        removed_targets = result[0]['value']['removed']
+        result[0]['value'].delete('removed')
+        removed_targets.each do |removed_target|
+          targets.delete(removed_target)
+          results[removed_target] = result
         end
-
-        results[node_name] = result unless result == []
       end
-      results
+
+      results[node_name] = result unless result == []
     end
+    results
   end
 
   def tear_down(node_name, inventory_hash)
-    Honeycomb.start_span(name: 'litmus.tear_down') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      # how do we know what provisioner to use
-
-      span.add_field('litmus.node_name', node_name)
-      add_platform_field(inventory_hash, node_name)
-
-      params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
-      node_facts = facts_from_node(inventory_hash, node_name)
-      bolt_result = run_task(provisioner_task(node_facts['provisioner']), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
-      raise_bolt_errors(bolt_result, "tear_down of #{node_name} failed.")
-      bolt_result
-    end
+    # how do we know what provisioner to use
+    add_platform_field(inventory_hash, node_name)
+
+    params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
+    node_facts = facts_from_node(inventory_hash, node_name)
+    bolt_result = run_task(provisioner_task(node_facts['provisioner']), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+    raise_bolt_errors(bolt_result, "tear_down of #{node_name} failed.")
+    bolt_result
   end
 
   def install_agent(collection, targets, inventory_hash)
-    Honeycomb.start_span(name: 'litmus.install_agent') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.collection', collection)
-      span.add_field('litmus.targets', targets)
-
-      include ::BoltSpec::Run
-      params = if collection.nil?
-                 {}
-               else
-                 { 'collection' => collection }
-               end
-      raise "puppet_agent was not found in #{DEFAULT_CONFIG_DATA['modulepath']}, please amend the .fixtures.yml file" \
-       unless File.directory?(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent'))
-
-      # using boltspec, when the runner is called it changes the inventory_hash dropping the version field. The clone works around this
-      bolt_result = run_task('puppet_agent::install', targets, params, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash.clone)
-      raise_bolt_errors(bolt_result, 'Installation of agent failed.')
-      bolt_result
-    end
+    include ::BoltSpec::Run
+    params = if collection.nil?
+               {}
+             else
+               { 'collection' => collection }
+             end
+    raise "puppet_agent was not found in #{DEFAULT_CONFIG_DATA['modulepath']}, please amend the .fixtures.yml file" \
+      unless File.directory?(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent'))
+
+    # using boltspec, when the runner is called it changes the inventory_hash dropping the version field. The clone works around this
+    bolt_result = run_task('puppet_agent::install', targets, params, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash.clone)
+    raise_bolt_errors(bolt_result, 'Installation of agent failed.')
+    bolt_result
   end
 
   def configure_path(inventory_hash)
@@ -297,32 +216,24 @@ module PuppetLitmus::RakeHelper
   # @param ignore_dependencies [Boolean] flag used to ignore module dependencies defaults to false.
   # @return a bolt result
   def install_module(inventory_hash, target_node_name, module_tar, module_repository = nil, ignore_dependencies = false) # rubocop:disable Style/OptionalBooleanParameter
-    Honeycomb.start_span(name: 'install_module') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      span.add_field('litmus.target_node_name', target_node_name)
-      span.add_field('litmus.module_tar', module_tar)
-
-      # make sure the module to install is not installed
-      # otherwise `puppet module install` might silently skip it
-      module_name = File.basename(module_tar, '.tar.gz').split('-', 3)[0..1].join('-')
-      uninstall_module(inventory_hash.clone, target_node_name, module_name, force: true)
-
-      include ::BoltSpec::Run
-
-      target_nodes = find_targets(inventory_hash, target_node_name)
-      span.add_field('litmus.target_nodes', target_nodes)
-      bolt_result = upload_file(module_tar, File.basename(module_tar), target_nodes, options: {}, config: nil, inventory: inventory_hash.clone)
-      raise_bolt_errors(bolt_result, 'Failed to upload module.')
-
-      module_repository_opts = "--module_repository '#{module_repository}'" unless module_repository.nil?
-      install_module_command = "puppet module install #{module_repository_opts} #{File.basename(module_tar)}"
-      install_module_command += ' --ignore-dependencies --force' if ignore_dependencies.to_s.casecmp('true').zero?
-      span.add_field('litmus.install_module_command', install_module_command)
-
-      bolt_result = run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash.clone)
-      raise_bolt_errors(bolt_result, "Installation of package #{File.basename(module_tar)} failed.")
-      bolt_result
-    end
+    # make sure the module to install is not installed
+    # otherwise `puppet module install` might silently skip it
+    module_name = File.basename(module_tar, '.tar.gz').split('-', 3)[0..1].join('-')
+    uninstall_module(inventory_hash.clone, target_node_name, module_name, force: true)
+
+    include ::BoltSpec::Run
+
+    target_nodes = find_targets(inventory_hash, target_node_name)
+    bolt_result = upload_file(module_tar, File.basename(module_tar), target_nodes, options: {}, config: nil, inventory: inventory_hash.clone)
+    raise_bolt_errors(bolt_result, 'Failed to upload module.')
+
+    module_repository_opts = "--module_repository '#{module_repository}'" unless module_repository.nil?
+    install_module_command = "puppet module install #{module_repository_opts} #{File.basename(module_tar)}"
+    install_module_command += ' --ignore-dependencies --force' if ignore_dependencies.to_s.casecmp('true').zero?
+
+    bolt_result = run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash.clone)
+    raise_bolt_errors(bolt_result, "Installation of package #{File.basename(module_tar)} failed.")
+    bolt_result
   end
 
   def metadata_module_name
@@ -353,33 +264,23 @@ module PuppetLitmus::RakeHelper
   end
 
   def check_connectivity?(inventory_hash, target_node_name)
-    Honeycomb.start_span(name: 'litmus.check_connectivity') do |span|
-      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
-      # if we're only checking connectivity for a single node
-      if target_node_name
-        span.add_field('litmus.target_node_name', target_node_name)
-        add_platform_field(inventory_hash, target_node_name)
-      end
+    # if we're only checking connectivity for a single node
+    add_platform_field(inventory_hash, target_node_name) if target_node_name
 
-      include ::BoltSpec::Run
-      target_nodes = find_targets(inventory_hash, target_node_name)
-      puts "Checking connectivity for #{target_nodes.inspect}"
-      span.add_field('litmus.target_nodes', target_nodes)
-
-      results = run_command('cd .', target_nodes, config: nil, inventory: inventory_hash)
-      span.add_field('litmus.bolt_result', results)
-      failed = []
-      results.reject { |r| r['status'] == 'success' }.each do |result|
-        puts "Failure connecting to #{result['target']}:\n#{result.inspect}"
-        failed.push(result['target'])
-      end
-      span.add_field('litmus.connectivity_success', results.select { |r| r['status'] == 'success' })
-      span.add_field('litmus.connectivity_failure', results.reject { |r| r['status'] == 'success' })
-      raise "Connectivity has failed on: #{failed}" unless failed.empty?
+    include ::BoltSpec::Run
+    target_nodes = find_targets(inventory_hash, target_node_name)
+    puts "Checking connectivity for #{target_nodes.inspect}"
 
-      puts 'Connectivity check PASSED.'
-      true
+    results = run_command('cd .', target_nodes, config: nil, inventory: inventory_hash)
+    failed = []
+    results.reject { |r| r['status'] == 'success' }.each do |result|
+      puts "Failure connecting to #{result['target']}:\n#{result.inspect}"
+      failed.push(result['target'])
     end
+    raise "Connectivity has failed on: #{failed}" unless failed.empty?
+
+    puts 'Connectivity check PASSED.'
+    true
   end
 
   def provisioner_task(provisioner)

data/lib/puppet_litmus/rake_tasks.rb

@@ -90,11 +90,8 @@ namespace :litmus do
                        results.first['value']['target_names'] || [] # provision_service multi-node provisioning
                      end
       target_names.each do |target|
-        Honeycomb.start_span(name: 'litmus.provision.check_connectivity') do |span|
-          span.add_field('target_name', target)
-          with_retries do
-            check_connectivity?(inventory_hash_from_inventory_file, target)
-          end
+        with_retries do
+          check_connectivity?(inventory_hash_from_inventory_file, target)
         end
       end
     ensure
@@ -355,7 +352,7 @@ namespace :litmus do
       payloads = []
       # Generate list of targets to provision
       targets.each do |target|
-        test = "bundle exec rspec ./spec/acceptance #{tag_value} --format progress --require rspec_honeycomb_formatter --format RSpecHoneycombFormatter"
+        test = "bundle exec rspec ./spec/acceptance #{tag_value} --format progress"
         title = "#{target}, #{facts_from_node(inventory_hash, target)['platform']}"
         options = {
           env: {
@@ -386,7 +383,6 @@ namespace :litmus do
           at_exit { exit! }
 
           env = options[:env].nil? ? {} : options[:env]
-          env['HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
           stdout, stderr, status = Open3.capture3(env, test)
           ["\n================\n#{title}\n", stdout, stderr, status]
         end
@@ -404,7 +400,6 @@ namespace :litmus do
         spinners = TTY::Spinner::Multi.new("[:spinner] Running against #{targets.size} targets.")
         payloads.each do |title, test, options|
           env = options[:env].nil? ? {} : options[:env]
-          env['HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
           spinners.register("[:spinner] #{title}") do |sp|
             stdout, stderr, status = Open3.capture3(env, test)
             if status.to_i.zero?

data/lib/puppet_litmus/version.rb

@@ -2,5 +2,5 @@
 
 # version of this gem
 module PuppetLitmus
-  VERSION = '1.0.2'
+  VERSION = '1.0.3'
 end

data/spec/lib/puppet_litmus/puppet_helpers_spec.rb

@@ -41,7 +41,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'passes the --hiera_config flag if the :hiera_config opt is specified' do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
         expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         apply_manifest(manifest, hiera_config: '/hiera.yaml')
@@ -61,7 +60,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'uses detailed-exitcodes with expect_failures' do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
         expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { apply_manifest(manifest, expect_failures: true) }.to raise_error(RuntimeError)
@@ -70,7 +68,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'uses detailed-exitcodes with catch_failures' do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
         expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         apply_manifest(manifest, catch_failures: true)
@@ -79,7 +76,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'uses detailed-exitcodes with expect_changes' do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
         expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { apply_manifest(manifest, expect_changes: true) }.to raise_error(RuntimeError)
@@ -88,7 +84,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'uses detailed-exitcodes with catch_changes' do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
         expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         apply_manifest(manifest, catch_changes: true)
@@ -114,7 +109,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_command).with(command_to_run, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { run_shell(command_to_run) }.not_to raise_error
       end
@@ -126,7 +120,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_command).with(command_to_run, 'some.host', config: nil, inventory: inventory_hash).and_return(result)
         expect { run_shell(command_to_run) }.not_to raise_error
       end
@@ -152,7 +145,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_success)
         expect { bolt_upload_file(local, remote) }.not_to raise_error
       end
@@ -162,7 +154,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).not_to receive(:inventory_hash_from_inventory_file)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:upload_file).with(local, remote, 'litmus_localhost', options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result_success)
         expect { bolt_upload_file(local, remote) }.not_to raise_error
       end
@@ -174,7 +165,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
         expect { bolt_upload_file(local, remote) }.to raise_error(RuntimeError, /upload file failed/)
       end
@@ -184,7 +174,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
         method_result = bolt_upload_file(local, remote, expect_failures: true)
         expect(method_result.exit_code).to be(255)
@@ -207,7 +196,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).not_to receive(:inventory_hash_from_inventory_file)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_script).with(script, 'litmus_localhost', [], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { bolt_run_script(script) }.not_to raise_error
       end
@@ -219,7 +207,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: inventory_hash).and_return(result)
         expect { bolt_run_script(script) }.not_to raise_error
       end
@@ -231,7 +218,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(false)
         expect(self).not_to receive(:inventory_hash_from_inventory_file)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_script).with(script, 'litmus_localhost', ['doot'], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { bolt_run_script(script, arguments: ['doot']) }.not_to raise_error
       end
@@ -259,7 +245,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
         expect { run_bolt_task(task_name, params, opts: {}) }.not_to raise_error
       end
@@ -269,7 +254,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('jim.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
         expect { run_bolt_task(task_name, params, inventory_file: 'jim.yaml') }.not_to raise_error
       end
@@ -279,7 +263,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
         method_result = run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('SUCCESS!')
@@ -290,7 +273,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_structured_task_success)
         method_result = run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('{"key1"=>"foo", "key2"=>"bar"}')
@@ -305,7 +287,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
         expect { run_bolt_task(task_name, params, opts: {}) }.to raise_error(RuntimeError, /task failed/)
       end
@@ -315,7 +296,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
         expect(File).to receive(:exist?).with('spec/fixtures/litmus_inventory.yaml').and_return(true)
         expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(self).to receive(:target_in_inventory?).and_return(true)
-        expect(self).to receive(:target_in_inventory?).and_return(true)
         expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
         method_result = run_bolt_task(task_name, params, expect_failures: true)
         expect(method_result.exit_code).to be(123)

data/spec/lib/puppet_litmus/rake_tasks_spec.rb

@@ -78,7 +78,7 @@ describe 'litmus rake tasks' do
       allow_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:inventory_hash_from_inventory_file).with(any_args).and_return({})
       allow_any_instance_of(PuppetLitmus::RakeHelper).to receive(:check_connectivity?).with(any_args).and_return(true)
 
-      expect { Rake::Task['litmus:provision'].invoke('docker', 'centos:7') }.to output(expected_output).to_stdout
+      expect { Rake::Task['litmus:provision'].invoke('docker', 'centos:7') }.to output(/#{expected_output}/).to_stdout
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet_litmus
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-25 00:00:00.000000000 Z
+date: 2023-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bolt
@@ -44,20 +44,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: honeycomb-beeline
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -114,20 +100,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec_honeycomb_formatter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: tty-spinner
   requirement: !ruby/object:Gem::Requirement