kennel 2.9.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9635f7b742f83290e0feaa0f3eb1a55ba4ad78ca7d95c38aaba6e0adfebc1f4
-  data.tar.gz: 984fd58f8cabb3303e5f9084eb90405d6cf39c23b9c42b304d1aa6a07afca24b
+  metadata.gz: 88495b67d113181455cb6dc751d2f7820eababca5679cfb714bb614dc9370ad6
+  data.tar.gz: a8703613913aa4557c585e605f35a1aef9555902c65a5f1c1772b1038e9d4d34
 SHA512:
-  metadata.gz: ef77dd9a72a9577b0bf8eb78b300c41e098543422d7313a800693fbdc3e5a9ba5db82687cd0551eb362bb9cd8990e9cb943987ea442a3b99cdd52d02b30de3eb
-  data.tar.gz: 4d4e036cc03aec4619c6e407255189f263d9cd167406cd1bf7f0c131047417a65a777c8c449701622fed38e908d8c3f6aab7f9cd6f7514668371fc33bf0eabb4
+  metadata.gz: d730ee50ff704f25eb39fdd8daa9c95a2c0b43f9a9534c7f1a05a245bd3881ab5ce36f12ebf226354eeafe94c4a961e843eebbbcf0312b2b548577b26a4debdd
+  data.tar.gz: ff487e51479e7a463464e37ec09a10ef7c1dc7d695bcf18f97303048ab0a75759d71eda14aa95e512aa69b66c25baf016d778be449455c0ef069e081f5957373

data/lib/kennel/api.rb

@@ -5,8 +5,6 @@ module Kennel
   class Api
     CACHE_FILE = ENV.fetch("KENNEL_API_CACHE_FILE", "tmp/cache/details")
 
-    RateLimitParams = Data.define(:limit, :period, :remaining, :reset, :name)
-
     def self.with_tracking(api_resource, reply)
       klass = Models::Record.api_resource_map[api_resource]
       return reply unless klass # do not blow up on unknown models
@@ -125,20 +123,8 @@ module Kennel
             end
           end
 
-          rate_limit = RateLimitParams.new(
-            limit: response.headers["x-ratelimit-limit"],
-            period: response.headers["x-ratelimit-period"],
-            remaining: response.headers["x-ratelimit-remaining"],
-            reset: response.headers["x-ratelimit-reset"],
-            name: response.headers["x-ratelimit-name"]
-          )
-
           if response.status == 429
-            message = "Datadog rate limit #{rate_limit.name.inspect} hit"
-            message += " (#{rate_limit.limit} requests per #{rate_limit.period} seconds)"
-            message += "; sleeping #{rate_limit.reset} seconds before trying again"
-            Kennel.err.puts message
-            sleep rate_limit.reset.to_f
+            sleep_until_rate_limit_resets(response)
             redo
           end
 
@@ -161,6 +147,20 @@ module Kennel
       end
     end
 
+    def sleep_until_rate_limit_resets(response)
+      limit = response.headers["x-ratelimit-limit"]
+      period = response.headers["x-ratelimit-period"]
+      reset = response.headers["x-ratelimit-reset"]
+      name = response.headers["x-ratelimit-name"]
+
+      message = "Datadog rate limit #{name.inspect} hit"
+      message += " (#{limit} requests per #{period} seconds)"
+      message += "; sleeping #{reset} seconds before trying again"
+
+      Kennel.err.puts message
+      sleep reset.to_f
+    end
+
     # allow caching all requests to speedup/benchmark logic that includes repeated requests
     def with_cache(enabled, key)
       return yield unless enabled

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, :assets
+        :multi, :matching_downtimes, :overall_state_modified, :overall_state, :restricted_roles, :draft_status, :assets,
+        :enable_logs_sample
       ]
       TRACKING_FIELD = :message
 
@@ -25,13 +26,19 @@ 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
       }.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
+      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,
@@ -49,13 +56,11 @@ 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 },
         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 },
@@ -70,6 +75,8 @@ module Kennel
       )
 
       def build_json
+        no_data_options = configure_no_data
+
         data = super.merge(
           name: "#{name}#{LOCK}",
           type: type,
@@ -79,8 +86,7 @@ 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,
@@ -88,33 +94,14 @@ module Kennel
             include_tags: true,
             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 +132,37 @@ 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
+        action = on_missing_data
+
+        # on_missing_data cannot be used with notify_no_data or no_data_timeframe
+        if type == "event-v2 alert" || action
+          # TODO: mark setting notify_no_data or no_data_timeframe at all as invalid
+          { on_missing_data: action || "default" }
+        else
+          {
+            notify_no_data: notify,
+            no_data_timeframe: notify ? no_data_timeframe : nil
+          }
+        end
+      end
+
       def resolve_linked_tracking_ids!(id_map, **args)
         case as_json[:type]
         when "composite", "slo alert"
@@ -187,6 +181,25 @@ module Kennel
         "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 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
@@ -213,7 +226,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])
@@ -243,13 +258,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
 
@@ -372,6 +412,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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kennel
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.11.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-20 00:00:00.000000000 Z
+date: 2026-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs