cem_acpt 0.11.0 → 0.11.2

data/lib/cem_acpt/image_builder/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module ImageBuilder
+    # Raised when an OS-specific image-builder Terraform template
+    # (e.g. `lib/terraform/image/<platform>/windows/main.tf`) is missing
+    # but the user has configured at least one image for that OS. The
+    # builder catches this before invoking `terraform init` so users get
+    # an actionable message instead of Terraform's "no configuration
+    # files" output.
+    class MissingTemplateError < StandardError
+      attr_reader :os_str, :template_path
+
+      def initialize(os_str, template_path)
+        @os_str = os_str
+        @template_path = template_path
+        super(
+          "No #{os_str} image-builder Terraform template ships with this version of cem_acpt " \
+          "(expected #{template_path}). Either upgrade cem_acpt or pass --no-#{os_str}."
+        )
+      end
+    end
+  end
+end

data/lib/cem_acpt/image_builder/provision_commands.rb

@@ -19,7 +19,11 @@ module CemAcpt
 
         def provision_commands
           commands_from_config = @config.get("images.#{@image_name}.provision_commands") || []
-          (default_provision_commands + commands_from_config).compact
+          if @config.get("images.#{@image_name}.skip_default_provision_commands")
+            commands_from_config.compact
+          else
+            (default_provision_commands + commands_from_config).compact
+          end
         end
         alias to_a provision_commands
 
@@ -83,7 +87,11 @@ module CemAcpt
 
         def provision_commands
           commands_from_config = @config.get("images.#{@image_name}.provision_commands") || []
-          (default_provision_commands + commands_from_config).compact
+          if @config.get("images.#{@image_name}.skip_default_provision_commands")
+            commands_from_config.compact
+          else
+            (default_provision_commands + commands_from_config).compact
+          end
         end
         alias to_a provision_commands
       end
@@ -103,7 +111,11 @@ module CemAcpt
 
         def provision_commands
           commands_from_config = @config.get("images.#{@image_name}.provision_commands") || []
-          (default_provision_commands + commands_from_config).compact
+          if @config.get("images.#{@image_name}.skip_default_provision_commands")
+            commands_from_config.compact
+          else
+            (default_provision_commands + commands_from_config).compact
+          end
         end
         alias to_a provision_commands
 

data/lib/cem_acpt/image_builder.rb

@@ -7,6 +7,7 @@ require_relative 'platform'
 require_relative 'utils'
 require_relative 'version'
 require_relative 'provision/terraform/terraform_cmd'
+require_relative 'image_builder/errors'
 require_relative 'image_builder/exec'
 require_relative 'image_builder/provision_commands'
 
@@ -35,6 +36,10 @@ module CemAcpt
     class TerraformBuilder
       DEFAULT_PLAN_NAME = 'testplan.tfplan'
       DEFAULT_VARS_FILE = 'imagevars.json'
+      # GCE image names must match RFC 1035 label rules: 1-63 chars, lowercase
+      # alphanumeric and dashes, no trailing dash. See
+      # https://cloud.google.com/compute/docs/reference/rest/v1/images.
+      GCE_IMAGE_NAME_MAX = 63
       include CemAcpt::Logging
 
       attr_reader :exit_code, :duration
@@ -64,6 +69,7 @@ module CemAcpt
         if image_types.empty?
           raise 'No images to build. Ensure the images config is populated and that --filter (if used) matches at least one image.'
         end
+        image_types.each { |_, os_str| assert_template_present!(os_str) }
         return dry_run(image_types) if @config.get('dry_run')
 
         @working_dir = new_working_dir
@@ -80,7 +86,7 @@ module CemAcpt
             output.each do |instance_name, data|
               unless @config.get('no_destroy_nodes')
                 logger.info('CemAcpt::ImageBuilder') { "Stopping instance #{instance_name}..." }
-                @exec.run('compute', 'instances', 'stop', instance_name)
+                @exec.run('compute', 'instances', 'stop', instance_name, '--zone', @config.get('platform.zone'))
               end
               unless @config.get('no_build_images')
                 deprecate_old_images_in_family(data['image_family'])
@@ -109,8 +115,18 @@ module CemAcpt
 
       attr_reader :environment
 
+      # Builds a GCE-safe image name from an image family. The returned name
+      # is at most GCE_IMAGE_NAME_MAX characters long, preserves the
+      # `-v<unix_timestamp>` suffix verbatim (so consecutive builds in the
+      # same family cannot collide on the truncated name), and never ends in
+      # a dash.
       def image_name_from_image_family(image_family)
-        "#{image_family}-v#{@start_time.to_i}"[0..64]
+        suffix = "-v#{@start_time.to_i}"
+        full = "#{image_family}#{suffix}"
+        return full if full.length <= GCE_IMAGE_NAME_MAX
+
+        prefix = image_family[0, GCE_IMAGE_NAME_MAX - suffix.length]
+        prefix.sub(/-+\z/, '') + suffix
       end
 
       def deprecate_old_images_in_family(image_family)
@@ -131,6 +147,17 @@ module CemAcpt
         logger.info('CemAcpt::ImageBuilder') { "Image #{image_name} created for family #{image_family}"}
       end
 
+      # Raises MissingTemplateError if the OS bucket has images configured but
+      # no `main.tf` ships under `lib/terraform/image/<platform>/<os_str>/`.
+      # Without this guard, `terraform init` later fails with an unhelpful
+      # "no configuration files" message.
+      def assert_template_present!(os_str)
+        template_path = File.join(@image_terraform_dir, os_str, 'main.tf')
+        return if File.exist?(template_path)
+
+        raise MissingTemplateError.new(os_str, template_path)
+      end
+
       def no_windows?
         @windows_tfvars[:node_data].empty? || @config.get('cem_acpt_image.no_windows')
       end

data/lib/cem_acpt/image_name_builder.rb

@@ -85,8 +85,15 @@ module CemAcpt
     def character_substitutions(name)
       return name unless @config[:character_substitutions]
 
+      subs = @config[:character_substitutions]
+      unless subs.is_a?(Array) && subs.all? { |s| s.is_a?(Array) && s.size == 2 }
+        raise ArgumentError,
+              'image_name_builder.character_substitutions must be an array of 2-item arrays, ' \
+              "e.g. [['_', '-']]; got: #{subs.inspect}"
+      end
+
       subbed_name = name
-      @config[:character_substitutions].each do |char_sub|
+      subs.each do |char_sub|
         subbed_name.gsub!(char_sub[0], char_sub[1])
       end
       subbed_name

data/lib/cem_acpt/platform/gcp.rb

@@ -4,112 +4,118 @@ require 'json'
 require 'open3'
 
 # GCP platform implementation
-module Platform
-  def platform_data
-    {
-      username: gcp_username,
-      credentials_file: gcp_credentials_file,
-      project: gcp_project,
-      region: gcp_region,
-      zone: gcp_zone,
-      subnetwork: gcp_subnetwork,
-      private_key: gcp_private_key,
-      public_key: gcp_public_key,
-    }
-  end
-
-  def node_data
-    nd = {}
-    nd[:machine_type] = gcp_machine_type
-    nd[:disk_size] = gcp_disk_size
-    nd[:max_run_duration] = gcp_max_run_duration
-    nd[:image] = image_name if image_name
-    nd[:test_name] = @test_data[:test_name] if @test_data&.key?(:test_name)
-    nd
-  end
-
-  def gcp_username
-    return @gcp_username if @gcp_username
-
-    @gcp_username = @config.get('platform.username')
-    return @gcp_username if @gcp_username
-
-    stdout, stderr, status = Open3.capture3('gcloud compute os-login describe-profile --format json')
-    raise "gcloud os-login describe-profile failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
-
-    parsed = JSON.parse(stdout)
-    accounts = parsed['posixAccounts']
-    raise "gcloud os-login profile returned no posixAccounts. stderr: #{stderr.chomp}" if accounts.nil? || accounts.empty?
-
-    username = accounts.first['username']
-    raise "gcloud os-login posixAccounts entry has no username. stdout: #{stdout.chomp}" unless username
-
-    @gcp_username = username
-  rescue JSON::ParserError => e
-    raise "Failed to parse gcloud os-login output: #{e.message}. stdout: #{stdout.chomp}"
-  end
-
-  def gcp_credentials_file
-    @gcp_credentials_file ||= (@config.get('platform.credentials_file') || File.join(Dir.home, '.config', 'gcloud', 'application_default_credentials.json'))
-  end
-
-  def gcp_project
-    return @gcp_project if @gcp_project
-
-    configured = @config.get('platform.project')
-    return @gcp_project = configured if configured
-
-    stdout, stderr, status = Open3.capture3('gcloud config get-value project')
-    raise "gcloud config get-value project failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
-
-    @gcp_project = stdout.chomp
-  end
-
-  def gcp_region
-    return @gcp_region if @gcp_region
-
-    configured = @config.get('platform.region')
-    return @gcp_region = configured if configured
-
-    stdout, stderr, status = Open3.capture3('gcloud config get-value compute/region')
-    raise "gcloud config get-value compute/region failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
-
-    @gcp_region = stdout.chomp
-  end
-
-  def gcp_zone
-    return @gcp_zone if @gcp_zone
-
-    configured = @config.get('platform.zone')
-    return @gcp_zone = configured if configured
-
-    stdout, stderr, status = Open3.capture3('gcloud config get-value compute/zone')
-    raise "gcloud config get-value compute/zone failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
-
-    @gcp_zone = stdout.chomp
-  end
-
-  def gcp_subnetwork
-    @gcp_subnetwork ||= (@config.get('platform.subnetwork') || 'default')
-  end
-
-  def gcp_private_key
-    @gcp_private_key ||= (@run_data[:private_key] || File.join(Dir.home, '.ssh', 'google_compute_engine'))
-  end
-
-  def gcp_public_key
-    @gcp_public_key ||= (@run_data[:public_key] || File.join(Dir.home, '.ssh', 'google_compute_engine.pub'))
-  end
-
-  def gcp_machine_type
-    @gcp_machine_type ||= (@config.get('node_data.machine_type') || 'e2-medium')
-  end
-
-  def gcp_disk_size
-    @gcp_disk_size ||= (@config.get('node_data.disk_size') || 40)
-  end
+module CemAcpt
+  module Platform
+    module Mixin
+      module Gcp
+        def platform_data
+          {
+            username: gcp_username,
+            credentials_file: gcp_credentials_file,
+            project: gcp_project,
+            region: gcp_region,
+            zone: gcp_zone,
+            subnetwork: gcp_subnetwork,
+            private_key: gcp_private_key,
+            public_key: gcp_public_key,
+          }
+        end
+
+        def node_data
+          nd = {}
+          nd[:machine_type] = gcp_machine_type
+          nd[:disk_size] = gcp_disk_size
+          nd[:max_run_duration] = gcp_max_run_duration
+          nd[:image] = image_name if image_name
+          nd[:test_name] = @test_data[:test_name] if @test_data&.key?(:test_name)
+          nd
+        end
+
+        def gcp_username
+          return @gcp_username if @gcp_username
+
+          @gcp_username = @config.get('platform.username')
+          return @gcp_username if @gcp_username
+
+          stdout, stderr, status = Open3.capture3('gcloud compute os-login describe-profile --format json')
+          raise "gcloud os-login describe-profile failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
+
+          parsed = JSON.parse(stdout)
+          accounts = parsed['posixAccounts']
+          raise "gcloud os-login profile returned no posixAccounts. stderr: #{stderr.chomp}" if accounts.nil? || accounts.empty?
+
+          username = accounts.first['username']
+          raise "gcloud os-login posixAccounts entry has no username. stdout: #{stdout.chomp}" unless username
+
+          @gcp_username = username
+        rescue JSON::ParserError => e
+          raise "Failed to parse gcloud os-login output: #{e.message}. stdout: #{stdout.chomp}"
+        end
+
+        def gcp_credentials_file
+          @gcp_credentials_file ||= (@config.get('platform.credentials_file') || File.join(Dir.home, '.config', 'gcloud', 'application_default_credentials.json'))
+        end
+
+        def gcp_project
+          return @gcp_project if @gcp_project
+
+          configured = @config.get('platform.project')
+          return @gcp_project = configured if configured
+
+          stdout, stderr, status = Open3.capture3('gcloud config get-value project')
+          raise "gcloud config get-value project failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
+
+          @gcp_project = stdout.chomp
+        end
+
+        def gcp_region
+          return @gcp_region if @gcp_region
+
+          configured = @config.get('platform.region')
+          return @gcp_region = configured if configured
+
+          stdout, stderr, status = Open3.capture3('gcloud config get-value compute/region')
+          raise "gcloud config get-value compute/region failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
+
+          @gcp_region = stdout.chomp
+        end
+
+        def gcp_zone
+          return @gcp_zone if @gcp_zone
+
+          configured = @config.get('platform.zone')
+          return @gcp_zone = configured if configured
+
+          stdout, stderr, status = Open3.capture3('gcloud config get-value compute/zone')
+          raise "gcloud config get-value compute/zone failed (exit #{status.exitstatus}): #{stderr.chomp}" unless status.success?
+
+          @gcp_zone = stdout.chomp
+        end
+
+        def gcp_subnetwork
+          @gcp_subnetwork ||= (@config.get('platform.subnetwork') || 'default')
+        end
+
+        def gcp_private_key
+          @gcp_private_key ||= (@run_data[:private_key] || File.join(Dir.home, '.ssh', 'google_compute_engine'))
+        end
+
+        def gcp_public_key
+          @gcp_public_key ||= (@run_data[:public_key] || File.join(Dir.home, '.ssh', 'google_compute_engine.pub'))
+        end
+
+        def gcp_machine_type
+          @gcp_machine_type ||= (@config.get('node_data.machine_type') || 'e2-medium')
+        end
+
+        def gcp_disk_size
+          @gcp_disk_size ||= (@config.get('node_data.disk_size') || 40)
+        end
 
-  def gcp_max_run_duration
-    @gcp_max_run_duration ||= (@config.get('node_data.max_run_duration') || 3600)
+        def gcp_max_run_duration
+          @gcp_max_run_duration ||= (@config.get('node_data.max_run_duration') || 3600)
+        end
+      end
+    end
   end
 end

data/lib/cem_acpt/platform.rb

@@ -7,6 +7,13 @@ require_relative 'logging'
 module CemAcpt::Platform
   class Error < StandardError; end
 
+  # Namespace for per-platform mixin modules. Each platform file in
+  # +lib/cem_acpt/platform/<name>.rb+ defines a module
+  # +CemAcpt::Platform::Mixin::<CamelCaseName>+ providing
+  # +#platform_data+ and +#node_data+, which is included into the
+  # dynamically-generated platform class.
+  module Mixin; end
+
   PLATFORM_DIR = File.expand_path(File.join(__dir__, 'platform'))
   BASE_TYPES = %i[base test].freeze
 
@@ -77,23 +84,19 @@ module CemAcpt::Platform
     # @param platform [String] the name of the platform.
     # @return [Class] the platform-specific Object.
     def platform_class(base_type, platform)
-      class_name = platform.capitalize
+      const_name = platform.split(/[_-]/).map(&:capitalize).join
       # We require the platform base class here so that we can use it as
       # a parent class for the platform-specific class.
       require_relative 'platform/base'
-      # If the class has already been defined, we can just use it.
-      if Object.const_defined?(class_name)
-        logger.debug('CemAcpt::Platform') { "Using existing platform class #{class_name}" }
-        klass = Object.const_get(class_name)
+      # If the class has already been defined under CemAcpt::Platform, reuse
+      # it. The +false+ argument skips ancestor lookup so that an unrelated
+      # constant of the same name elsewhere in the constant graph cannot
+      # silently win the cache check.
+      if CemAcpt::Platform.const_defined?(const_name, false)
+        logger.debug('CemAcpt::Platform') { "Using existing platform class #{const_name}" }
+        klass = CemAcpt::Platform.const_get(const_name, false)
       else
-        # Otherwise, we need to create the class. We do this by setting
-        # a new constant with the name of the platform capitalized, and
-        # associate that constant with a new instance of Class that inherits
-        # from the platform base class. We then require the platform file,
-        # include and extend our class with the Platform module from the file,
-        # include Logging and Concurrent::Async, and finally call the
-        # initialize method on the class.
-        logger.debug "Creating platform class #{class_name}"
+        logger.debug "Creating platform class #{const_name}"
         baseklass = case base_type.to_sym
                     when :base
                       CemAcpt::Platform::Base
@@ -102,12 +105,11 @@ module CemAcpt::Platform
                     else
                       raise Error, "Base type #{base_type} is not supported"
                     end
-        klass = Object.const_set(
-          class_name,
-          Class.new(baseklass) do
-            require_relative "platform/#{platform}"
-            include Platform
-          end,
+        require_relative "platform/#{platform}"
+        mixin = CemAcpt::Platform::Mixin.const_get(const_name, false)
+        klass = CemAcpt::Platform.const_set(
+          const_name,
+          Class.new(baseklass) { include mixin },
         )
       end
       logger.debug('CemAcpt::Platform') { "Using platform class: #{klass.inspect}" }

data/lib/cem_acpt/provision/terraform/linux.rb

@@ -11,7 +11,7 @@ module CemAcpt
       end
 
       def self.valid_versions
-        %w[7 8 9 2004 2204 2404]
+        %w[7 8 9 10 2004 2204 2404]
       end
 
       def systemd_files

data/lib/cem_acpt/provision/terraform/os_data.rb

@@ -9,6 +9,29 @@ module CemAcpt
       include CemAcpt::Logging
       extend CemAcpt::Logging
 
+      # Raised when a test name cannot be classified as either a Linux or Windows test by `os_family_for`.
+      class UnknownOsFamilyError < StandardError; end
+
+      # Classifies a test name as `:linux` or `:windows` using the same `use_for?` predicate that
+      # `Provision::Terraform#new_backend` consumes. Anchored on `Linux.valid_names` /
+      # `Windows.valid_names` rather than substring matching, so a test like
+      # `cis_rhel-8_firewalld_windowserver_2` correctly classifies as `:linux`.
+      # @param test_name [String] The test name to classify.
+      # @return [Symbol] `:windows` or `:linux`.
+      # @raise [UnknownOsFamilyError] if the test name does not match any known OS / version.
+      def self.os_family_for(test_name)
+        return :windows if CemAcpt::Provision::Windows.use_for?(test_name)
+        return :linux if CemAcpt::Provision::Linux.use_for?(test_name)
+
+        raise UnknownOsFamilyError, [
+          "Cannot determine OS family for test name: #{test_name}.",
+          "Known OSes: linux=[#{CemAcpt::Provision::Linux.valid_names.join(', ')}], " \
+            "windows=[#{CemAcpt::Provision::Windows.valid_names.join(', ')}].",
+          "Known versions: linux=[#{CemAcpt::Provision::Linux.valid_versions.join(', ')}], " \
+            "windows=[#{CemAcpt::Provision::Windows.valid_versions.join(', ')}].",
+        ].join(' ')
+      end
+
       # Determines if this OsData implementation should be used for the given test name. This method extracts the OS
       # name and version from the test name using a regular expression, and checks if they match the valid names and
       # versions defined by the subclass. The test name is expected to be in the format `<prefix>_osname-version`, where

data/lib/cem_acpt/provision/terraform/windows.rb

@@ -23,8 +23,14 @@ module CemAcpt
         'C:/cem_acpt'
       end
 
+      # Windows provisioning intentionally does not run any Terraform
+      # `remote-exec` commands — the Windows `main.tf` has no provisioner
+      # blocks. All shell work happens via {CemAcpt::Utils::WinRMRunner}
+      # after Terraform finishes. See ARCHITECTURE.md §13.
       def provision_commands
-        ['placeholder']
+        raise NotImplementedError,
+              'Windows provisioning is performed via Utils::WinRMRunner, not via ' \
+              'Terraform remote-exec. See ARCHITECTURE.md §13.'
       end
     end
   end

data/lib/cem_acpt/provision/terraform.rb

@@ -172,32 +172,23 @@ module CemAcpt
         terraform.show({ chdir: working_dir, no_color: true }, { environment: environment })
       end
 
-      # Creates a new backend instance based on the OS specified in the test name. This method checks the test name
-      # against the valid names and versions defined by the Linux and Windows backend classes, and returns an instance
-      # of the appropriate class. If the test name does not match any known OS, an error is raised.
+      # Creates a new backend instance based on the OS specified in the test name. Delegates to
+      # `Provision::OsData.os_family_for` so the runner and provisioner share a single source of truth for OS dispatch.
       # @param test_name [String] The name of the test, which should include the OS name and version in the format
       #   `<prefix>_osname-version`.
       # @return [CemAcpt::Provision::Linux, CemAcpt::Provision::Windows] An instance of the appropriate backend class
       #   based on the OS specified in the test name.
-      # @raise [ArgumentError] If the test name does not match any known OS or version.
+      # @raise [CemAcpt::Provision::OsData::UnknownOsFamilyError] If the test name does not match any known OS or version.
       def new_backend(test_name)
-        if CemAcpt::Provision::Linux.use_for?(test_name)
+        case CemAcpt::Provision::OsData.os_family_for(test_name)
+        when :linux
           logger.info('CemAcpt::Provision::Terraform') { 'Using Linux backend' }
           logger.verbose('CemAcpt::Provision::Terraform') { "Creating backend with provision_data:\n#{JSON.pretty_generate(@provision_data)}" }
           CemAcpt::Provision::Linux.new(@config, @provision_data)
-        elsif CemAcpt::Provision::Windows.use_for?(test_name)
+        when :windows
           logger.info('CemAcpt::Provision::Terraform') { 'Using Windows backend' }
           logger.verbose('CemAcpt::Provision::Terraform') { "Creating backend with provision_data:\n#{JSON.pretty_generate(@provision_data)}" }
           CemAcpt::Provision::Windows.new(@config, @provision_data)
-        else
-          err_msg = [
-            "Test name #{test_name} does not match any known OS.",
-            "Known OSes are: #{CemAcpt::Provision::Linux.valid_names.join(', ')}",
-            "and #{CemAcpt::Provision::Windows.valid_names.join(', ')}.",
-            "Known versions are: #{CemAcpt::Provision::Linux.valid_versions.join(', ')}",
-            ", and #{CemAcpt::Provision::Windows.valid_versions.join(', ')}.",
-          ].join(' ')
-          raise ArgumentError, err_msg
         end
       end
 
@@ -282,7 +273,7 @@ module CemAcpt
               puppet_manifest: node.test_data[:puppet_manifest],
               provision_dir_source: @backend.provision_directory,
               provision_dir_dest: @backend.destination_provision_directory,
-              provision_commands: @backend.instance_of?(CemAcpt::Provision::Linux) ? @backend.provision_commands_wrapper(node.node_data[:image]) : @backend.provision_commands,
+              provision_commands: provision_commands_for(node),
             }
           )
         end
@@ -291,6 +282,19 @@ module CemAcpt
         raise e
       end
 
+      # Windows provisioning runs via {CemAcpt::Utils::WinRMRunner} rather
+      # than Terraform `remote-exec`, so its node_data carries no commands.
+      def provision_commands_for(node)
+        case @backend
+        when CemAcpt::Provision::Linux
+          @backend.provision_commands_wrapper(node.node_data[:image])
+        when CemAcpt::Provision::Windows
+          []
+        else
+          @backend.provision_commands
+        end
+      end
+
       # @return [Hash] The variables to be passed to Terraform, including the provision data for the nodes and any
       #   necessary credentials and module package paths.
       # @raise [StandardError] If there is an error formatting the variables.

data/lib/cem_acpt/test_runner/log_formatter/bolt_summary_results_formatter.rb

@@ -6,7 +6,8 @@ require_relative 'base'
 module CemAcpt
   module TestRunner
     module LogFormatter
-      # Formats the results of a Bolt::SummaryResults object
+      # Canonical formatter for Bolt subsystem results. Wired into
+      # LogFormatter.new_formatter for CemAcpt::Bolt::SummaryResults.
       class BoltSummaryResultsFormatter < Base
         def initialize(config, instance_names_ips, subject: nil)
           super(subject)

data/lib/cem_acpt/test_runner/log_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'log_formatter/bolt_summary_results_formatter'
-require_relative 'log_formatter/bolt_output_formatter'
 require_relative 'log_formatter/goss_action_response'
 require_relative 'log_formatter/goss_error_formatter'
 require_relative 'log_formatter/standard_error_formatter'