kennel 2.2.1 → 2.22.0

data/lib/kennel/models/monitor.rb

@@ -6,7 +6,8 @@ module Kennel
 
       OPTIONAL_SERVICE_CHECK_THRESHOLDS = [:ok, :warning].freeze
       READONLY_ATTRIBUTES = superclass::READONLY_ATTRIBUTES + [
-        :multi, :matching_downtimes, :overall_state_modified, :overall_state, :restricted_roles, :draft_status
+        :multi, :matching_downtimes, :overall_state_modified, :overall_state, :restricted_roles, :draft_status, :assets,
+        :enable_logs_sample
       ]
       TRACKING_FIELD = :message
 
@@ -25,19 +26,27 @@ module Kennel
         group_retention_duration: nil,
         groupby_simple_monitor: false,
         variables: nil,
-        on_missing_data: "default", # "default" is "evaluate as zero"
+        on_missing_data: nil,
         notification_preset_name: nil,
-        notify_by: nil
+        notify_by: nil,
+        include_tags: true
       }.freeze
       DEFAULT_ESCALATION_MESSAGE = ["", nil].freeze
       ALLOWED_PRIORITY_CLASSES = [NilClass, Integer].freeze
       SKIP_NOTIFY_NO_DATA_TYPES = ["event alert", "event-v2 alert", "log alert"].freeze
+      ON_MISSING_DATA_UNSUPPORTED_TYPES = ["composite", "datadog-usage alert"].freeze
+      MINUTES_PER_UNIT = {
+        "m" => 1,
+        "h" => 60,
+        "d" => 60 * 24,
+        "w" => 60 * 24 * 7
+      }.freeze
 
       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, :scheduling_options, :new_host_delay, :new_group_delay, :group_retention_duration, :priority,
-        :variables, :on_missing_data, :notification_preset_name, :notify_by
+        :variables, :on_missing_data, :notification_preset_name, :notify_by, :include_tags
       )
 
       defaults(
@@ -49,13 +58,12 @@ module Kennel
         # datadog UI sets this to false by default, but true is safer
         # except for log alerts which will always have "no error" gaps and should default to false
         notify_no_data: -> { !SKIP_NOTIFY_NO_DATA_TYPES.include?(type) },
-        no_data_timeframe: -> { 60 },
+        no_data_timeframe: -> { MONITOR_OPTION_DEFAULTS.fetch(:no_data_timeframe) },
         notify_audit: -> { MONITOR_OPTION_DEFAULTS.fetch(:notify_audit) },
         new_host_delay: -> { MONITOR_OPTION_DEFAULTS.fetch(:new_host_delay) },
         new_group_delay: -> { nil },
         group_retention_duration: -> { MONITOR_OPTION_DEFAULTS.fetch(:group_retention_duration) },
         tags: -> { @project.tags },
-        timeout_h: -> { MONITOR_OPTION_DEFAULTS.fetch(:timeout_h) },
         evaluation_delay: -> { MONITOR_OPTION_DEFAULTS.fetch(:evaluation_delay) },
         critical_recovery: -> { nil },
         warning_recovery: -> { nil },
@@ -66,10 +74,13 @@ module Kennel
         on_missing_data: -> { MONITOR_OPTION_DEFAULTS.fetch(:on_missing_data) },
         notification_preset_name: -> { MONITOR_OPTION_DEFAULTS.fetch(:notification_preset_name) },
         notify_by: -> { MONITOR_OPTION_DEFAULTS.fetch(:notify_by) },
-        require_full_window: -> { false }
+        require_full_window: -> { false },
+        include_tags: -> { MONITOR_OPTION_DEFAULTS.fetch(:include_tags) }
       )
 
       def build_json
+        no_data_options = configure_no_data
+
         data = super.merge(
           name: "#{name}#{LOCK}",
           type: type,
@@ -79,42 +90,22 @@ module Kennel
           priority: priority,
           options: {
             timeout_h: timeout_h,
-            notify_no_data: notify_no_data,
-            no_data_timeframe: notify_no_data ? no_data_timeframe : nil,
+            **no_data_options.except(:on_missing_data),
             notify_audit: notify_audit,
             require_full_window: require_full_window,
             new_host_delay: new_host_delay,
             new_group_delay: new_group_delay,
-            include_tags: true,
+            include_tags: include_tags,
             escalation_message: Utils.presence(escalation_message.strip),
             evaluation_delay: evaluation_delay,
-            locked: false, # deprecated: setting this to true will likely fail
             renotify_interval: renotify_interval || 0,
-            variables: variables
+            variables: variables,
+            **configure_thresholds,
+            **no_data_options.slice(:on_missing_data) # moved here to avoid generated diff
           }
         )
 
         options = data[:options]
-        if data.fetch(:type) != "composite"
-          thresholds = (options[:thresholds] = { critical: critical })
-
-          # warning, ok, critical_recovery, and warning_recovery are optional
-          [:warning, :ok, :critical_recovery, :warning_recovery].each do |key|
-            if (value = send(key))
-              thresholds[key] = value
-            end
-          end
-
-          thresholds[:critical] = critical unless
-          case data.fetch(:type)
-          when "service check"
-            # avoid diff for default values of 1
-            OPTIONAL_SERVICE_CHECK_THRESHOLDS.each { |t| thresholds[t] ||= 1 }
-          when "query alert"
-            # metric and query values are stored as float by datadog
-            thresholds.each { |k, v| thresholds[k] = Float(v) }
-          end
-        end
 
         # set without causing lots of nulls to be stored
         if (notify_by_value = notify_by)
@@ -145,30 +136,54 @@ module Kennel
         # Add in statuses where we would re notify on. Possible values: alert, no data, warn
         if options[:renotify_interval] != 0
           statuses = ["alert"]
-          statuses << "no data" if options[:notify_no_data]
+          statuses << "no data" if options[:notify_no_data] || options[:on_missing_data] == "show_and_notify_no_data"
           statuses << "warn" if options.dig(:thresholds, :warning)
           options[:renotify_statuses] = statuses
         end
 
-        # on_missing_data cannot be used with notify_no_data or no_data_timeframe
-        # TODO migrate everything to only use on_missing_data
-        if data.fetch(:type) == "event-v2 alert" || on_missing_data != "default"
-          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
-
         # only set when needed to avoid big diff
         if (notification_preset_name = notification_preset_name())
           options[:notification_preset_name] = notification_preset_name
         end
 
-        # locked is deprecated, will fail if used
-        options.delete :locked
-
         data
       end
 
+      # TODO: migrate everything to only use on_missing_data by only sending notify_no_data when it was set by a user
+      # and enforce that it is not set at the same time as on_missing_data
+      def configure_no_data
+        notify = notify_no_data
+        timeframe = no_data_timeframe
+        action = on_missing_data
+        action ||= "default" if type == "event-v2 alert"
+
+        # TODO: mark setting action && !notify.nil? at all as invalid
+        if action
+          if ON_MISSING_DATA_UNSUPPORTED_TYPES.include?(type)
+            invalid! :invalid_no_data_config, "cannot use on_missing_data with #{type} monitor"
+          end
+          if timeframe
+            invalid! :invalid_no_data_config, "set either no_data_timeframe or on_missing_data"
+          end
+          if action != "default" && type == "query alert" && query.to_s.include?("default_zero(") # is allowed for log alert for example
+            invalid! :invalid_no_data_config, "set on_missing_data to `default` when using default_zero"
+          end
+          if action == "resolve" && timeout_h.to_i != 0
+            invalid! :invalid_no_data_config, "timeout_h cannot be set and non-zero when on_missing_data is `resolve`"
+          end
+        end
+
+        # on_missing_data cannot be used with notify_no_data + no_data_timeframe
+        if action
+          { on_missing_data: action || "default" }
+        else
+          {
+            notify_no_data: notify,
+            no_data_timeframe: notify ? no_data_timeframe || default_no_data_timeframe : nil
+          }
+        end
+      end
+
       def resolve_linked_tracking_ids!(id_map, **args)
         case as_json[:type]
         when "composite", "slo alert"
@@ -180,14 +195,32 @@ module Kennel
         end
       end
 
-      def validate_update!(diffs)
-        # ensure type does not change, but not if it's metric->query which is supported and used by importer.rb
-        _, path, from, to = diffs.detect { |_, path, _, _| path == "type" }
-        if path && !(from == "metric alert" && to == "query alert")
-          invalid_update!(path, from, to)
+      # ensure type does not change, but not if it's metric->query which is supported and used by importer.rb
+      def allowed_update_error(actual)
+        actual_type = actual[:type]
+        return if actual_type == type || (actual_type == "metric alert" && type == "query alert")
+        "cannot update type from #{actual_type} to #{type}"
+      end
+
+      # deprecated this setting is no longer returned by dd for new monitors
+      # datadog UI warns when setting no data timeframe to less than 2x the query window
+      # limited to 24h because `no_data_timeframe must not exceed group retention` and max group retention is 24h
+      def default_no_data_timeframe
+        default = 60
+        if type == "query alert" && (minutes = query_window_minutes)
+          (minutes * 2).clamp(default, 24 * 60)
+        else
+          default
         end
       end
 
+      # validate that monitors that alert on no data resolve in external services by using timeout_h, so it sends a
+      # notification when the no data group is removed from the monitor, which datadog does automatically after 24h
+      def timeout_h
+        sending_no_data_notifications = (on_missing_data ? on_missing_data == "show_and_notify_no_data" : notify_no_data)
+        sending_no_data_notifications ? 24 : MONITOR_OPTION_DEFAULTS.fetch(:timeout_h)
+      end
+
       def self.api_resource
         "monitor"
       end
@@ -214,7 +247,9 @@ module Kennel
         ignore_default(expected, actual, MONITOR_DEFAULTS)
 
         options = actual.fetch(:options)
-        options.delete(:silenced) # we do not manage silenced, so ignore it when diffing
+
+        # we do not manage silenced: ignore it when diffing
+        options.delete(:silenced)
 
         # fields are not returned when set to true
         if ["service check", "event alert"].include?(actual[:type])
@@ -244,13 +279,38 @@ module Kennel
           options.delete(:escalation_message)
           expected_options.delete(:escalation_message)
         end
+
         # locked is deprecated: ignored when diffing
         options.delete(:locked)
-        expected_options.delete(:locked)
       end
 
       private
 
+      def configure_thresholds
+        return {} if type == "composite"
+
+        thresholds = { critical: critical }
+
+        # set optional variables
+        [:warning, :ok, :critical_recovery, :warning_recovery].each do |key|
+          if (value = send(key))
+            thresholds[key] = value
+          end
+        end
+
+        # custom logic for some types
+        case type
+        when "service check"
+          # avoid diff for default values of 1
+          OPTIONAL_SERVICE_CHECK_THRESHOLDS.each { |t| thresholds[t] ||= 1 }
+        when "query alert"
+          # metric and query values are stored as float by datadog
+          thresholds.each { |k, v| thresholds[k] = Float(v) }
+        end
+
+        { thresholds: thresholds }
+      end
+
       def validate_json(data)
         super
 
@@ -266,9 +326,11 @@ module Kennel
         end
 
         # verify query includes critical value
-        if (query_value = data.fetch(:query)[/\s*[<>]=?\s*(\d+(\.\d+)?)\s*$/, 1])
-          if Float(query_value) != Float(data.dig(:options, :thresholds, :critical))
-            invalid! :critical_does_not_match_query, "critical and value used in query must match"
+        if (critical = data.dig(:options, :thresholds, :critical))
+          if (query_value = data.fetch(:query)[/\s*[<>]=?\s*(\d+(\.\d+)?)\s*$/, 1])
+            if Float(query_value) != Float(critical)
+              invalid! :critical_does_not_match_query, "critical and value used in query must match"
+            end
           end
         end
 
@@ -297,7 +359,7 @@ module Kennel
         message = data.fetch(:message)
 
         used =
-          message.scan(/{{\s*(?:[#^]is(?:_exact)?_match)\s*"([^\s}]+)"/) + # {{#is_match "environment.name" "production"}}
+          message.scan(/{{\s*(?:[#^]is(?:_exact)?_match)\s*['"]([^\s}]+)['"]/) + # {{#is_match "environment.name" "production"}}
           message.scan(/{{\s*([^}]+\.name)\s*}}/) # Pod {{pod.name}} failed
         return if used.empty?
         used.flatten!(1)
@@ -373,6 +435,11 @@ module Kennel
         else # do nothing
         end
       end
+
+      def query_window_minutes
+        return unless (match = query.match(/^\s*\w+\(last_(?<count>\d+)(?<unit>[mhdw])\):/))
+        Integer(match["count"]) * MINUTES_PER_UNIT.fetch(match["unit"])
+      end
     end
   end
 end

data/lib/kennel/models/project.rb

@@ -10,15 +10,21 @@ module Kennel
 
       def self.file_location
         return @file_location if defined?(@file_location)
-        if (location = instance_methods(false).first)
-          @file_location = instance_method(location).source_location.first.sub("#{Bundler.root}/", "")
+        methods = instance_methods(false)
+        if methods.any?
+          @file_location = methods.detect do |method|
+            location = instance_method(method).source_location.first
+            if (path = find_relative_path(location))
+              break path
+            end
+          end || raise("Unable to find file_location for #{name}")
         else
-          @file_location = nil
+          @file_location = nil # not sure if this is actually needed
         end
       end
 
       def validated_parts
-        all = parts
+        all = filter_parts(parts)
         unless all.is_a?(Array) && all.all? { |part| part.is_a?(Record) }
           raise "Project #{kennel_id} #parts must return an array of Records"
         end
@@ -29,6 +35,16 @@ module Kennel
 
       private
 
+      private_class_method def self.find_relative_path(path)
+        return path unless File.absolute_path?(path)
+        path.dup.sub!("#{Bundler.root}/", "") || path.dup.sub!("#{Dir.pwd}/", "")
+      end
+
+      # hook for users to add custom filtering via `prepend`
+      def filter_parts(parts)
+        parts
+      end
+
       # hook for users to add custom validations via `prepend`
       def validate_parts(parts)
       end

data/lib/kennel/models/record.rb

@@ -142,12 +142,8 @@ module Kennel
         @as_json
       end
 
-      # Can raise DisallowedUpdateError
-      def validate_update!(_diffs)
-      end
-
-      def invalid_update!(field, old_value, new_value)
-        raise DisallowedUpdateError, "#{safe_tracking_id} Datadog does not allow update of #{field} (#{old_value.inspect} -> #{new_value.inspect})"
+      def allowed_update_error(_a)
+        nil
       end
 
       # For use during error handling

data/lib/kennel/models/slo.rb

@@ -6,7 +6,7 @@ module Kennel
 
       READONLY_ATTRIBUTES = [
         *superclass::READONLY_ATTRIBUTES,
-        :type_id, :monitor_tags, :target_threshold, :timeframe, :warning_threshold
+        :type_id, :monitor_tags
       ].freeze
       TRACKING_FIELD = :description
       DEFAULTS = {
@@ -14,10 +14,12 @@ module Kennel
         query: nil,
         groups: nil,
         monitor_ids: [],
-        thresholds: []
+        thresholds: [],
+        primary: nil,
+        sli_specification: nil
       }.freeze
 
-      settings :type, :description, :thresholds, :query, :tags, :monitor_ids, :monitor_tags, :name, :groups, :sli_specification
+      settings :type, :description, :thresholds, :query, :tags, :monitor_ids, :monitor_tags, :name, :groups, :sli_specification, :primary
 
       defaults(
         tags: -> { @project.tags },
@@ -25,7 +27,9 @@ module Kennel
         description: -> { DEFAULTS.fetch(:description) },
         monitor_ids: -> { DEFAULTS.fetch(:monitor_ids) },
         thresholds: -> { DEFAULTS.fetch(:thresholds) },
-        groups: -> { DEFAULTS.fetch(:groups) }
+        groups: -> { DEFAULTS.fetch(:groups) },
+        primary: -> { DEFAULTS.fetch(:primary) },
+        sli_specification: -> { DEFAULTS.fetch(:sli_specification) }
       )
 
       def build_json
@@ -38,8 +42,18 @@ module Kennel
           type: type
         )
 
-        if type == "time_slice"
-          data[:sli_specification] = sli_specification
+        # add top level timeframe and threshold settings based on `primary`
+        if (p = primary)
+          data[:timeframe] = p
+          threshold =
+            thresholds.detect { |t| t[:timeframe] == p } ||
+            raise(ArgumentError, "#{tracking_id} unable to find threshold with timeframe #{p}")
+          data[:warning_threshold] = threshold[:warning]
+          data[:target_threshold] = threshold[:target]
+        end
+
+        if (v = sli_specification)
+          data[:sli_specification] = v
         elsif (v = query)
           data[:query] = v
         end
@@ -60,7 +74,7 @@ module Kennel
       end
 
       def self.parse_url(url)
-        url[/[?&]slo_id=([a-z\d]{10,})/, 1] || url[/\/slo\/([a-z\d]{10,})\/edit(\?|$)/, 1]
+        url[/[?&]slo_id=([a-z\d]{10,})/, 1] || url[/\/slo\/([a-z\d]{10,})(:?\/edit)?(\?|$)/, 1]
       end
 
       def resolve_linked_tracking_ids!(id_map, **args)
@@ -83,6 +97,21 @@ module Kennel
         expected[:tags]&.sort!
         actual[:tags].sort!
 
+        # do not show these in the diff if we automatically pick the primary timeframe,
+        # or we will have a permanent `something -> nil` diff
+        unless expected[:timeframe]
+          [:timeframe, :warning_threshold, :target_threshold].each { |k| actual.delete k }
+        end
+
+        # discard deprecated query which stays in datadog forever when we are trying to set sli_specification
+        # (downgrading to query by setting sli_specification=nil is not supported in the api)
+        actual.delete :query if expected[:sli_specification]
+
+        # user set query so let's not worry about sli_specification even if this might be hiding bugs
+        # ideally we'd validate and tell the user that this will have no effect (see importer logic)
+        # but I'm not confident this will always be right
+        actual.delete :sli_specification if expected[:query]
+
         ignore_default(expected, actual, DEFAULTS)
       end
 
@@ -97,6 +126,11 @@ module Kennel
           invalid! :tags_are_upper_case, "Tags must not be upper case (bad tags: #{bad_tags.sort.inspect})"
         end
 
+        # Check that thresholds are not empty
+        if !data[:thresholds] || data[:thresholds].empty?
+          invalid! :thresholds_empty, "SLO must have at least one threshold defined"
+        end
+
         # prevent "Invalid payload: The target is incorrect: target must be a positive number between (0.0, 100.0)"
         data[:thresholds]&.each do |threshold|
           target = threshold.fetch(:target)

data/lib/kennel/models/synthetic_test.rb

@@ -54,6 +54,9 @@ module Kennel
         actual[:locations] = actual[:locations]&.sort
 
         ignore_default(expected, actual, DEFAULTS)
+
+        # only update downtime_ids if we are trying to manage them
+        actual[:options]&.delete :downtime_ids unless expected.dig(:options, :downtime_ids)
       end
     end
   end

data/lib/kennel/models/team.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 module Kennel
   module Models
-    class Team < Base
-      settings :mention, :tags, :renotify_interval, :kennel_id
+    class Team
+      include SettingsAsMethods
+
+      settings :mention, :tags, :renotify_interval
       defaults(
-        tags: -> { ["team:#{kennel_id.sub(/^teams_/, "").tr("_", "-")}"] },
+        tags: -> { ["team:#{StringUtils.snake_case(self.class.name).sub(/^teams_/, "").tr("_", "-")}"] },
         renotify_interval: -> { 0 }
       )
     end

data/lib/kennel/parts_serializer.rb

@@ -2,6 +2,9 @@
 
 module Kennel
   class PartsSerializer
+    FILE_EXTENSION = ".json"
+    FOLDER = "generated"
+
     def initialize(filter:)
       @filter = filter
     end
@@ -9,8 +12,15 @@ module Kennel
     def write(parts)
       Progress.progress "Storing" do
         existing = existing_files_and_folders
-        used = write_changed(parts)
-        FileUtils.rm_rf(existing - used)
+        used, changed = write_changed(parts)
+        FileUtils.rm_rf(existing - used) # cleanup abandoned
+        suggest_using_project_filter(changed)
+      end
+    end
+
+    class << self
+      def tracking_id_for_path(path)
+        path.sub("#{FOLDER}/", "").sub(FILE_EXTENSION, "").sub("/", ":")
       end
     end
 
@@ -20,28 +30,29 @@ module Kennel
 
     def write_changed(parts)
       used = []
+      changed = []
 
       Utils.parallel(parts, max: 2) do |part|
         path = path_for_tracking_id(part.tracking_id)
 
+        # match paths returned from existing_files_and_folders
         used << File.dirname(path) # we have 1 level of sub folders, so this is enough
         used << path
 
         content = part.as_json.merge(api_resource: part.class.api_resource)
-        write_file_if_necessary(path, content)
+        changed << path if write_file_if_necessary(path, content)
       end
-
-      used
+      [used, changed]
     end
 
     def existing_files_and_folders
-      paths = Dir["generated/**/*"]
+      paths = Dir["#{FOLDER}/**/*"] # we rely on this returning folders and files, see write_changed
 
       # when filtering we only need the files we are going to write
       if filter.filtering?
         paths.select! do |path|
-          tracking_id = filter.tracking_id_for_path(path)
-          filter.matches_tracking_id?(tracking_id)
+          tracking_id = self.class.tracking_id_for_path(path)
+          filter.filters_tracking_id?(tracking_id)
         end
       end
 
@@ -49,7 +60,7 @@ module Kennel
     end
 
     def path_for_tracking_id(tracking_id)
-      "generated/#{tracking_id.tr("/", ":").sub(":", "/")}.json"
+      "#{FOLDER}/#{tracking_id.tr("/", ":").sub(":", "/")}#{FILE_EXTENSION}"
     end
 
     def write_file_if_necessary(path, content)
@@ -58,13 +69,21 @@ module Kennel
 
       # 99% case
       begin
-        return if File.read(path) == content
-      rescue Errno::ENOENT
+        return false if File.read(path) == content
+      rescue Errno::ENOENT # file or even folder did not exist
         FileUtils.mkdir_p(File.dirname(path))
       end
 
       # slow 1% case
       File.write(path, content)
+      true
+    end
+
+    def suggest_using_project_filter(changed)
+      return if filter.filtering?
+      projects = changed.map { |path| path.split("/")[1] }.uniq
+      return if projects.size != 1
+      warn "Hint: Using PROJECT=#{projects[0]} is faster"
     end
   end
 end

data/lib/kennel/projects_provider.rb

@@ -12,13 +12,14 @@ module Kennel
     #   All requested projects. This is a slow operation when loading all projects.
     def projects
       load_requested
-      loaded_projects.map(&:new)
+      projects = loaded_projects.map(&:new)
+      @filter.filter_projects projects # in case we loaded more though dependencies
     end
 
     private
 
     def loaded_projects
-      Models::Project.recursive_subclasses
+      Models::Project.recursive_subclasses.reject(&:abstract_class?)
     end
 
     # "require" requested .rb files under './projects',

data/lib/kennel/subclass_tracking.rb

@@ -9,8 +9,16 @@ module Kennel
       @subclasses ||= []
     end
 
+    def abstract_class?
+      !!@abstract_class
+    end
+
     private
 
+    def abstract_class!
+      @abstract_class = true # not inherited by children
+    end
+
     def inherited(child)
       super
       subclasses << child

data/lib/kennel/syncer/matched_expected.rb

@@ -36,7 +36,13 @@ module Kennel
 
         def matching_expected(a, map)
           klass = a.fetch(:klass)
-          map["#{klass.api_resource}:#{a.fetch(:id)}"] || map[a.fetch(:tracking_id)]
+          full_id = "#{klass.api_resource}:#{a.fetch(:id)}"
+          if (e = map[full_id]) # we try to update and the user has set the id
+            return e unless (error = e.allowed_update_error(a))
+            raise DisallowedUpdateError, "#{full_id} Datadog does not allow update: #{error}"
+          elsif (e = map[a.fetch(:tracking_id)])
+            e.allowed_update_error(a) ? nil : e # force a re-create if we can't update
+          end
         end
       end
     end

data/lib/kennel/syncer/plan_printer.rb

@@ -12,9 +12,9 @@ module Kennel
         if plan.empty?
           Kennel.out.puts Console.color(:green, "Nothing to do")
         else
+          print_changes "Delete", plan.deletes, :red
           print_changes "Create", plan.creates, :green
           print_changes "Update", plan.updates, :yellow
-          print_changes "Delete", plan.deletes, :red
         end
       end
 

data/lib/kennel/syncer/resolver.rb

@@ -27,7 +27,7 @@ module Kennel
           # 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)
+          next if !id_map.get(api_resource, tracking_id) && filter.filters_tracking_id?(tracking_id)
 
           id_map.set(api_resource, tracking_id, a.fetch(:id))
           if a.fetch(:klass).api_resource == "synthetics/tests"