mux_tf 0.13.0 → 0.14.0

data/lib/mux_tf/plan_formatter.rb

@@ -1,14 +1,358 @@
 # frozen_string_literal: true
 
 module MuxTf
-  class PlanFormatter
+  class PlanFormatter # rubocop:disable Metrics/ClassLength
     extend TerraformHelpers
     extend PiotrbCliUtils::Util
+    include Coloring
 
-    class << self
-      def pretty_plan(filename, targets: []) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        pastel = Pastel.new
+    class << self # rubocop:disable Metrics/ClassLength
+      def log_unhandled_line(state, line, reason: nil)
+        p [state, pastel.strip(line), reason]
+      end
+
+      def pretty_plan(filename, targets: [])
+        if ENV["JSON_PLAN"]
+          pretty_plan_v2(filename, targets: targets)
+        else
+          pretty_plan_v1(filename, targets: targets)
+        end
+      end
+
+      def parse_non_json_plan_line(raw_line)
+        result = {}
+
+        if raw_line.match(/^time=(?<timestamp>[^ ]+) level=(?<level>[^ ]+) msg=(?<message>.+?)(?: prefix=\[(?<prefix>.+?)\])?\s*$/)
+          result.merge!($LAST_MATCH_INFO.named_captures.symbolize_keys)
+          result[:module] = "terragrunt"
+          result.delete(:prefix) unless result[:prefix]
+          result[:prefix] = Pathname.new(result[:prefix]).relative_path_from(Dir.getwd).to_s if result[:prefix]
+
+          result[:merge_up] = true if result[:message].match(/^\d+ errors? occurred:$/)
+        elsif raw_line.strip == ""
+          result[:blank] = true
+        else
+          result[:message] = raw_line
+          result[:merge_up] = true
+        end
+
+        # time=2023-08-25T11:44:41-07:00 level=error msg=Terraform invocation failed in /Users/piotr/Work/janepods/.terragrunt-cache/BM86IAj5tW4bZga2lXeYT8tdOKI/V0IEypKSfyl-kHfCnRNAqyX02V8/modules/event-bus prefix=[/Users/piotr/Work/janepods/accounts/eks-dev/admin/apps/kube-system-event-bus]
+        # time=2023-08-25T11:44:41-07:00 level=error msg=1 error occurred:
+        #         * [/Users/piotr/Work/janepods/.terragrunt-cache/BM86IAj5tW4bZga2lXeYT8tdOKI/V0IEypKSfyl-kHfCnRNAqyX02V8/modules/event-bus] exit status 2
+        #
+        #
+        result
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def tf_plan_json(out:, targets: [], &block)
+        emit_line = proc { |result|
+          result[:level] ||= result[:stream] == :stderr ? "error" : "info"
+          result[:module] ||= result[:stream]
+          result[:type] ||= "unknown"
+
+          if result[:message].match(/^Terraform invocation failed in (.+)/)
+            result[:type] = "tf_failed"
+
+            lines = result[:message].split("\n")
+            result[:diagnostic] = {
+              "summary" => "Terraform invocation failed",
+              "detail" => result[:message],
+              roots: [],
+              extra: []
+            }
+
+            lines.each do |line|
+              if line.match(/^\s+\* \[(.+)\] exit status (\d+)$/)
+                result[:diagnostic][:roots] << {
+                  path: $LAST_MATCH_INFO[1],
+                  status: $LAST_MATCH_INFO[2].to_i
+                }
+              elsif line.match(/^\d+ errors? occurred$/)
+                # noop
+              else
+                result[:diagnostic][:extra] << line
+              end
+            end
+
+            result[:message] = "Terraform invocation failed"
+          end
+
+          block.call(result)
+        }
+        last_stderr_line = nil
+        status = tf_plan(out: out, detailed_exitcode: true, color: true, compact_warnings: false, json: true, input: false,
+                         targets: targets) { |(stream, raw_line)|
+          case stream
+          # when :command
+          #   puts raw_line
+          when :stdout
+            parsed_line = JSON.parse(raw_line)
+            parsed_line.keys.each do |key| # rubocop:disable Style/HashEachMethods -- intentional, allow adding keys to hash while iterating
+              if key[0] == "@"
+                parsed_line[key[1..]] = parsed_line[key]
+                parsed_line.delete(key)
+              end
+            end
+            parsed_line.symbolize_keys!
+            parsed_line[:stream] = stream
+            if last_stderr_line
+              emit_line.call(last_stderr_line)
+              last_stderr_line = nil
+            end
+            emit_line.call(parsed_line)
+          when :stderr
+            parsed_line = parse_non_json_plan_line(raw_line)
+            parsed_line[:stream] = stream
+
+            if parsed_line[:blank]
+              if last_stderr_line
+                emit_line.call(last_stderr_line)
+                last_stderr_line = nil
+              end
+            elsif parsed_line[:merge_up]
+              if last_stderr_line
+                last_stderr_line[:message] += "\n#{parsed_line[:message]}"
+              else
+                # this is just a standalone message then
+                parsed_line.delete(:merge_up)
+                last_stderr_line = parsed_line
+              end
+            elsif last_stderr_line
+              emit_line.call(last_stderr_line)
+              last_stderr_line = parsed_line
+            else
+              last_stderr_line = parsed_line
+            end
+          end
+        }
+        emit_line.call(last_stderr_line) if last_stderr_line
+        status
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def parse_lock_info(detail)
+        # Lock Info:
+        #   ID:        4cc9c775-f0b7-3da7-25a4-94131afcef4d
+        #   Path:      jane-terraform-eks-dev/admin/apps/kube-system-event-bus/terraform.tfstate
+        #   Operation: OperationTypePlan
+        #   Who:       piotr@Piotrs-Jane-MacBook-Pro.local
+        #   Version:   1.5.4
+        #   Created:   2023-08-25 19:03:38.821597 +0000 UTC
+        #   Info:
+        result = {}
+        keys = %w[ID Path Operation Who Version Created]
+        keys.each do |key|
+          result[key] = detail.match(/^\s*#{key}:\s+(.+)$/)&.captures&.first
+        end
+        result
+      end
 
+      def print_plan_line(parsed_line, without: [])
+        default_without = [
+          :level,
+          :module,
+          :type,
+          :stream,
+          :message,
+          :timestamp,
+          :terraform,
+          :ui
+        ]
+        extra = parsed_line.without(*default_without, *without)
+        data = parsed_line.merge(extra: extra)
+        log_line = [
+          "%<level>-6s",
+          "%<module>-12s",
+          "%<type>-10s",
+          "%<message>s",
+          "%<extra>s"
+        ].map { |format_string|
+          field = format_string.match(/%<([^>]+)>/)[1].to_sym
+          data[field].present? ? format(format_string, data) : nil
+        }.compact.join(" | ")
+        log log_line
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def pretty_plan_v2(filename, targets: [])
+        meta = {}
+        meta[:seen] = {
+          module_and_type: Set.new
+        }
+
+        status = tf_plan_json(out: filename, targets: targets) { |(parsed_line)|
+          seen = proc { |module_arg, type_arg| meta[:seen][:module_and_type].include?([module_arg, type_arg]) }
+          # first_in_state = !seen.call(parsed_line[:module], parsed_line[:type])
+
+          case parsed_line[:level]
+          when "info"
+            case parsed_line[:module]
+            when "terraform.ui"
+              case parsed_line[:type]
+              when "version"
+                meta[:terraform_version] = parsed_line[:terraform]
+                meta[:terraform_ui_version] = parsed_line[:ui]
+              when "apply_start", "refresh_start"
+                first_in_group = !seen.call(parsed_line[:module], "apply_start") &&
+                                 !seen.call(parsed_line[:module], "refresh_start")
+                log "Refreshing ", depth: 1, newline: false if first_in_group
+                # {
+                #   :hook=>{
+                #     "resource"=>{
+                #       "addr"=>"data.aws_eks_cluster_auth.this",
+                #       "module"=>"",
+                #       "resource"=>"data.aws_eks_cluster_auth.this",
+                #       "implied_provider"=>"aws",
+                #       "resource_type"=>"aws_eks_cluster_auth",
+                #       "resource_name"=>"this",
+                #       "resource_key"=>nil
+                #     },
+                #     "action"=>"read"
+                #   }
+                # }
+                log ".", newline: false
+              when "apply_complete", "refresh_complete"
+                # {
+                #   :hook=>{
+                #     "resource"=>{
+                #       "addr"=>"data.aws_eks_cluster_auth.this",
+                #       "module"=>"",
+                #       "resource"=>"data.aws_eks_cluster_auth.this",
+                #       "implied_provider"=>"aws",
+                #       "resource_type"=>"aws_eks_cluster_auth",
+                #       "resource_name"=>"this",
+                #       "resource_key"=>nil
+                #     },
+                #     "action"=>"read",
+                #     "id_key"=>"id",
+                #     "id_value"=>"admin",
+                #     "elapsed_seconds"=>0
+                #   }
+                # }
+                # noop
+              when "resource_drift"
+                first_in_group = !seen.call(parsed_line[:module], "resource_drift") &&
+                                 !seen.call(parsed_line[:module], "planned_change")
+                # {
+                #   :change=>{
+                #     "resource"=>{"addr"=>"module.application.kubectl_manifest.application", "module"=>"module.application", "resource"=>"kubectl_manifest.application", "implied_provider"=>"kubectl", "resource_type"=>"kubectl_manifest", "resource_name"=>"application", "resource_key"=>nil},
+                #     "action"=>"update"
+                #   }
+                # }
+                if first_in_group
+                  log ""
+                  log ""
+                  log "Planned Changes:"
+                end
+                # {
+                #   :change=>{
+                #     "resource"=>{"addr"=>"aws_iam_policy.crossplane_aws_ecr[0]", "module"=>"", "resource"=>"aws_iam_policy.crossplane_aws_ecr[0]", "implied_provider"=>"aws", "resource_type"=>"aws_iam_policy", "resource_name"=>"crossplane_aws_ecr", "resource_key"=>0},
+                #     "action"=>"update"
+                #   },
+                #   :type=>"resource_drift",
+                #   :level=>"info",
+                #   :message=>"aws_iam_policy.crossplane_aws_ecr[0]: Drift detected (update)",
+                #   :module=>"terraform.ui",
+                #   :timestamp=>"2023-09-26T17:11:46.340117-07:00",
+                #   :stream=>:stdout
+                # }
+
+                log format("[%<action>s] %<addr>s - Drift Detected (%<change_action>s)",
+                           action: PlanSummaryHandler.format_action(parsed_line[:change]["action"]),
+                           addr: PlanSummaryHandler.format_address(parsed_line[:change]["resource"]["addr"]),
+                           change_action: parsed_line[:change]["action"]), depth: 1
+              when "planned_change"
+                first_in_group = !seen.call(parsed_line[:module], "resource_drift") &&
+                                 !seen.call(parsed_line[:module], "planned_change")
+                # {
+                #  :change=>
+                #   {"resource"=>
+                #     {"addr"=>"module.application.kubectl_manifest.application",
+                #      "module"=>"module.application",
+                #      "resource"=>"kubectl_manifest.application",
+                #      "implied_provider"=>"kubectl",
+                #      "resource_type"=>"kubectl_manifest",
+                #      "resource_name"=>"application",
+                #      "resource_key"=>nil},
+                #    "action"=>"create"},
+                #  :type=>"planned_change",
+                #  :level=>"info",
+                #  :message=>"module.application.kubectl_manifest.application: Plan to create",
+                #  :module=>"terraform.ui",
+                #  :timestamp=>"2023-08-25T14:48:46.005185-07:00",
+                # }
+                if first_in_group
+                  log ""
+                  log ""
+                  log "Planned Changes:"
+                end
+                log format("[%<action>s] %<addr>s",
+                           action: PlanSummaryHandler.format_action(parsed_line[:change]["action"]),
+                           addr: PlanSummaryHandler.format_address(parsed_line[:change]["resource"]["addr"])), depth: 1
+              when "change_summary"
+                # {
+                #   :changes=>{"add"=>1, "change"=>0, "import"=>0, "remove"=>0, "operation"=>"plan"},
+                #   :type=>"change_summary",
+                #   :level=>"info",
+                #   :message=>"Plan: 1 to add, 0 to change, 0 to destroy.",
+                #   :module=>"terraform.ui",
+                #   :timestamp=>"2023-08-25T14:48:46.005211-07:00",
+                #   :stream=>:stdout
+                # }
+                log ""
+                # puts parsed_line[:message]
+                log "#{parsed_line[:changes]['operation'].capitalize} summary: " + parsed_line[:changes].without("operation").map { |k, v|
+                  color = PlanSummaryHandler.color_for_action(k)
+                  "#{pastel.yellow(v)} to #{pastel.decorate(k, color)}" if v.positive?
+                }.compact.join(" ")
+
+              else
+                print_plan_line(parsed_line)
+              end
+            else
+              print_plan_line(parsed_line)
+            end
+          when "error"
+            if parsed_line[:diagnostic]
+              handled_error = false
+              muted_error = false
+              unless parsed_line[:module] == "terragrunt" && parsed_line[:type] == "tf_failed"
+                meta[:errors] ||= []
+                meta[:errors] << {
+                  type: :error,
+                  message: parsed_line[:diagnostic]["summary"],
+                  body: parsed_line[:diagnostic]["detail"].split("\n")
+                }
+              end
+
+              if parsed_line[:diagnostic]["summary"] == "Error acquiring the state lock"
+                meta["error"] = "lock"
+                meta.merge!(parse_lock_info(parsed_line[:diagnostic]["detail"]))
+                handled_error = true
+              elsif parsed_line[:module] == "terragrunt" && parsed_line[:type] == "tf_failed"
+                muted_error = true
+              end
+
+              unless muted_error
+                if handled_error
+                  print_plan_line(parsed_line, without: [:diagnostic])
+                else
+                  print_plan_line(parsed_line)
+                end
+              end
+            else
+              print_plan_line(parsed_line)
+            end
+          end
+
+          meta[:seen][:module_and_type] << [parsed_line[:module], parsed_line[:type]]
+        }
+        [status.status, meta]
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def pretty_plan_v1(filename, targets: []) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         meta = {}
 
         parser = StatefulParser.new(normalizer: pastel.method(:strip))
@@ -19,25 +363,28 @@ module MuxTf
         parser.state(:refreshing, /^.+: Refreshing state... \[id=/, [:none, :info, :reading])
         parser.state(:refreshing, /Refreshing Terraform state in-memory prior to plan.../,
                      [:none, :blank, :info, :reading])
-        parser.state(:refresh_done, /^----------+$/, [:refreshing])
-        parser.state(:refresh_done, /^$/, [:refreshing])
+        parser.state(:none, /^----------+$/, [:refreshing])
+        parser.state(:none, /^$/, [:refreshing])
 
-        parser.state(:output_info, /^Changes to Outputs:$/, [:refresh_done])
-        parser.state(:refresh_done, /^$/, [:output_info])
+        parser.state(:output_info, /^Changes to Outputs:$/, [:none])
+        parser.state(:none, /^$/, [:output_info])
 
-        parser.state(:plan_info, /Terraform will perform the following actions:/, [:refresh_done, :none])
+        parser.state(:plan_info, /Terraform will perform the following actions:/, [:none])
         parser.state(:plan_summary, /^Plan:/, [:plan_info])
 
         parser.state(:plan_legend, /^Terraform used the selected providers to generate the following execution$/)
         parser.state(:none, /^$/, [:plan_legend])
 
-        parser.state(:error_lock_info, /Lock Info/, [:plan_error_error])
+        parser.state(:plan_info, /Terraform planned the following actions, but then encountered a problem:/, [:none])
+        parser.state(:plan_info, /No changes. Your infrastructure matches the configuration./, [:none])
+
+        parser.state(:plan_error, /Planning failed. Terraform encountered an error while generating this plan./, [:refreshing])
+
+        # this extends the error block to include the lock info
+        parser.state(:error_lock_info, /Lock Info/, [:error_block_error])
+        parser.state(:after_error, /^╵/, [:error_lock_info])
 
-        parser.state(:plan_error, /Planning failed. Terraform encountered an error while generating this plan./, [:refreshing, :refresh_done])
-        parser.state(:plan_error_block, /^╷/, [:plan_error, :none, :blank, :info, :reading])
-        parser.state(:plan_error_warning, /^│ Warning: /, [:plan_error_block])
-        parser.state(:plan_error_error, /^│ Error: /, [:plan_error_block])
-        parser.state(:plan_error, /^╵/, [:plan_error_warning, :plan_error_error, :plan_error_block, :error_lock_info])
+        setup_error_handling(parser, from_states: [:plan_error, :none, :blank, :info, :reading, :plan_summary, :refreshing])
 
         last_state = nil
 
@@ -50,7 +397,7 @@ module MuxTf
               if line.blank?
                 # nothing
               else
-                p [state, line]
+                log_unhandled_line(state, line, reason: "unexpected non blank line in :none state")
               end
             when :reading
               clean_line = pastel.strip(line)
@@ -63,43 +410,16 @@ module MuxTf
                   log "Reading Complete: #{$LAST_MATCH_INFO[1]} after #{$LAST_MATCH_INFO[2]}", depth: 3
                 end
               else
-                p [state, line]
+                log_unhandled_line(state, line, reason: "unexpected line in :reading state")
               end
             when :info
               if /Acquiring state lock. This may take a few moments.../.match?(line)
                 log "Acquiring state lock ...", depth: 2
               else
-                p [state, line]
-              end
-            when :plan_error_block
-              meta[:current_error] = {
-                type: :unknown,
-                body: []
-              }
-            when :plan_error_warning, :plan_error_error
-              clean_line = pastel.strip(line).gsub(/^│ /, "")
-              if clean_line =~ /^(Warning|Error): (.+)$/
-                meta[:current_error][:type] = $LAST_MATCH_INFO[1].downcase.to_sym
-                meta[:current_error][:message] = $LAST_MATCH_INFO[2]
-              elsif clean_line == ""
-                # skip double empty lines
-                meta[:current_error][:body] << clean_line if meta[:current_error][:body].last != ""
-              else
-                meta[:current_error][:body] ||= []
-                meta[:current_error][:body] << clean_line
+                log_unhandled_line(state, line, reason: "unexpected line in :info state")
               end
             when :plan_error
               case pastel.strip(line)
-              when "╵" # closing of an error block
-                if meta[:current_error][:type] == :error
-                  meta[:errors] ||= []
-                  meta[:errors] << meta[:current_error]
-                end
-                if meta[:current_error][:type] == :warning
-                  meta[:warnings] ||= []
-                  meta[:warnings] << meta[:current_error]
-                end
-                meta.delete(:current_error)
               when ""
                 # skip empty line
               when /Releasing state lock. This may take a few moments"/
@@ -107,7 +427,7 @@ module MuxTf
               when /Planning failed./ # rubocop:disable Lint/DuplicateBranch
                 log line, depth: 2
               else
-                p [state, line]
+                log_unhandled_line(state, line, reason: "unexpected line in :plan_error state")
               end
             when :error_lock_info
               meta["error"] = "lock"
@@ -118,7 +438,6 @@ module MuxTf
               else
                 meta[:current_error][:body] << clean_line
               end
-              # log Paint[line, :red], depth: 2
             when :refreshing
               if first_in_state
                 log "Refreshing state ", depth: 2, newline: false
@@ -139,7 +458,7 @@ module MuxTf
             when :plan_summary
               log line, depth: 2
             else
-              p [state, pastel.strip(line)]
+              log_unhandled_line(state, line, reason: "unexpected state") unless handle_error_states(meta, state, line)
             end
             last_state = state
           end
@@ -150,19 +469,67 @@ module MuxTf
       def init_status_to_remedies(status, meta)
         remedies = Set.new
         if status != 0
-          if meta[:need_reconfigure]
-            remedies << :reconfigure
-          else
-            p [status, meta]
+          remedies << :reconfigure if meta[:need_reconfigure]
+          meta[:errors].each do |error|
+            remedies << :add_provider_constraint if error[:body].grep(/Could not retrieve the list of available versions for provider/)
+          end
+          if remedies.empty?
+            log "!! don't know how to generate init remedies for this"
+            log "!! Status: #{status}"
+            log "!! Meta:"
+            log meta.to_yaml.split("\n").map { |l| "!!   #{l}" }.join("\n")
             remedies << :unknown
           end
         end
         remedies
       end
 
-      def run_tf_init(upgrade: nil, reconfigure: nil) # rubocop:disable Metrics/MethodLength
-        pastel = Pastel.new
+      def setup_error_handling(parser, from_states:)
+        parser.state(:error_block, /^╷/, from_states | [:after_error])
+        parser.state(:error_block_error, /^│ Error: /, [:error_block])
+        parser.state(:error_block_warning, /^│ Warning: /, [:error_block])
+        parser.state(:after_error, /^╵/, [:error_block, :error_block_error, :error_block_warning])
+      end
 
+      def handle_error_states(meta, state, line) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        case state
+        when :error_block
+          meta[:current_error] = {
+            type: :unknown,
+            body: []
+          }
+        when :error_block_error, :error_block_warning
+          clean_line = pastel.strip(line).gsub(/^│ /, "")
+          if clean_line =~ /^(Warning|Error): (.+)$/
+            meta[:current_error][:type] = $LAST_MATCH_INFO[1].downcase.to_sym
+            meta[:current_error][:message] = $LAST_MATCH_INFO[2]
+          elsif clean_line == ""
+            # skip double empty lines
+            meta[:current_error][:body] << clean_line if meta[:current_error][:body].last != ""
+          else
+            meta[:current_error][:body] ||= []
+            meta[:current_error][:body] << clean_line
+          end
+        when :after_error
+          case pastel.strip(line)
+          when "╵" # closing of an error block
+            if meta[:current_error][:type] == :error
+              meta[:errors] ||= []
+              meta[:errors] << meta[:current_error]
+            end
+            if meta[:current_error][:type] == :warning
+              meta[:warnings] ||= []
+              meta[:warnings] << meta[:current_error]
+            end
+            meta.delete(:current_error)
+          end
+        else
+          return false
+        end
+        true
+      end
+
+      def run_tf_init(upgrade: nil, reconfigure: nil) # rubocop:disable Metrics/MethodLength
         phase = :init
 
         meta = {}
@@ -177,6 +544,8 @@ module MuxTf
         parser.state(:plugin_warnings, /^$/, [:plugins])
         parser.state(:backend_error, /Error:/, [:backend])
 
+        setup_error_handling(parser, from_states: [:plugins])
+
         status = tf_init(upgrade: upgrade, reconfigure: reconfigure) { |raw_line|
           stripped_line = pastel.strip(raw_line.rstrip)
 
@@ -198,7 +567,7 @@ module MuxTf
               when ""
                 puts
               else
-                p [state, stripped_line]
+                log_unhandled_line(state, line, reason: "unexpected line in :modules_init state")
               end
             when :modules_upgrade
               if phase != state
@@ -217,13 +586,13 @@ module MuxTf
               when ""
                 puts
               else
-                p [state, stripped_line]
+                log_unhandled_line(state, line, reason: "unexpected line in :modules_upgrade state")
               end
             when :backend
               if phase != state
                 # first line
                 phase = state
-                log "Initializing the backend ", depth: 1, newline: false
+                log "Initializing the backend ", depth: 1 # , newline: false
                 next
               end
               case stripped_line
@@ -234,12 +603,12 @@ module MuxTf
               when ""
                 puts
               else
-                p [state, stripped_line]
+                log_unhandled_line(state, line, reason: "unexpected line in :backend state")
               end
             when :backend_error
               if raw_line.match "terraform init -reconfigure"
                 meta[:need_reconfigure] = true
-                log Paint["module needs to be reconfigured", :red], depth: 2
+                log pastel.red("module needs to be reconfigured"), depth: 2
               end
             when :plugins
               if phase != state
@@ -276,7 +645,7 @@ module MuxTf
               when "- Checking for available provider plugins..."
                 # noop
               else
-                p [state, line]
+                log_unhandled_line(state, line, reason: "unexpected line in :plugins state")
               end
             when :plugin_warnings
               if phase != state
@@ -285,13 +654,13 @@ module MuxTf
                 next
               end
 
-              log Paint[line, :yellow], depth: 1
+              log pastel.yellow(line), depth: 1
             when :none
               next if line == ""
 
-              p [state, line]
+              log_unhandled_line(state, line, reason: "unexpected line in :none state")
             else
-              p [state, line]
+              log_unhandled_line(state, line, reason: "unexpected state") unless handle_error_states(meta, state, line)
             end
           end
         }
@@ -299,35 +668,75 @@ module MuxTf
         [status.status, meta]
       end
 
-      def process_validation(info) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def print_validation_errors(info)
+        return unless (info["error_count"]).positive? || (info["warning_count"]).positive?
+
+        log "Encountered #{pastel.red(info['error_count'])} Errors and #{pastel.yellow(info['warning_count'])} Warnings!", depth: 2
+        info["diagnostics"].each do |dinfo|
+          color = dinfo["severity"] == "error" ? :red : :yellow
+          log "#{pastel.decorate(dinfo['severity'].capitalize, color)}: #{dinfo['summary']}", depth: 3
+          log dinfo["detail"].split("\n"), depth: 4 if dinfo["detail"]
+          log format_validation_range(dinfo, color), depth: 4 if dinfo["range"]
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def process_validation(info) # rubocop:disable Metrics/CyclomaticComplexity
         remedies = Set.new
 
         if (info["error_count"]).positive? || (info["warning_count"]).positive?
-          log "Encountered #{Paint[info['error_count'], :red]} Errors and #{Paint[info['warning_count'], :yellow]} Warnings!", depth: 2
-          info["diagnostics"].each do |dinfo|
-            color = dinfo["severity"] == "error" ? :red : :yellow
-            log "#{Paint[dinfo['severity'].capitalize, color]}: #{dinfo['summary']}", depth: 3
-            if dinfo["detail"]&.include?("terraform init")
-              remedies << :init
-            elsif /there is no package for .+ cached in/.match?(dinfo["summary"]) # rubocop:disable Lint/DuplicateBranch
-              remedies << :init
-            elsif dinfo["detail"]&.include?("timeout while waiting for plugin to start") # rubocop:disable Lint/DuplicateBranch
+          info["diagnostics"].each do |dinfo| # rubocop:disable Metrics/BlockLength
+            item_handled = false
+
+            case dinfo["summary"]
+            when /there is no package for .+ cached in/,
+                /Missing required provider/,
+                /Module not installed/,
+                /Module source has changed/,
+                /Required plugins are not installed/,
+                /Module version requirements have changed/
               remedies << :init
-            else
-              log dinfo["detail"], depth: 4 if dinfo["detail"]
-              log format_validation_range(dinfo["range"], color), depth: 4 if dinfo["range"]
+              item_handled = true
+            when /Missing required argument/,
+                /Error in function call/,
+                /Invalid value for input variable/,
+                /Unsupported block type/,
+                /Reference to undeclared input variable/,
+                /Invalid reference/,
+                /Unsupported attribute/,
+                /Invalid depends_on reference/
+              remedies << :user_error
+              item_handled = true
+            end
 
-              remedies << :unknown if dinfo["severity"] == "error"
+            if dinfo["severity"] == "error" && dinfo["snippet"]
+              # trying something new .. assuming anything with a snippet is a user error
+              remedies << :user_error
+              item_handled = true
             end
+
+            case dinfo["detail"]
+            when /timeout while waiting for plugin to start/
+              remedies << :init
+              item_handled = true
+            end
+
+            next if item_handled
+
+            puts "!! don't know how to handle this validation error"
+            puts dinfo.inspect
+            remedies << :unknown if dinfo["severity"] == "error"
           end
         end
 
         remedies
       end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       private
 
-      def format_validation_range(range, color) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+      def format_validation_range(dinfo, color) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+        range = dinfo["range"]
         # filename: "../../../modules/pods/jane_pod/main.tf"
         # start:
         #   line: 151
@@ -353,6 +762,7 @@ module MuxTf
                      end
         output << "on: #{range['filename']} line#{lines.size > 1 ? 's' : ''}: #{lines_info}"
 
+        # TODO: in terragrunt mode, we need to somehow figure out the path to the cache root, all the paths will end up being relative to that
         if File.exist?(range["filename"])
           file_lines = File.read(range["filename"]).split("\n")
           extract_range = (([lines.first - context_lines,
@@ -368,12 +778,25 @@ module MuxTf
                   start_col = columns.last
                 end
                 painted_line = paint_line(line, color, start_col: start_col, end_col: end_col)
-                output << "#{Paint['>', color]} #{index + 1}: #{painted_line}"
+                output << "#{pastel.decorate('>', color)} #{index + 1}: #{painted_line}"
               else
                 output << "  #{index + 1}: #{line}"
               end
             end
           end
+        elsif dinfo["snippet"]
+          # {
+          #   "context"=>"locals",
+          #   "code"=>"        aws_iam_policy.crossplane_aws_ecr.arn",
+          #   "start_line"=>72,
+          #   "highlight_start_offset"=>8,
+          #   "highlight_end_offset"=>41,
+          #   "values"=>[]
+          # }
+          output << "Code:"
+          dinfo["snippet"]["code"].split("\n").each do |l|
+            output << " > #{l}"
+          end
         end
 
         output
@@ -384,7 +807,7 @@ module MuxTf
         prefix = line[0, start_col - 1]
         suffix = line[end_col..]
         middle = line[start_col - 1..end_col - 1]
-        "#{prefix}#{Paint[middle, *paint_options]}#{suffix}"
+        "#{prefix}#{pastel.decorate(middle, *paint_options)}#{suffix}"
       end
     end
   end