kennel 1.128.0 → 1.130.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27f0b47987630640f1d58181bc98360714dc4b39827ea7282d1445496e3d315
-  data.tar.gz: a2dbe1c762943b8859134772f39e3f0af0f4e7e2c5c1a60c2de980574de84714
+  metadata.gz: d6ee3df09b69dd5a7af7285c219f4415c4e94ce2ab4f6533c5fff03be848e9c4
+  data.tar.gz: d7f923b69ad9b63774141ac0e9c6c04de7a26a67abd732c41c5f19d478704656
 SHA512:
-  metadata.gz: 6c16b16c0914e6c436424c431eec9b5b0ff5dcb92195096973e1807c75375e34f16094c4935c28de6a0797ebb8d5cc5a8e86a9c38f4a778df65598ede58ad348
-  data.tar.gz: d885678eb185f3fa404d8c42c64f3c7f22250da1537ecec556d5f9728fe9a6aa7d7fb889f9c8d637c4f29787864f05ec5a51c5abb90023fde1c71a0110a24dd5
+  metadata.gz: 7c967bf54743cc757a0c0c911e981701d4b5b393f6ebac66538432541c7c6dfecef2cd8c1c0e5389f90c7d0b91a54e79a29e0e1abf9d16fd67adad4bcd6209fe
+  data.tar.gz: 297239ea9305e4eadbe40a363160b0ca2aaf70dad237f95a448b00b30d3db9ed9f707b2736b2596ef73e8981d333b600af87da40978f5d1c9fc8e0dee3d7f9ea

data/lib/kennel/api.rb

@@ -5,6 +5,14 @@ module Kennel
   class Api
     CACHE_FILE = "tmp/cache/details"
 
+    def self.tag(api_resource, reply)
+      klass = Models::Record.api_resource_map[api_resource]
+      reply.merge(
+        klass: klass,
+        tracking_id: klass.parse_tracking_id(reply)
+      )
+    end
+
     def initialize(app_key = nil, api_key = nil)
       @app_key = app_key || ENV.fetch("DATADOG_APP_KEY")
       @api_key = api_key || ENV.fetch("DATADOG_API_KEY")
@@ -16,7 +24,7 @@ module Kennel
       response = request :get, "/api/v1/#{api_resource}/#{id}", params: params
       response = response.fetch(:data) if api_resource == "slo"
       response[:id] = response.delete(:public_id) if api_resource == "synthetics/tests"
-      response
+      self.class.tag(api_resource, response)
     end
 
     def list(api_resource, params = {})
@@ -32,7 +40,7 @@ module Kennel
         # ignore monitor synthetics create and that inherit the kennel_id, we do not directly manage them
         response.reject! { |m| m[:type] == "synthetics alert" } if api_resource == "monitor"
 
-        response
+        response.map { |r| self.class.tag(api_resource, r) }
       end
     end
 
@@ -40,13 +48,13 @@ module Kennel
       response = request :post, "/api/v1/#{api_resource}", body: attributes
       response = response.fetch(:data).first if api_resource == "slo"
       response[:id] = response.delete(:public_id) if api_resource == "synthetics/tests"
-      response
+      self.class.tag(api_resource, response)
     end
 
     def update(api_resource, id, attributes)
       response = request :put, "/api/v1/#{api_resource}/#{id}", body: attributes
       response[:id] = response.delete(:public_id) if api_resource == "synthetics/tests"
-      response
+      self.class.tag(api_resource, response)
     end
 
     # - force=true to not dead-lock on dependent monitors+slos

data/lib/kennel/attribute_differ.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "diff/lcs"
+
+module Kennel
+  class AttributeDiffer
+    def initialize
+      # min '2' because: -1 makes no sense, 0 does not work with * 2 math, 1 says '1 lines'
+      @max_diff_lines = [Integer(ENV.fetch("MAX_DIFF_LINES", "50")), 2].max
+      super
+    end
+
+    def format(type, field, old, new = nil)
+      multiline = false
+      if type == "+"
+        temp = pretty_inspect(new)
+        new = pretty_inspect(old)
+        old = temp
+      elsif old.is_a?(String) && new.is_a?(String) && (old.include?("\n") || new.include?("\n"))
+        multiline = true
+      else # ~ and -
+        old = pretty_inspect(old)
+        new = pretty_inspect(new)
+      end
+
+      message =
+        if multiline
+          "  #{type}#{field}\n" +
+            multiline_diff(old, new).map { |l| "    #{l}" }.join("\n")
+        elsif (old + new).size > 100
+          "  #{type}#{field}\n" \
+          "    #{old} ->\n" \
+          "    #{new}"
+        else
+          "  #{type}#{field} #{old} -> #{new}"
+        end
+
+      truncate(message)
+    end
+
+    private
+
+    # display diff for multi-line strings
+    # must stay readable when color is off too
+    def multiline_diff(old, new)
+      Diff::LCS.sdiff(old.split("\n", -1), new.split("\n", -1)).flat_map do |diff|
+        case diff.action
+        when "-"
+          Console.color(:red, "- #{diff.old_element}")
+        when "+"
+          Console.color(:green, "+ #{diff.new_element}")
+        when "!"
+          [
+            Console.color(:red, "- #{diff.old_element}"),
+            Console.color(:green, "+ #{diff.new_element}")
+          ]
+        else
+          "  #{diff.old_element}"
+        end
+      end
+    end
+
+    def truncate(message)
+      warning = Console.color(
+        :magenta,
+        "  (Diff for this item truncated after #{@max_diff_lines} lines. " \
+        "Rerun with MAX_DIFF_LINES=#{@max_diff_lines * 2} to see more)"
+      )
+      StringUtils.truncate_lines(message, to: @max_diff_lines, warning: warning)
+    end
+
+    # TODO: use awesome-print or similar, but it has too many monkey-patches
+    # https://github.com/amazing-print/amazing_print/issues/36
+    def pretty_inspect(object)
+      string = object.inspect.dup
+      string.gsub!(/:([a-z_]+)=>/, "\\1: ")
+      10.times do
+        string.gsub!(/{(\S.*?\S)}/, "{ \\1 }") || break
+      end
+      string
+    end
+  end
+end

data/lib/kennel/console.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module Kennel
+  module Console
+    COLORS = { red: 31, green: 32, yellow: 33, cyan: 36, magenta: 35, default: 0 }.freeze
+
+    class TeeIO < IO
+      def initialize(ios)
+        super(0) # called with fake file descriptor 0, so we can call super and get a proper class
+        @ios = ios
+      end
+
+      def write(string)
+        @ios.each { |io| io.write string }
+      end
+    end
+
+    class << self
+      def ask?(question)
+        Kennel.err.printf color(:red, "#{question} -  press 'y' to continue: ", force: true)
+        begin
+          STDIN.gets.chomp == "y"
+        rescue Interrupt # do not show a backtrace if user decides to Ctrl+C here
+          Kennel.err.print "\n"
+          exit 1
+        end
+      end
+
+      def color(color, text, force: false)
+        return text unless force || Kennel.out.tty?
+
+        "\e[#{COLORS.fetch(color)}m#{text}\e[0m"
+      end
+
+      def capture_stdout
+        old = Kennel.out
+        Kennel.out = StringIO.new
+        yield
+        Kennel.out.string
+      ensure
+        Kennel.out = old
+      end
+
+      def capture_stderr
+        old = Kennel.err
+        Kennel.err = StringIO.new
+        yield
+        Kennel.err.string
+      ensure
+        Kennel.err = old
+      end
+
+      def tee_output
+        old_stdout = Kennel.out
+        old_stderr = Kennel.err
+        capture = StringIO.new
+        Kennel.out = TeeIO.new([capture, Kennel.out])
+        Kennel.err = TeeIO.new([capture, Kennel.err])
+        yield
+        capture.string
+      ensure
+        Kennel.out = old_stdout
+        Kennel.err = old_stderr
+      end
+    end
+  end
+end

data/lib/kennel/github_reporter.rb

@@ -24,7 +24,7 @@ module Kennel
     end
 
     def report(&block)
-      output = Utils.tee_output(&block).strip
+      output = Console.tee_output(&block).strip
     rescue StandardError
       output = "Error:\n#{$ERROR_INFO.message}"
       raise

data/lib/kennel/importer.rb

@@ -33,7 +33,7 @@ module Kennel
           model.remove_tracking_id(data)
           tracking_id.split(":").last
         else
-          Kennel::Utils.parameterize(title)
+          Kennel::StringUtils.parameterize(title)
         end
 
       case resource
@@ -189,7 +189,7 @@ module Kennel
 
     # important to the front and rest deterministic
     def sort_hash(hash)
-      Hash[hash.sort_by { |k, _| [SORT_ORDER.index(k) || 999, k] }]
+      hash.sort_by { |k, _| [SORT_ORDER.index(k) || 999, k] }.to_h
     end
   end
 end

data/lib/kennel/models/base.rb

@@ -10,7 +10,7 @@ module Kennel
       SETTING_OVERRIDABLE_METHODS = [:name, :kennel_id].freeze
 
       def kennel_id
-        @kennel_id ||= Utils.snake_case kennel_id_base
+        @kennel_id ||= StringUtils.snake_case kennel_id_base
       end
 
       def name

data/lib/kennel/models/record.rb

@@ -35,8 +35,8 @@ module Kennel
         :klass, :tracking_id # added by syncer.rb
       ].freeze
       ALLOWED_KENNEL_ID_CHARS = "a-zA-Z_\\d.-"
-      ALLOWED_KENNEL_ID_FULL = "[#{ALLOWED_KENNEL_ID_CHARS}]+:[#{ALLOWED_KENNEL_ID_CHARS}]+"
-      ALLOWED_KENNEL_ID_REGEX = /\A#{ALLOWED_KENNEL_ID_FULL}\z/.freeze
+      ALLOWED_KENNEL_ID_FULL = "[#{ALLOWED_KENNEL_ID_CHARS}]+:[#{ALLOWED_KENNEL_ID_CHARS}]+".freeze
+      ALLOWED_KENNEL_ID_REGEX = /\A#{ALLOWED_KENNEL_ID_FULL}\z/
 
       settings :id, :kennel_id
 
@@ -52,7 +52,7 @@ module Kennel
         end
 
         def api_resource_map
-          subclasses.map { |s| [s.api_resource, s] }.to_h
+          subclasses.to_h { |s| [s.api_resource, s] }
         end
 
         def parse_tracking_id(a)
@@ -98,6 +98,8 @@ module Kennel
 
         self.class.send(:normalize, expected, actual)
 
+        return [] if actual == expected # Hashdiff is slow, this is fast
+
         # strict: ignore Integer vs Float
         # similarity: show diff when not 100% similar
         # use_lcs: saner output

data/lib/kennel/models/synthetic_test.rb

@@ -3,8 +3,7 @@ module Kennel
   module Models
     class SyntheticTest < Record
       TRACKING_FIELD = :message
-      DEFAULTS = {
-      }.freeze
+      DEFAULTS = {}.freeze
       READONLY_ATTRIBUTES = superclass::READONLY_ATTRIBUTES + [:status, :monitor_id]
       LOCATIONS = ["aws:ca-central-1", "aws:eu-north-1", "aws:eu-west-1", "aws:eu-west-3", "aws:eu-west-2", "aws:ap-south-1", "aws:us-west-2", "aws:us-west-1", "aws:sa-east-1", "aws:us-east-2", "aws:ap-northeast-1", "aws:ap-northeast-2", "aws:eu-central-1", "aws:ap-southeast-2", "aws:ap-southeast-1"].freeze
 

data/lib/kennel/parts_serializer.rb

@@ -8,13 +8,9 @@ module Kennel
 
     def write(parts)
       Progress.progress "Storing" do
-        if filter.tracking_id_filter
-          write_changed(parts)
-        else
-          old = old_paths
-          used = write_changed(parts)
-          (old - used).uniq.each { |p| FileUtils.rm_rf(p) }
-        end
+        existing = existing_files_and_folders
+        used = write_changed(parts)
+        FileUtils.rm_rf(existing - used)
       end
     end
 
@@ -26,31 +22,36 @@ module Kennel
       used = []
 
       Utils.parallel(parts, max: 2) do |part|
-        path = "generated/#{part.tracking_id.tr("/", ":").sub(":", "/")}.json"
+        path = path_for_tracking_id(part.tracking_id)
 
-        used << File.dirname(path) # only 1 level of sub folders, so this is enough
+        used << File.dirname(path) # we have 1 level of sub folders, so this is enough
         used << path
 
-        payload = part.as_json.merge(api_resource: part.class.api_resource)
-        write_file_if_necessary(path, JSON.pretty_generate(payload) << "\n")
+        content = part.as_json.merge(api_resource: part.class.api_resource)
+        write_file_if_necessary(path, content)
       end
 
       used
     end
 
-    def directories_to_clean_up
-      if filter.project_filter
-        filter.project_filter.map { |project| "generated/#{project}" }
+    def existing_files_and_folders
+      if filter.tracking_id_filter
+        filter.tracking_id_filter.map { |tracking_id| path_for_tracking_id(tracking_id) }
+      elsif filter.project_filter
+        filter.project_filter.flat_map { |project| Dir["generated/#{project}/*"] }
       else
-        ["generated"]
+        Dir["generated/**/*"] # also includes folders so we clean up empty directories
       end
     end
 
-    def old_paths
-      Dir["{#{directories_to_clean_up.join(",")}}/**/*"]
+    def path_for_tracking_id(tracking_id)
+      "generated/#{tracking_id.tr("/", ":").sub(":", "/")}.json"
     end
 
     def write_file_if_necessary(path, content)
+      # NOTE: always generating is faster than JSON.load-ing and comparing
+      content = JSON.pretty_generate(content) << "\n"
+
       # 99% case
       begin
         return if File.read(path) == content

data/lib/kennel/string_utils.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Kennel
+  module StringUtils
+    class << self
+      def snake_case(string)
+        string
+          .gsub(/::/, "_") # Foo::Bar -> foo_bar
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2') # FOOBar -> foo_bar
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2') # fooBar -> foo_bar
+          .tr("-", "_") # foo-bar -> foo_bar
+          .downcase
+      end
+
+      # for child projects, not used internally
+      def title_case(string)
+        string.split(/[\s_]/).map(&:capitalize) * " "
+      end
+
+      # simplified version of https://apidock.com/rails/ActiveSupport/Inflector/parameterize
+      def parameterize(string)
+        string
+          .downcase
+          .gsub(/[^a-z0-9\-_]+/, "-") # remove unsupported
+          .gsub(/-{2,}/, "-") # remove duplicates
+          .gsub(/^-|-$/, "") # remove leading/trailing
+      end
+
+      def truncate_lines(text, to:, warning:)
+        lines = text.split(/\n/, to + 1)
+        lines[-1] = warning if lines.size > to
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/kennel/syncer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "diff/lcs"
-
 module Kennel
   class Syncer
     DELETE_ORDER = ["dashboard", "slo", "monitor", "synthetics/tests"].freeze # dashboards references monitors + slos, slos reference monitors
@@ -10,41 +8,47 @@ module Kennel
     Plan = Struct.new(:changes, keyword_init: true)
     Change = Struct.new(:type, :api_resource, :tracking_id, :id)
 
-    def initialize(api, expected, actual, kennel:, project_filter: nil, tracking_id_filter: nil)
+    def initialize(api, expected, actual, strict_imports: true, project_filter: nil, tracking_id_filter: nil)
       @api = api
-      @kennel = kennel
+      @expected = Set.new expected # need Set to speed up deletion
+      @actual = actual
+      @strict_imports = strict_imports
       @project_filter = project_filter
       @tracking_id_filter = tracking_id_filter
-      @expected = Set.new expected # need set to speed up deletion
-      @actual = actual
-      calculate_diff
-      validate_plan
+
+      @attribute_differ = AttributeDiffer.new
+
+      calculate_changes
+      validate_changes
       prevent_irreversible_partial_updates
+
+      @warnings.each { |message| Kennel.out.puts Console.color(:yellow, "Warning: #{message}") }
     end
 
     def plan
-      Kennel.out.puts "Plan:"
-      if noop?
-        Kennel.out.puts Utils.color(:green, "Nothing to do")
-      else
-        @warnings.each { |message| Kennel.out.puts Utils.color(:yellow, "Warning: #{message}") }
-        print_plan "Create", @create, :green
-        print_plan "Update", @update, :yellow
-        print_plan "Delete", @delete, :red
-      end
-
       Plan.new(
         changes:
           @create.map { |_id, e, _a| Change.new(:create, e.class.api_resource, e.tracking_id, nil) } +
-          @update.map { |id, e, _a| Change.new(:update, e.class.api_resource, e.tracking_id, id) } +
-          @delete.map { |id, _e, a| Change.new(:delete, a.fetch(:klass).api_resource, a.fetch(:tracking_id), id) }
+            @update.map { |id, e, _a| Change.new(:update, e.class.api_resource, e.tracking_id, id) } +
+            @delete.map { |id, _e, a| Change.new(:delete, a.fetch(:klass).api_resource, a.fetch(:tracking_id), id) }
       )
     end
 
+    def print_plan
+      Kennel.out.puts "Plan:"
+      if noop?
+        Kennel.out.puts Console.color(:green, "Nothing to do")
+      else
+        print_changes "Create", @create, :green
+        print_changes "Update", @update, :yellow
+        print_changes "Delete", @delete, :red
+      end
+    end
+
     def confirm
       return false if noop?
       return true if ENV["CI"] || !STDIN.tty? || !Kennel.err.tty?
-      Utils.ask("Execute Plan ?")
+      Console.ask?("Execute Plan ?")
     end
 
     def update
@@ -54,7 +58,6 @@ module Kennel
         message = "#{e.class.api_resource} #{e.tracking_id}"
         Kennel.out.puts "Creating #{message}"
         reply = @api.create e.class.api_resource, e.as_json
-        Utils.inline_resource_metadata reply, e.class
         id = reply.fetch(:id)
         changes << Change.new(:create, e.class.api_resource, e.tracking_id, id)
         populate_id_map [], [reply] # allow resolving ids we could previously no resolve
@@ -83,8 +86,6 @@ module Kennel
 
     private
 
-    attr_reader :kennel
-
     # loop over items until everything is resolved or crash when we get stuck
     # this solves cases like composite monitors depending on each other or monitor->monitor slo->slo monitor chains
     def each_resolved(list)
@@ -120,58 +121,67 @@ module Kennel
       @create.empty? && @update.empty? && @delete.empty?
     end
 
-    def calculate_diff
+    def calculate_changes
       @warnings = []
-      @update = []
-      @delete = []
       @id_map = IdMap.new
 
       Progress.progress "Diffing" do
         populate_id_map @expected, @actual
         filter_actual! @actual
         resolve_linked_tracking_ids! @expected # resolve dependencies to avoid diff
+        @expected.each(&:add_tracking_id) # avoid diff with actual, which has tracking_id
 
-        @expected.each(&:add_tracking_id) # avoid diff with actual
+        # see which expected match the actual
+        matching, unmatched_expected, unmatched_actual = partition_matched_expected
+        validate_expected_id_not_missing unmatched_expected
+        fill_details! matching # need details to diff later
 
-        lookup_map = matching_expected_lookup_map
-        items = @actual.map do |a|
-          e = matching_expected(a, lookup_map)
-          if e && @expected.delete?(e)
-            [e, a]
-          else
-            [nil, a]
-          end
-        end
+        # update matching if needed
+        @update = matching.map do |e, a|
+          id = a.fetch(:id)
+          diff = e.diff(a)
+          [id, e, a, diff] if diff.any?
+        end.compact
 
-        # fill details of things we need to compare
-        details = items.map { |e, a| a if e && e.class.api_resource == "dashboard" }.compact
-        @api.fill_details! "dashboard", details
+        # delete previously managed
+        @delete = unmatched_actual.map { |a| [a.fetch(:id), nil, a] if a.fetch(:tracking_id) }.compact
 
-        # pick out things to update or delete
-        items.each do |e, a|
-          id = a.fetch(:id)
-          if e
-            diff = e.diff(a) # slow ...
-            if diff.any?
-              @update << [id, e, a, diff]
-            end
-          elsif a.fetch(:tracking_id) # was previously managed
-            @delete << [id, nil, a]
-          end
-        end
+        # unmatched expected need to be created
+        @create = unmatched_expected.map { |e| [nil, e] }
 
-        ensure_all_ids_found
-        @create = @expected.map { |e| [nil, e] }
+        # order to avoid deadlocks
         @delete.sort_by! { |_, _, a| DELETE_ORDER.index a.fetch(:klass).api_resource }
         @update.sort_by! { |_, e, _| DELETE_ORDER.index e.class.api_resource } # slo needs to come before slo alert
       end
     end
 
-    def ensure_all_ids_found
-      @expected.each do |e|
+    def partition_matched_expected
+      lookup_map = matching_expected_lookup_map
+      unmatched_expected = @expected.dup
+      unmatched_actual = []
+      matched = []
+      @actual.each do |a|
+        e = matching_expected(a, lookup_map)
+        if e && unmatched_expected.delete?(e)
+          matched << [e, a]
+        else
+          unmatched_actual << a
+        end
+      end.compact
+      [matched, unmatched_expected, unmatched_actual]
+    end
+
+    # fill details of things we need to compare
+    def fill_details!(details_needed)
+      details_needed = details_needed.map { |e, a| a if e && e.class.api_resource == "dashboard" }.compact
+      @api.fill_details! "dashboard", details_needed
+    end
+
+    def validate_expected_id_not_missing(expected)
+      expected.each do |e|
         next unless id = e.id
         resource = e.class.api_resource
-        if kennel.strict_imports
+        if @strict_imports
           raise "Unable to find existing #{resource} with id #{id}\nIf the #{resource} was deleted, remove the `id: -> { #{id} }` line."
         else
           @warnings << "#{resource} #{e.tracking_id} specifies id #{id}, but no such #{resource} exists. 'id' will be ignored. Remove the `id: -> { #{id} }` line."
@@ -196,79 +206,18 @@ module Kennel
       map["#{klass.api_resource}:#{a.fetch(:id)}"] || map[a.fetch(:tracking_id)]
     end
 
-    def print_plan(step, list, color)
+    def print_changes(step, list, color)
       return if list.empty?
       list.each do |_, e, a, diff|
         klass = (e ? e.class : a.fetch(:klass))
-        Kennel.out.puts Utils.color(color, "#{step} #{klass.api_resource} #{e&.tracking_id || a.fetch(:tracking_id)}")
-        print_diff(diff) if diff # only for update
-      end
-    end
-
-    def print_diff(diff)
-      diff.each do |type, field, old, new|
-        use_diff = false
-        if type == "+"
-          temp = Utils.pretty_inspect(new)
-          new = Utils.pretty_inspect(old)
-          old = temp
-        elsif old.is_a?(String) && new.is_a?(String) && (old.include?("\n") || new.include?("\n"))
-          use_diff = true
-        else # ~ and -
-          old = Utils.pretty_inspect(old)
-          new = Utils.pretty_inspect(new)
-        end
-
-        message =
-          if use_diff
-            "  #{type}#{field}\n" +
-              diff(old, new).map { |l| "    #{l}" }.join("\n")
-          elsif (old + new).size > 100
-            "  #{type}#{field}\n" \
-              "    #{old} ->\n" \
-              "    #{new}"
-          else
-            "  #{type}#{field} #{old} -> #{new}"
-          end
-
-        Kennel.out.puts truncate_diff(message)
-      end
-    end
-
-    # display diff for multi-line strings
-    # must stay readable when color is off too
-    def diff(old, new)
-      Diff::LCS.sdiff(old.split("\n", -1), new.split("\n", -1)).flat_map do |diff|
-        case diff.action
-        when "-"
-          Utils.color(:red, "- #{diff.old_element}")
-        when "+"
-          Utils.color(:green, "+ #{diff.new_element}")
-        when "!"
-          [
-            Utils.color(:red, "- #{diff.old_element}"),
-            Utils.color(:green, "+ #{diff.new_element}")
-          ]
-        else
-          "  #{diff.old_element}"
-        end
+        Kennel.out.puts Console.color(color, "#{step} #{klass.api_resource} #{e&.tracking_id || a.fetch(:tracking_id)}")
+        diff&.each { |args| Kennel.out.puts @attribute_differ.format(*args) } # only for update
       end
     end
 
-    def truncate_diff(message)
-      # min '2' because: -1 makes no sense, 0 does not work with * 2 math, 1 says '1 lines'
-      @max_diff_lines ||= [Integer(ENV.fetch("MAX_DIFF_LINES", "50")), 2].max
-      warning = Utils.color(
-        :magenta,
-        "  (Diff for this item truncated after #{@max_diff_lines} lines. " \
-          "Rerun with MAX_DIFF_LINES=#{@max_diff_lines * 2} to see more)"
-      )
-      Utils.truncate_lines(message, to: @max_diff_lines, warning: warning)
-    end
-
     # We've already validated the desired objects ('generated') in isolation.
     # Now that we have made the plan, we can perform some more validation.
-    def validate_plan
+    def validate_changes
       @update.each do |_, expected, actuals, diffs|
         expected.validate_update!(actuals, diffs)
       end
@@ -276,11 +225,10 @@ module Kennel
 
     # - do not add tracking-id when working with existing ids on a branch,
     #   so resource do not get deleted when running an update on master (for example merge->CI)
-    # - make sure the diff is clean, by kicking out the now noop-update
     # - ideally we'd never add tracking in the first place, but when adding tracking we do not know the diff yet
     def prevent_irreversible_partial_updates
-      return unless @project_filter
-      @update.select! do |_, e, _, diff|
+      return unless @project_filter # full update, so we are not on a branch
+      @update.select! do |_, e, _, diff| # ensure clean diff, by removing noop-update
         next true unless e.id # safe to add tracking when not having id
 
         diff.select! do |field_diff|
@@ -293,7 +241,7 @@ module Kennel
           actual != field_diff[3] # discard diff if now nothing changes
         end
 
-        !diff.empty?
+        diff.any?
       end
     end
 
@@ -321,7 +269,7 @@ module Kennel
           (!@tracking_id_filter || @tracking_id_filter.include?(tracking_id))
 
         @id_map.set(api_resource, tracking_id, a.fetch(:id))
-        if a[:klass].api_resource == "synthetics/tests"
+        if a.fetch(:klass).api_resource == "synthetics/tests"
           @id_map.set(Kennel::Models::Monitor.api_resource, tracking_id, a.fetch(:monitor_id))
         end
       end

data/lib/kennel/unmuted_alerts.rb

@@ -22,7 +22,7 @@ module Kennel
             m[:state][:groups].each do |g|
               color = COLORS[g[:status]] || :default
               since = "\t#{time_since(g[:last_triggered_ts])}"
-              Kennel.out.puts "#{Kennel::Utils.color(color, g[:status])}\t#{g[:name]}#{since}"
+              Kennel.out.puts "#{Kennel::Console.color(color, g[:status])}\t#{g[:name]}#{since}"
             end
             Kennel.out.puts
           end

data/lib/kennel/utils.rb

@@ -1,99 +1,11 @@
 # frozen_string_literal: true
 module Kennel
   module Utils
-    COLORS = { red: 31, green: 32, yellow: 33, cyan: 36, magenta: 35, default: 0 }.freeze
-
-    class TeeIO < IO
-      def initialize(ios)
-        @ios = ios
-      end
-
-      def write(string)
-        @ios.each { |io| io.write string }
-      end
-    end
-
     class << self
-      def snake_case(string)
-        string
-          .gsub(/::/, "_") # Foo::Bar -> foo_bar
-          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2') # FOOBar -> foo_bar
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2') # fooBar -> foo_bar
-          .tr("-", "_") # foo-bar -> foo_bar
-          .downcase
-      end
-
-      # for child projects, not used internally
-      def title_case(string)
-        string.split(/[\s_]/).map(&:capitalize) * " "
-      end
-
-      # simplified version of https://apidock.com/rails/ActiveSupport/Inflector/parameterize
-      def parameterize(string)
-        string
-          .downcase
-          .gsub(/[^a-z0-9\-_]+/, "-") # remove unsupported
-          .gsub(/-{2,}/, "-") # remove duplicates
-          .gsub(/^-|-$/, "") # remove leading/trailing
-      end
-
       def presence(value)
         value.nil? || value.empty? ? nil : value
       end
 
-      def ask(question)
-        Kennel.err.printf color(:red, "#{question} -  press 'y' to continue: ", force: true)
-        begin
-          STDIN.gets.chomp == "y"
-        rescue Interrupt # do not show a backtrace if user decides to Ctrl+C here
-          Kennel.err.print "\n"
-          exit 1
-        end
-      end
-
-      def color(color, text, force: false)
-        return text unless force || Kennel.out.tty?
-
-        "\e[#{COLORS.fetch(color)}m#{text}\e[0m"
-      end
-
-      def truncate_lines(text, to:, warning:)
-        lines = text.split(/\n/, to + 1)
-        lines[-1] = warning if lines.size > to
-        lines.join("\n")
-      end
-
-      def capture_stdout
-        old = Kennel.out
-        Kennel.out = StringIO.new
-        yield
-        Kennel.out.string
-      ensure
-        Kennel.out = old
-      end
-
-      def capture_stderr
-        old = Kennel.err
-        Kennel.err = StringIO.new
-        yield
-        Kennel.err.string
-      ensure
-        Kennel.err = old
-      end
-
-      def tee_output
-        old_stdout = Kennel.out
-        old_stderr = Kennel.err
-        capture = StringIO.new
-        Kennel.out = TeeIO.new([capture, Kennel.out])
-        Kennel.err = TeeIO.new([capture, Kennel.err])
-        yield
-        capture.string
-      ensure
-        Kennel.out = old_stdout
-        Kennel.err = old_stderr
-      end
-
       def capture_sh(command)
         result = `#{command} 2>&1`
         raise "Command failed:\n#{command}\n#{result}" unless $CHILD_STATUS.success?
@@ -149,22 +61,6 @@ module Kennel
         else []
         end
       end
-
-      # TODO: use awesome-print or similar, but it has too many monkey-patches
-      # https://github.com/amazing-print/amazing_print/issues/36
-      def pretty_inspect(object)
-        string = object.inspect.dup
-        string.gsub!(/:([a-z_]+)=>/, "\\1: ")
-        10.times do
-          string.gsub!(/{(\S.*?\S)}/, "{ \\1 }") || break
-        end
-        string
-      end
-
-      def inline_resource_metadata(resource, klass)
-        resource[:klass] = klass
-        resource[:tracking_id] = klass.parse_tracking_id(resource)
-      end
     end
   end
 end

data/lib/kennel/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Kennel
-  VERSION = "1.128.0"
+  VERSION = "1.130.0"
 end

data/lib/kennel.rb

@@ -5,11 +5,14 @@ require "zeitwerk"
 require "English"
 
 require "kennel/version"
+require "kennel/console"
+require "kennel/string_utils"
 require "kennel/utils"
 require "kennel/progress"
 require "kennel/filter"
 require "kennel/parts_serializer"
 require "kennel/projects_provider"
+require "kennel/attribute_differ"
 require "kennel/syncer"
 require "kennel/id_map"
 require "kennel/api"
@@ -42,7 +45,6 @@ module Kennel
   UnresolvableIdError = Class.new(StandardError)
   DisallowedUpdateError = Class.new(StandardError)
   GenerationAbortedError = Class.new(StandardError)
-  UpdateResult = Struct.new(:plan, :update, keyword_init: true)
 
   class << self
     attr_accessor :out, :err
@@ -52,12 +54,12 @@ module Kennel
   self.err = $stderr
 
   class Engine
+    attr_accessor :strict_imports
+
     def initialize
       @strict_imports = true
     end
 
-    attr_accessor :strict_imports
-
     # start generation and download in parallel to make planning faster
     def preload
       Utils.parallel([:generated, :definitions]) { |m| send m, plain: true }
@@ -65,16 +67,17 @@ module Kennel
 
     def generate
       parts = generated
-      parts_serializer.write(parts) if ENV["STORE"] != "false" # quicker when debugging
+      PartsSerializer.new(filter: filter).write(parts) if ENV["STORE"] != "false" # quicker when debugging
       parts
     end
 
     def plan
+      syncer.print_plan
       syncer.plan
     end
 
     def update
-      syncer.plan
+      syncer.print_plan
       syncer.update if syncer.confirm
     end
 
@@ -87,7 +90,12 @@ module Kennel
     def syncer
       @syncer ||= begin
         preload
-        Syncer.new(api, generated, definitions, kennel: self, project_filter: filter.project_filter, tracking_id_filter: filter.tracking_id_filter)
+        Syncer.new(
+          api, generated, definitions,
+          strict_imports: strict_imports,
+          project_filter: filter.project_filter,
+          tracking_id_filter: filter.tracking_id_filter
+        )
       end
     end
 
@@ -95,18 +103,10 @@ module Kennel
       @api ||= Api.new
     end
 
-    def projects_provider
-      @projects_provider ||= ProjectsProvider.new
-    end
-
-    def parts_serializer
-      @parts_serializer ||= PartsSerializer.new(filter: filter)
-    end
-
     def generated(**kwargs)
       @generated ||= begin
         parts = Progress.progress "Finding parts", **kwargs do
-          projects = projects_provider.projects
+          projects = ProjectsProvider.new.projects
           projects = filter.filter_projects projects
 
           parts = Utils.parallel(projects, &:validated_parts).flatten(1)
@@ -135,8 +135,7 @@ module Kennel
     def definitions(**kwargs)
       @definitions ||= Progress.progress("Downloading definitions", **kwargs) do
         Utils.parallel(Models::Record.subclasses) do |klass|
-          results = api.list(klass.api_resource, with_downtimes: false) # lookup monitors without adding unnecessary downtime information
-          results.each { |a| Utils.inline_resource_metadata(a, klass) }
+          api.list(klass.api_resource, with_downtimes: false) # lookup monitors without adding unnecessary downtime information
         end.flatten(1)
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 1.128.0
+  version: 1.130.0
 platform: ruby
 authors:
 - Michael Grosser
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-06 00:00:00.000000000 Z
+date: 2022-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -80,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
-description: 
+description:
 email: michael@grosser.it
 executables: []
 extensions: []
@@ -89,6 +89,8 @@ files:
 - Readme.md
 - lib/kennel.rb
 - lib/kennel/api.rb
+- lib/kennel/attribute_differ.rb
+- lib/kennel/console.rb
 - lib/kennel/file_cache.rb
 - lib/kennel/filter.rb
 - lib/kennel/github_reporter.rb
@@ -107,6 +109,7 @@ files:
 - lib/kennel/progress.rb
 - lib/kennel/projects_provider.rb
 - lib/kennel/settings_as_methods.rb
+- lib/kennel/string_utils.rb
 - lib/kennel/subclass_tracking.rb
 - lib/kennel/syncer.rb
 - lib/kennel/tasks.rb
@@ -119,7 +122,7 @@ homepage: https://github.com/grosser/kennel
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -127,15 +130,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Keep datadog monitors/dashboards/etc in version control, avoid chaotic management
   via UI