kennel 1.131.0 → 1.133.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac3eeb3c1ec0e2b03c7acbf2b2d7c68335207a7e79408775e9b876c6c4acd400
-  data.tar.gz: db96fddb04bce543efcea1a505a1d360447161259e9e9fdd481acfe785bad194
+  metadata.gz: d3aff9df6291b4831989719092533b91416db67398fbd2f8b43d694ce2a758c6
+  data.tar.gz: 316279b5d6059c65281322e8d0dae8caeac665a48bba70c377c218febfd76fb9
 SHA512:
-  metadata.gz: a710b2e2ae6932cf36bdd12fbb06c34f8b538944e693a484b294e7614b7d9941e7c2da498cf7cdcb56bda255a0b2c874383306437ee5b71456d900ae1e9a5c2f
-  data.tar.gz: 90e767722863bb640f3bd96436937c390d40d8c8b868d3ee51a444ff6e042e36f03048cc1b5c9cec49d96207d53d99df6f529318658c3881fd9078ed55c2b7d8
+  metadata.gz: f54f29018a039ee2b5d8bf4bfb05b371af4551c102a0f349463faa6a380873b387d5f8229460bb6b991d30a21cd2cdbb14765c43400e983bc74d13822467d7bf
+  data.tar.gz: c893a9caa3a122f454cf7f654c4583df3397c985fa230f06ff9fcdaec07fb90b89be43a363eb5911483aad6bf9699971ea0664dcc0e4758fb61e833bce587008

data/lib/kennel/filter.rb

@@ -2,8 +2,6 @@
 
 module Kennel
   class Filter
-    attr_reader :project_filter, :tracking_id_filter
-
     def initialize
       # build early so we fail fast on invalid user input
       @tracking_id_filter = build_tracking_id_filter
@@ -18,8 +16,25 @@ module Kennel
       filter_resources(parts, :tracking_id, tracking_id_filter, "resources", "TRACKING_ID")
     end
 
+    def filtering?
+      !project_filter.nil?
+    end
+
+    def matches_project_id?(project_id)
+      !filtering? || project_filter.include?(project_id)
+    end
+
+    def matches_tracking_id?(tracking_id)
+      return true unless filtering?
+      return tracking_id_filter.include?(tracking_id) if tracking_id_filter
+
+      project_filter.include?(tracking_id.split(":").first)
+    end
+
     private
 
+    attr_reader :project_filter, :tracking_id_filter
+
     def build_project_filter
       project_names = ENV["PROJECT"]&.split(",")&.sort&.uniq
       tracking_project_names = tracking_id_filter&.map { |id| id.split(":", 2).first }&.sort&.uniq

data/lib/kennel/models/monitor.rb

@@ -22,7 +22,8 @@ module Kennel
         notify_audit: false,
         no_data_timeframe: nil, # this works out ok since if notify_no_data is on, it would never be nil
         groupby_simple_monitor: false,
-        variables: nil
+        variables: nil,
+        on_missing_data: "default"
       }.freeze
       DEFAULT_ESCALATION_MESSAGE = ["", nil].freeze
       ALLOWED_PRIORITY_CLASSES = [NilClass, Integer].freeze
@@ -31,7 +32,7 @@ module Kennel
       settings(
         :query, :name, :message, :escalation_message, :critical, :type, :renotify_interval, :warning, :timeout_h, :evaluation_delay,
         :ok, :no_data_timeframe, :notify_no_data, :notify_audit, :tags, :critical_recovery, :warning_recovery, :require_full_window,
-        :threshold_windows, :new_host_delay, :new_group_delay, :priority, :validate_using_links, :variables
+        :threshold_windows, :new_host_delay, :new_group_delay, :priority, :validate_using_links, :variables, :on_missing_data
       )
 
       defaults(
@@ -52,7 +53,8 @@ module Kennel
         warning_recovery: -> { nil },
         threshold_windows: -> { nil },
         priority: -> { MONITOR_DEFAULTS.fetch(:priority) },
-        variables: -> { MONITOR_OPTION_DEFAULTS.fetch(:variables) }
+        variables: -> { MONITOR_OPTION_DEFAULTS.fetch(:variables) },
+        on_missing_data: -> { notify_no_data ? "show_and_notify_no_data" : "default" } # "default" is "evaluate as zero"
       )
 
       def build_json
@@ -123,6 +125,13 @@ module Kennel
           options[:renotify_statuses] = statuses
         end
 
+        # for events: on_missing_data cannot be used with notify_no_data or no_data_timeframe
+        if data.fetch(:type) == "event-v2 alert"
+          options[:on_missing_data] = on_missing_data
+          options[:notify_no_data] = false # cannot set nil or it's an endless update loop
+          options.delete :no_data_timeframe
+        end
+
         data
       end
 

data/lib/kennel/models/record.rb

@@ -35,7 +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}]+".freeze
+      ALLOWED_KENNEL_ID_SEGMENT = /[#{ALLOWED_KENNEL_ID_CHARS}]+/
+      ALLOWED_KENNEL_ID_FULL = "#{ALLOWED_KENNEL_ID_SEGMENT}:#{ALLOWED_KENNEL_ID_SEGMENT}".freeze
       ALLOWED_KENNEL_ID_REGEX = /\A#{ALLOWED_KENNEL_ID_FULL}\z/
 
       settings :id, :kennel_id

data/lib/kennel/parts_serializer.rb

@@ -35,13 +35,16 @@ module Kennel
     end
 
     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
-        Dir["generated/**/*"] # also includes folders so we clean up empty directories
+      paths = Dir["generated/**/*"]
+
+      if filter.filtering?
+        paths.select! do |path|
+          tracking_id = path.split("/")[1..2].to_a.join(":")
+          filter.matches_tracking_id?(tracking_id)
+        end
       end
+
+      paths
     end
 
     def path_for_tracking_id(tracking_id)

data/lib/kennel/syncer/matched_expected.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kennel
+  class Syncer
+    module MatchedExpected
+      class << self
+        def partition(expected, actual)
+          lookup_map = matching_expected_lookup_map(expected)
+          unmatched_expected = Set.new(expected) # for efficient deletion
+          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.to_a, unmatched_actual]
+        end
+
+        private
+
+        # index list by all the thing we look up by: tracking id and actual id
+        def matching_expected_lookup_map(expected)
+          expected.each_with_object({}) do |e, all|
+            keys = [e.tracking_id]
+            keys << "#{e.class.api_resource}:#{e.id}" if e.id
+            keys.compact.each do |key|
+              raise "Lookup #{key} is duplicated" if all[key]
+              all[key] = e
+            end
+          end
+        end
+
+        def matching_expected(a, map)
+          klass = a.fetch(:klass)
+          map["#{klass.api_resource}:#{a.fetch(:id)}"] || map[a.fetch(:tracking_id)]
+        end
+      end
+    end
+  end
+end

data/lib/kennel/syncer/plan_displayer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kennel
+  class Syncer
+    class PlanDisplayer
+      def initialize
+        @attribute_differ = AttributeDiffer.new
+      end
+
+      def display(internal_plan)
+        Kennel.out.puts "Plan:"
+        if internal_plan.empty?
+          Kennel.out.puts Console.color(:green, "Nothing to do")
+        else
+          print_changes "Create", internal_plan.creates, :green
+          print_changes "Update", internal_plan.updates, :yellow
+          print_changes "Delete", internal_plan.deletes, :red
+        end
+      end
+
+      private
+
+      def print_changes(step, list, color)
+        return if list.empty?
+        list.each do |item|
+          Kennel.out.puts Console.color(color, "#{step} #{item.api_resource} #{item.tracking_id}")
+          if item.class::TYPE == :update
+            item.diff.each { |args| Kennel.out.puts @attribute_differ.format(*args) } # only for update
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kennel/syncer/resolver.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../id_map"
+
+module Kennel
+  class Syncer
+    class Resolver
+      def initialize(expected:, filter:)
+        @id_map = IdMap.new
+        @filter = filter
+
+        # mark everything as new
+        expected.each do |e|
+          id_map.set(e.class.api_resource, e.tracking_id, IdMap::NEW)
+          if e.class.api_resource == "synthetics/tests"
+            id_map.set(Kennel::Models::Monitor.api_resource, e.tracking_id, IdMap::NEW)
+          end
+        end
+      end
+
+      def add_actual(actual)
+        # override resources that exist with their id
+        actual.each do |a|
+          # ignore when not managed by kennel
+          next unless tracking_id = a.fetch(:tracking_id)
+
+          # ignore when deleted from the codebase
+          # (when running with filters we cannot see the other resources in the codebase)
+          api_resource = a.fetch(:klass).api_resource
+          next if !id_map.get(api_resource, tracking_id) && filter.matches_tracking_id?(tracking_id)
+
+          id_map.set(api_resource, tracking_id, a.fetch(:id))
+          if a.fetch(:klass).api_resource == "synthetics/tests"
+            id_map.set(Kennel::Models::Monitor.api_resource, tracking_id, a.fetch(:monitor_id))
+          end
+        end
+      end
+
+      def resolve_as_much_as_possible(expected)
+        expected.each do |e|
+          e.resolve_linked_tracking_ids!(id_map, force: false)
+        end
+      end
+
+      # 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)
+        list = list.dup
+        loop do
+          return if list.empty?
+          list.reject! do |item|
+            if resolved?(item.expected)
+              yield item
+              true
+            else
+              false
+            end
+          end ||
+            assert_resolved(list[0].expected) # resolve something or show a circular dependency error
+        end
+      end
+
+      private
+
+      attr_reader :id_map, :filter
+
+      # TODO: optimize by storing an instance variable if already resolved
+      def resolved?(e)
+        assert_resolved e
+        true
+      rescue UnresolvableIdError
+        false
+      end
+
+      # raises UnresolvableIdError when not resolved
+      def assert_resolved(e)
+        e.resolve_linked_tracking_ids!(id_map, force: true)
+      end
+    end
+  end
+end

data/lib/kennel/syncer/types.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Kennel
+  class Syncer
+    module Types
+      class PlannedChange
+        def initialize(klass, tracking_id)
+          @klass = klass
+          @tracking_id = tracking_id
+        end
+
+        def api_resource
+          klass.api_resource
+        end
+
+        def url(id = nil)
+          klass.url(id || self.id)
+        end
+
+        def change(id = nil)
+          Change.new(self.class::TYPE, api_resource, tracking_id, id)
+        end
+
+        attr_reader :klass, :tracking_id
+      end
+
+      class PlannedCreate < PlannedChange
+        TYPE = :create
+
+        def initialize(expected)
+          super(expected.class, expected.tracking_id)
+          @expected = expected
+        end
+
+        attr_reader :expected
+      end
+
+      class PlannedUpdate < PlannedChange
+        TYPE = :update
+
+        def initialize(expected, actual, diff)
+          super(expected.class, expected.tracking_id)
+          @expected = expected
+          @actual = actual
+          @diff = diff
+          @id = actual.fetch(:id)
+        end
+
+        def change
+          super(id)
+        end
+
+        attr_reader :expected, :actual, :diff, :id
+      end
+
+      class PlannedDelete < PlannedChange
+        TYPE = :delete
+
+        def initialize(actual)
+          super(actual.fetch(:klass), actual.fetch(:tracking_id))
+          @actual = actual
+          @id = actual.fetch(:id)
+        end
+
+        def change
+          super(id)
+        end
+
+        attr_reader :actual, :id
+      end
+    end
+  end
+end

data/lib/kennel/syncer.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "./syncer/matched_expected"
+require_relative "./syncer/plan_displayer"
+require_relative "./syncer/resolver"
+require_relative "./syncer/types"
+
 module Kennel
   class Syncer
     DELETE_ORDER = ["dashboard", "slo", "monitor", "synthetics/tests"].freeze # dashboards references monitors + slos, slos reference monitors
@@ -15,13 +20,12 @@ module Kennel
 
     Change = Struct.new(:type, :api_resource, :tracking_id, :id)
 
-    def initialize(api, expected, actual, strict_imports: true, project_filter: nil, tracking_id_filter: nil)
+    def initialize(api, expected, actual, filter:, strict_imports: true)
       @api = api
       @strict_imports = strict_imports
-      @project_filter = project_filter
-      @tracking_id_filter = tracking_id_filter
+      @filter = filter
 
-      @resolver = Resolver.new(expected: expected, project_filter: @project_filter, tracking_id_filter: @tracking_id_filter)
+      @resolver = Resolver.new(expected: expected, filter: filter)
 
       internal_plan = calculate_changes(expected: expected, actual: actual)
       validate_changes(internal_plan)
@@ -81,7 +85,7 @@ module Kennel
 
     private
 
-    attr_reader :resolver, :internal_plan
+    attr_reader :filter, :resolver, :internal_plan
 
     def calculate_changes(expected:, actual:)
       @warnings = []
@@ -101,7 +105,7 @@ module Kennel
           # Refuse to "adopt" existing items into kennel while running with a filter (i.e. on a branch).
           # Without this, we'd adopt an item, then the next CI run would delete it
           # (instead of "unadopting" it).
-          e.add_tracking_id unless @project_filter && a.fetch(:tracking_id).nil?
+          e.add_tracking_id unless filter.filtering? && a.fetch(:tracking_id).nil?
           id = a.fetch(:id)
           diff = e.diff(a)
           a[:id] = id
@@ -150,233 +154,11 @@ module Kennel
     end
 
     def filter_actual!(actual)
-      if @tracking_id_filter
-        actual.select! do |a|
-          tracking_id = a.fetch(:tracking_id)
-          !tracking_id || @tracking_id_filter.include?(tracking_id)
-        end
-      elsif @project_filter
-        project_prefixes = @project_filter.map { |p| "#{p}:" }
-        actual.select! do |a|
-          tracking_id = a.fetch(:tracking_id)
-          !tracking_id || tracking_id.start_with?(*project_prefixes)
-        end
-      end
-    end
-
-    class PlanDisplayer
-      def initialize
-        @attribute_differ = AttributeDiffer.new
-      end
-
-      def display(internal_plan)
-        Kennel.out.puts "Plan:"
-        if internal_plan.empty?
-          Kennel.out.puts Console.color(:green, "Nothing to do")
-        else
-          print_changes "Create", internal_plan.creates, :green
-          print_changes "Update", internal_plan.updates, :yellow
-          print_changes "Delete", internal_plan.deletes, :red
-        end
-      end
-
-      private
-
-      def print_changes(step, list, color)
-        return if list.empty?
-        list.each do |item|
-          Kennel.out.puts Console.color(color, "#{step} #{item.api_resource} #{item.tracking_id}")
-          if item.class::TYPE == :update
-            item.diff.each { |args| Kennel.out.puts @attribute_differ.format(*args) } # only for update
-          end
-        end
-      end
-    end
-
-    class Resolver
-      def initialize(expected:, project_filter:, tracking_id_filter:)
-        @id_map = IdMap.new
-        @project_filter = project_filter
-        @tracking_id_filter = tracking_id_filter
-
-        # mark everything as new
-        expected.each do |e|
-          id_map.set(e.class.api_resource, e.tracking_id, IdMap::NEW)
-          if e.class.api_resource == "synthetics/tests"
-            id_map.set(Kennel::Models::Monitor.api_resource, e.tracking_id, IdMap::NEW)
-          end
-        end
-      end
-
-      def add_actual(actual)
-        # override resources that exist with their id
-        project_prefixes = project_filter&.map { |p| "#{p}:" }
-
-        actual.each do |a|
-          # ignore when not managed by kennel
-          next unless tracking_id = a.fetch(:tracking_id)
-
-          # ignore when deleted from the codebase
-          # (when running with filters we cannot see the other resources in the codebase)
-          api_resource = a.fetch(:klass).api_resource
-          next if
-            !id_map.get(api_resource, tracking_id) &&
-            (!project_prefixes || tracking_id.start_with?(*project_prefixes)) &&
-            (!tracking_id_filter || tracking_id_filter.include?(tracking_id))
-
-          id_map.set(api_resource, tracking_id, a.fetch(:id))
-          if a.fetch(:klass).api_resource == "synthetics/tests"
-            id_map.set(Kennel::Models::Monitor.api_resource, tracking_id, a.fetch(:monitor_id))
-          end
-        end
-      end
-
-      def resolve_as_much_as_possible(expected)
-        expected.each do |e|
-          e.resolve_linked_tracking_ids!(id_map, force: false)
-        end
-      end
-
-      # 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)
-        list = list.dup
-        loop do
-          return if list.empty?
-          list.reject! do |item|
-            if resolved?(item.expected)
-              yield item
-              true
-            else
-              false
-            end
-          end ||
-            assert_resolved(list[0].expected) # resolve something or show a circular dependency error
-        end
-      end
-
-      private
-
-      attr_reader :id_map, :project_filter, :tracking_id_filter
-
-      # TODO: optimize by storing an instance variable if already resolved
-      def resolved?(e)
-        assert_resolved e
-        true
-      rescue UnresolvableIdError
-        false
-      end
-
-      # raises UnresolvableIdError when not resolved
-      def assert_resolved(e)
-        e.resolve_linked_tracking_ids!(id_map, force: true)
-      end
-    end
-
-    module MatchedExpected
-      class << self
-        def partition(expected, actual)
-          lookup_map = matching_expected_lookup_map(expected)
-          unmatched_expected = Set.new(expected) # for efficient deletion
-          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.to_a, unmatched_actual]
-        end
-
-        private
-
-        # index list by all the thing we look up by: tracking id and actual id
-        def matching_expected_lookup_map(expected)
-          expected.each_with_object({}) do |e, all|
-            keys = [e.tracking_id]
-            keys << "#{e.class.api_resource}:#{e.id}" if e.id
-            keys.compact.each do |key|
-              raise "Lookup #{key} is duplicated" if all[key]
-              all[key] = e
-            end
-          end
-        end
-
-        def matching_expected(a, map)
-          klass = a.fetch(:klass)
-          map["#{klass.api_resource}:#{a.fetch(:id)}"] || map[a.fetch(:tracking_id)]
-        end
-      end
-    end
-
-    module Types
-      class PlannedChange
-        def initialize(klass, tracking_id)
-          @klass = klass
-          @tracking_id = tracking_id
-        end
-
-        def api_resource
-          klass.api_resource
-        end
-
-        def url(id = nil)
-          klass.url(id || self.id)
-        end
-
-        def change(id = nil)
-          Change.new(self.class::TYPE, api_resource, tracking_id, id)
-        end
-
-        attr_reader :klass, :tracking_id
-      end
-
-      class PlannedCreate < PlannedChange
-        TYPE = :create
-
-        def initialize(expected)
-          super(expected.class, expected.tracking_id)
-          @expected = expected
-        end
-
-        attr_reader :expected
-      end
-
-      class PlannedUpdate < PlannedChange
-        TYPE = :update
-
-        def initialize(expected, actual, diff)
-          super(expected.class, expected.tracking_id)
-          @expected = expected
-          @actual = actual
-          @diff = diff
-          @id = actual.fetch(:id)
-        end
-
-        def change
-          super(id)
-        end
-
-        attr_reader :expected, :actual, :diff, :id
-      end
-
-      class PlannedDelete < PlannedChange
-        TYPE = :delete
-
-        def initialize(actual)
-          super(actual.fetch(:klass), actual.fetch(:tracking_id))
-          @actual = actual
-          @id = actual.fetch(:id)
-        end
-
-        def change
-          super(id)
-        end
+      return unless filter.filtering? # minor optimization
 
-        attr_reader :actual, :id
+      actual.select! do |a|
+        tracking_id = a.fetch(:tracking_id)
+        tracking_id.nil? || filter.matches_tracking_id?(tracking_id)
       end
     end
   end

data/lib/kennel/version.rb

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

data/lib/kennel.rb

@@ -92,9 +92,8 @@ module Kennel
         preload
         Syncer.new(
           api, generated, definitions,
-          strict_imports: strict_imports,
-          project_filter: filter.project_filter,
-          tracking_id_filter: filter.tracking_id_filter
+          filter: filter,
+          strict_imports: strict_imports
         )
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 1.131.0
+  version: 1.133.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-09 00:00:00.000000000 Z
+date: 2023-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -112,6 +112,10 @@ files:
 - lib/kennel/string_utils.rb
 - lib/kennel/subclass_tracking.rb
 - lib/kennel/syncer.rb
+- lib/kennel/syncer/matched_expected.rb
+- lib/kennel/syncer/plan_displayer.rb
+- lib/kennel/syncer/resolver.rb
+- lib/kennel/syncer/types.rb
 - lib/kennel/tasks.rb
 - lib/kennel/template_variables.rb
 - lib/kennel/unmuted_alerts.rb