kennel 1.139.0 → 1.141.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33d7570c6b4d70c6d50f89d0111d8db96e6c0c0ba9273d00bb0975acfef12526
-  data.tar.gz: ea89fdf62138917a204e9c619a7a1182acca1e8d898f22e16707d0a02685cd26
+  metadata.gz: e82dacccbb0c14e8b8bedd9545b782b7405ca057a02724e89aa03f0a624fa3e4
+  data.tar.gz: f70302b436c823c6cbcb765edbd56da1103b83fadf398c2c904372a8f73b36a7
 SHA512:
-  metadata.gz: de01f19064531cb09615b63056b1eaa82118a4734fbdd9afa44eef56019923a736b45f9f4440da584cd0939231f7d7928f9a819cbfdb2f014336e82ee0f66c7e
-  data.tar.gz: ec59ee486794d91f5af93e8b3f77134ff206b6f653cc424c3e337b6893fefef1a6fb92a401029e2f5fd4ca83db49c1d284bf556105ad6d38667b3825667bb973
+  metadata.gz: c34733bc887129a6bda1ebc96898ca46cec0346bb008af8020d4159d23db515de54d8db8813749ba7883c0417b0cecb243a530789a4a99d6aa146679996007aa
+  data.tar.gz: a7821e5e67899aa71a068bfabbd895f7c69a369a187b7245510fc969a69d4354bad352cfb953f64293140c6282fa21d38f0e8695ab60d9186a19b30faeddd019

data/lib/kennel/models/monitor.rb

@@ -30,12 +30,11 @@ module Kennel
       }.freeze
       DEFAULT_ESCALATION_MESSAGE = ["", nil].freeze
       ALLOWED_PRIORITY_CLASSES = [NilClass, Integer].freeze
-      ALLOWED_UNLINKED = [] # rubocop:disable Style/MutableConstant placeholder for custom overrides
 
       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, :priority, :validate_using_links, :variables, :on_missing_data,
+        :threshold_windows, :scheduling_options, :new_host_delay, :new_group_delay, :priority, :variables, :on_missing_data,
         :notification_preset_name
       )
 
@@ -265,6 +264,7 @@ module Kennel
         end
 
         validate_using_links(data)
+        validate_thresholds(data)
 
         if type == "service check" && !data[:query].to_s.include?(".by(")
           invalid! :query_must_include_by, "query must include a .by() at least .by(\"*\")"
@@ -320,16 +320,45 @@ module Kennel
         case data[:type]
         when "composite" # TODO: add slo to mirror resolve_linked_tracking_ids! logic
           ids = data[:query].tr("-", "_").scan(/\b\d+\b/)
-          ids.reject! { |id| ALLOWED_UNLINKED.include?([tracking_id, id]) }
           if ids.any?
             invalid! :links_must_be_via_tracking_id, <<~MSG.rstrip
-              Used #{ids} in the query, but should only use links in the form of %{<project id>:<monitor id>}
-              If that is not possible, add `validate_using_links: ->(*){} # linked monitors are not in kennel
+              Use kennel ids in the query for linking monitors instead of #{ids}, for example `%{#{project.kennel_id}:<monitor id>}`
+              If the target monitors are not managed via kennel, add `ignored_errors: [:links_must_be_via_tracking_id] # linked monitors are not in kennel`
+            MSG
+          end
+        when "slo alert"
+          if (id = data[:query][/error_budget\("([a-f\d]+)"\)/, 1])
+            invalid! :links_must_be_via_tracking_id, <<~MSG
+              Use kennel ids in the query for linking alerts to slos instead of "#{id}", for example `error_budget("%{#{project.kennel_id}:slo_id_goes_here}")
+              If the target slo is not managed by kennel, then add `ignored_errors: [:links_must_be_via_tracking_id] # linked slo is not in kennel`
             MSG
           end
         else # do nothing
         end
       end
+
+      # Prevent "Warning threshold (50.0) must be less than the alert threshold (20.0) with > comparison."
+      def validate_thresholds(data)
+        return unless (warning = data.dig(:options, :thresholds, :warning))
+        critical = data.dig(:options, :thresholds, :critical)
+
+        case data[:query]
+        when /<=?\s*\S+\s*$/
+          if warning <= critical
+            invalid!(
+              :alert_less_than_warning,
+              "Warning threshold (#{warning}) must be greater than the alert threshold (#{critical}) with < comparison"
+            )
+          end
+        when />=?\s*\S+\s*$/
+          if warning >= critical
+            invalid!(
+              :alert_less_than_warning,
+              "Warning threshold (#{warning}) must be less than the alert threshold (#{critical}) with > comparison"
+            )
+          end
+        end
+      end
     end
   end
 end

data/lib/kennel/models/record.rb

@@ -2,14 +2,6 @@
 module Kennel
   module Models
     class Record < Base
-      class PrepareError < StandardError
-        def initialize(tracking_id)
-          super("Error while preparing #{tracking_id}")
-        end
-      end
-
-      UnvalidatedRecordError = Class.new(StandardError)
-
       include OptionalValidations
 
       # Apart from if you just don't like the default for some reason,
@@ -85,12 +77,12 @@ module Kennel
         end
       end
 
-      attr_reader :project, :unfiltered_validation_errors, :filtered_validation_errors
+      attr_reader :project, :as_json
 
-      def initialize(project, *args)
+      def initialize(project, ...)
         raise ArgumentError, "First argument must be a project, not #{project.class}" unless project.is_a?(Project)
         @project = project
-        super(*args)
+        super(...)
       end
 
       def diff(actual)
@@ -141,29 +133,9 @@ module Kennel
       end
 
       def build
-        @unfiltered_validation_errors = []
-        json = nil
-
-        begin
-          json = build_json
-          (id = json.delete(:id)) && json[:id] = id
-          validate_json(json)
-        rescue StandardError
-          if unfiltered_validation_errors.empty?
-            @unfiltered_validation_errors = nil
-            raise PrepareError, safe_tracking_id # FIXME: this makes errors hard to debug when running tests
-          end
-        end
-
-        @filtered_validation_errors = filter_validation_errors
-        @as_json = json # Only valid if filtered_validation_errors.empty?
-      end
-
-      def as_json
-        # A courtesy to those tests that still expect as_json to perform validation and raise on error
-        build if @unfiltered_validation_errors.nil?
-        raise UnvalidatedRecordError, "#{safe_tracking_id} as_json called on invalid part" if filtered_validation_errors.any?
-
+        @as_json = build_json
+        (id = @as_json.delete(:id)) && @as_json[:id] = id
+        validate_json(@as_json)
         @as_json
       end
 
@@ -184,6 +156,17 @@ module Kennel
 
       private
 
+      def validate_json(data)
+        bad = Kennel::Utils.all_keys(data).grep_v(Symbol).sort.uniq
+        return if bad.empty?
+        invalid!(
+          :hash_keys_must_be_symbols,
+          "Only use Symbols as hash keys to avoid permanent diffs when updating.\n" \
+          "Change these keys to be symbols (usually 'foo' => 1 --> 'foo': 1)\n" \
+          "#{bad.map(&:inspect).join("\n")}"
+        )
+      end
+
       def resolve(value, type, id_map, force:)
         return value unless tracking_id?(value)
         resolve_link(value, type, id_map, force: force)
@@ -214,10 +197,6 @@ module Kennel
         end
       end
 
-      def invalid!(tag, message)
-        unfiltered_validation_errors << ValidationMessage.new(tag || OptionalValidations::UNIGNORABLE, message)
-      end
-
       def raise_with_location(error, message)
         super error, "#{message} for project #{project.kennel_id}"
       end

data/lib/kennel/optional_validations.rb

@@ -4,80 +4,89 @@ module Kennel
     ValidationMessage = Struct.new(:tag, :text)
 
     UNIGNORABLE = :unignorable
+    UNUSED_IGNORES = :unused_ignores
 
     def self.included(base)
       base.settings :ignored_errors
       base.defaults(ignored_errors: -> { [] })
+      base.attr_reader :validation_errors
     end
 
-    def self.valid?(parts)
-      parts_with_errors = parts.reject do |part|
-        part.filtered_validation_errors.empty?
-      end
+    def initialize(...)
+      super
+      @validation_errors = []
+    end
 
-      return true if parts_with_errors.empty?
+    def invalid!(tag, message)
+      validation_errors << ValidationMessage.new(tag || OptionalValidations::UNIGNORABLE, message)
+    end
 
-      example_tag = nil
+    def self.valid?(parts)
+      parts_with_errors = parts.map { |p| [p, filter_validation_errors(p)] }
+      return true if parts_with_errors.all? { |_, errors| errors.empty? }
 
+      # print errors in order
+      example_tag = nil
       Kennel.err.puts
-      parts_with_errors.sort_by(&:safe_tracking_id).each do |part|
-        part.filtered_validation_errors.each do |err|
+      parts_with_errors.sort_by! { |p, _| p.safe_tracking_id }
+      parts_with_errors.each do |part, errors|
+        errors.each do |err|
           Kennel.err.puts "#{part.safe_tracking_id} [#{err.tag.inspect}] #{err.text.gsub("\n", " ")}"
           example_tag = err.tag unless err.tag == :unignorable
         end
       end
       Kennel.err.puts
 
-      Kennel.err.puts <<~MESSAGE if example_tag
-        If a particular error cannot be fixed, it can be marked as ignored via `ignored_errors`, e.g.:
-          Kennel::Models::Monitor.new(
-            ...,
-            ignored_errors: [#{example_tag.inspect}]
-          )
+      if example_tag
+        Kennel.err.puts <<~MESSAGE
+          If a particular error cannot be fixed, it can be marked as ignored via `ignored_errors`, e.g.:
+            Kennel::Models::Monitor.new(
+              ...,
+              ignored_errors: [#{example_tag.inspect}]
+            )
 
-      MESSAGE
+        MESSAGE
+      end
 
       false
     end
 
-    private
-
-    def validate_json(data)
-      bad = Kennel::Utils.all_keys(data).grep_v(Symbol).sort.uniq
-      return if bad.empty?
-      invalid!(
-        :hash_keys_must_be_symbols,
-        "Only use Symbols as hash keys to avoid permanent diffs when updating.\n" \
-        "Change these keys to be symbols (usually 'foo' => 1 --> 'foo': 1)\n" \
-        "#{bad.map(&:inspect).join("\n")}"
-      )
-    end
+    def self.filter_validation_errors(part)
+      errors = part.validation_errors
+      ignored_tags = part.ignored_errors
 
-    def filter_validation_errors
-      if unfiltered_validation_errors.empty?
-        if ignored_errors.empty?
+      if errors.empty? # 95% case, so keep it fast
+        if ignored_tags.empty? || ignored_tags.include?(UNUSED_IGNORES)
           []
         else
-          [ValidationMessage.new(UNIGNORABLE, "`ignored_errors` is non-empty, but there are no errors to ignore. Remove `ignored_errors`")]
+          # tell users to remove the whole line and not just an element
+          [
+            ValidationMessage.new(
+              UNUSED_IGNORES,
+              "`ignored_errors` is non-empty, but there are no errors to ignore. Remove `ignored_errors`"
+            )
+          ]
         end
       else
-        to_report =
-          if ENV["NO_IGNORED_ERRORS"]
-            # Turn off all suppressions, to see what errors are actually being suppressed
-            unfiltered_validation_errors
+        reported_errors =
+          if ENV["NO_IGNORED_ERRORS"] # let users see what errors are suppressed
+            errors
           else
-            unfiltered_validation_errors.reject do |err|
-              err.tag != UNIGNORABLE && ignored_errors.include?(err.tag)
-            end
+            errors.select { |err| err.tag == UNIGNORABLE || !ignored_tags.include?(err.tag) }
           end
 
-        unused_ignores = ignored_errors - unfiltered_validation_errors.map(&:tag)
-
-        if unused_ignores.any?
-          to_report << ValidationMessage.new(UNIGNORABLE, "Unused ignores #{unused_ignores.map(&:inspect).sort.uniq.join(" ")}. Remove these from `ignored_errors`")
+        # let users know when they can remove an ignore ... unless they don't care (for example for a generic monitor)
+        unless ignored_tags.include?(UNUSED_IGNORES)
+          unused_ignored_tags = ignored_tags - errors.map(&:tag)
+          if unused_ignored_tags.any?
+            reported_errors << ValidationMessage.new(
+              UNUSED_IGNORES,
+              "Unused ignores #{unused_ignored_tags.map(&:inspect).sort.uniq.join(" ")}. Remove these from `ignored_errors`"
+            )
+          end
         end
 
-        to_report
+        reported_errors
       end
     end
   end

data/lib/kennel/version.rb

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

data/lib/kennel.rb

@@ -127,7 +127,7 @@ module Kennel
           Utils.parallel(parts, &:build)
         end
 
-        OptionalValidations.valid?(parts) or raise GenerationAbortedError
+        OptionalValidations.valid?(parts) || raise(GenerationAbortedError)
 
         parts
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 1.139.0
+  version: 1.141.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-26 00:00:00.000000000 Z
+date: 2023-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs