kennel 1.75.0

data/lib/kennel/models/monitor.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Monitor < Record
+      include OptionalValidations
+
+      RENOTIFY_INTERVALS = [0, 10, 20, 30, 40, 50, 60, 90, 120, 180, 240, 300, 360, 720, 1440].freeze # minutes
+      # 2d and 1w are valid timeframes for anomaly monitors
+      QUERY_INTERVALS = ["1m", "5m", "10m", "15m", "30m", "1h", "2h", "4h", "1d", "2d", "1w"].freeze
+      OPTIONAL_SERVICE_CHECK_THRESHOLDS = [:ok, :warning].freeze
+      READONLY_ATTRIBUTES = superclass::READONLY_ATTRIBUTES + [
+        :multi, :matching_downtimes, :overall_state_modified, :overall_state, :restricted_roles
+      ]
+
+      # defaults that datadog uses when options are not sent, so safe to leave out if our values match their defaults
+      MONITOR_OPTION_DEFAULTS = {
+        evaluation_delay: nil,
+        new_host_delay: 300,
+        timeout_h: 0,
+        renotify_interval: 0,
+        no_data_timeframe: nil # this works out ok since if notify_no_data is on, it would never be nil
+      }.freeze
+      DEFAULT_ESCALATION_MESSAGE = ["", nil].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, :new_host_delay, :groupby_simple_monitor
+      )
+
+      defaults(
+        message: -> { "\n\n#{project.mention}" },
+        escalation_message: -> { DEFAULT_ESCALATION_MESSAGE.first },
+        renotify_interval: -> { project.team.renotify_interval },
+        warning: -> { nil },
+        ok: -> { nil },
+        id: -> { nil },
+        notify_no_data: -> { true },
+        no_data_timeframe: -> { 60 },
+        notify_audit: -> { true },
+        new_host_delay: -> { MONITOR_OPTION_DEFAULTS.fetch(:new_host_delay) },
+        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 },
+        threshold_windows: -> { nil },
+        groupby_simple_monitor: -> { nil }
+      )
+
+      def as_json
+        return @as_json if @as_json
+        data = {
+          name: "#{name}#{LOCK}",
+          type: type,
+          query: query.strip,
+          message: message.strip,
+          tags: tags.uniq,
+          options: {
+            timeout_h: timeout_h,
+            notify_no_data: notify_no_data,
+            no_data_timeframe: notify_no_data ? no_data_timeframe : nil,
+            notify_audit: notify_audit,
+            require_full_window: require_full_window,
+            new_host_delay: new_host_delay,
+            include_tags: true,
+            escalation_message: Utils.presence(escalation_message.strip),
+            evaluation_delay: evaluation_delay,
+            locked: false, # setting this to true prevents any edit and breaks updates when using replace workflow
+            renotify_interval: renotify_interval || 0
+          }
+        }
+
+        data[:id] = id if id
+
+        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
+
+        # option randomly pops up and cannot be removed
+        unless (group = groupby_simple_monitor).nil?
+          options[:groupby_simple_monitor] = group
+        end
+
+        if windows = threshold_windows
+          options[:threshold_windows] = windows
+        end
+
+        validate_json(data) if validate
+
+        @as_json = data
+      end
+
+      def resolve_linked_tracking_ids!(id_map, **args)
+        if as_json[:type] == "composite"
+          as_json[:query] = as_json[:query].gsub(/%\{(.*?)\}/) do
+            resolve_link($1, :monitor, id_map, **args)
+          end
+        end
+      end
+
+      def self.api_resource
+        "monitor"
+      end
+
+      def url(id)
+        Utils.path_to_url "/monitors##{id}/edit"
+      end
+
+      # datadog uses / for show and # for edit as separator in it's links
+      def self.parse_url(url)
+        return unless id = url[/\/monitors[\/#](\d+)/, 1]
+        Integer(id)
+      end
+
+      def self.normalize(expected, actual)
+        super
+        options = actual.fetch(:options)
+        options.delete(:silenced) # we do not manage silenced, so ignore it when diffing
+
+        # fields are not returned when set to true
+        if ["service check", "event alert"].include?(actual[:type])
+          options[:include_tags] = true unless options.key?(:include_tags)
+          options[:require_full_window] = true unless options.key?(:require_full_window)
+        end
+
+        case actual[:type]
+        when "event alert"
+          # setting nothing results in thresholds not getting returned from the api
+          options[:thresholds] ||= { critical: 0 }
+
+        when "service check"
+          # fields are not returned when created with default values via UI
+          OPTIONAL_SERVICE_CHECK_THRESHOLDS.each do |t|
+            options[:thresholds][t] ||= 1
+          end
+        end
+
+        # nil / "" / 0 are not returned from the api when set via the UI
+        options[:evaluation_delay] ||= nil
+
+        expected_options = expected[:options] || {}
+        ignore_default(expected_options, options, MONITOR_OPTION_DEFAULTS)
+        if DEFAULT_ESCALATION_MESSAGE.include?(options[:escalation_message])
+          options.delete(:escalation_message)
+          expected_options.delete(:escalation_message)
+        end
+      end
+
+      private
+
+      def require_full_window
+        # default 'on_average', 'at_all_times', 'in_total' aggregations to true, otherwise false
+        # https://docs.datadoghq.com/ap/#create-a-monitor
+        type != "query alert" || query.start_with?("avg", "min", "sum")
+      end
+
+      def validate_json(data)
+        super
+
+        type = data.fetch(:type)
+
+        # do not allow deprecated type that will be coverted by datadog and then produce a diff
+        if type == "metric alert"
+          invalid! "type 'metric alert' is deprecated, please set to a different type (e.g. 'query alert')"
+        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 and value used in query must match"
+          end
+        end
+
+        # verify renotify interval is valid
+        unless RENOTIFY_INTERVALS.include? data.dig(:options, :renotify_interval)
+          invalid! "renotify_interval must be one of #{RENOTIFY_INTERVALS.join(", ")}"
+        end
+
+        if type == "query alert"
+          # verify interval is valud
+          interval = data.fetch(:query)[/\(last_(\S+?)\)/, 1]
+          if interval && !QUERY_INTERVALS.include?(interval)
+            invalid! "query interval was #{interval}, but must be one of #{QUERY_INTERVALS.join(", ")}"
+          end
+        end
+
+        if ["query alert", "service check"].include?(type) # TODO: most likely more types need this
+          # verify is_match uses available variables
+          message = data.fetch(:message)
+          used = message.scan(/{{\s*#is_match\s*"([a-zA-Z\d_.-]+).name"/).flatten.uniq
+          allowed = data.fetch(:query)[/by\s*[({]([^})]+)[})]/, 1].to_s.gsub(/["']/, "").split(/\s*,\s*/)
+          unsupported = used - allowed
+          if unsupported.any?
+            invalid! "is_match used with #{unsupported}, but metric is only grouped by #{allowed}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kennel/models/project.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Project < Base
+      settings :team, :parts, :tags, :mention
+      defaults(
+        tags: -> { ["service:#{kennel_id}"] + team.tags },
+        mention: -> { team.mention }
+      )
+
+      def self.file_location
+        @file_location ||= begin
+          method_in_file = instance_methods(false).first
+          instance_method(method_in_file).source_location.first.sub("#{Bundler.root}/", "")
+        end
+      end
+
+      def validated_parts
+        all = parts
+        validate_parts(all)
+        all
+      end
+
+      private
+
+      # hook for users to add custom validations via `prepend`
+      def validate_parts(parts)
+      end
+    end
+  end
+end

data/lib/kennel/models/record.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Record < Base
+      LOCK = "\u{1F512}"
+      READONLY_ATTRIBUTES = [
+        :deleted, :id, :created, :created_at, :creator, :org_id, :modified, :modified_at, :api_resource
+      ].freeze
+      API_LIST_INCOMPLETE = false
+
+      settings :id, :kennel_id
+
+      class << self
+        def parse_any_url(url)
+          subclasses.detect do |s|
+            if id = s.parse_url(url)
+              break s.api_resource, id
+            end
+          end
+        end
+
+        private
+
+        def normalize(_expected, actual)
+          self::READONLY_ATTRIBUTES.each { |k| actual.delete k }
+        end
+
+        def ignore_default(expected, actual, defaults)
+          definitions = [actual, expected]
+          defaults.each do |key, default|
+            if definitions.all? { |r| !r.key?(key) || r[key] == default }
+              actual.delete(key)
+              expected.delete(key)
+            end
+          end
+        end
+      end
+
+      attr_reader :project
+
+      def initialize(project, *args)
+        raise ArgumentError, "First argument must be a project, not #{project.class}" unless project.is_a?(Project)
+        @project = project
+        super(*args)
+      end
+
+      def diff(actual)
+        expected = as_json
+        expected.delete(:id)
+
+        self.class.send(:normalize, expected, actual)
+
+        # strict: ignore Integer vs Float
+        # similarity: show diff when not 100% similar
+        # use_lcs: saner output
+        Hashdiff.diff(actual, expected, use_lcs: false, strict: false, similarity: 1)
+      end
+
+      def tracking_id
+        "#{project.kennel_id}:#{kennel_id}"
+      end
+
+      def resolve_linked_tracking_ids!(*)
+      end
+
+      private
+
+      def resolve_link(id, type, id_map, force:)
+        value = id_map[id]
+        if value == :new
+          if force
+            # TODO: remove the need for this by sorting monitors by missing resolutions
+            invalid! "#{id} needs to already exist, try again"
+          else
+            id # will be re-resolved by syncer after the linked object was created
+          end
+        elsif value
+          value
+        else
+          invalid! "Unable to find #{type} #{id} (does not exist and is not being created by the current run)"
+        end
+      end
+
+      # let users know which project/resource failed when something happens during diffing where the backtrace is hidden
+      def invalid!(message)
+        raise ValidationError, "#{tracking_id} #{message}"
+      end
+
+      def raise_with_location(error, message)
+        super error, "#{message} for project #{project.kennel_id}"
+      end
+    end
+  end
+end

data/lib/kennel/models/slo.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Slo < Record
+      READONLY_ATTRIBUTES = superclass::READONLY_ATTRIBUTES + [:type_id, :monitor_tags]
+      DEFAULTS = {
+        description: nil,
+        query: nil,
+        groups: nil,
+        monitor_ids: [],
+        thresholds: []
+      }.freeze
+
+      settings :type, :description, :thresholds, :query, :tags, :monitor_ids, :monitor_tags, :name, :groups
+
+      defaults(
+        id: -> { nil },
+        tags: -> { @project.tags },
+        query: -> { DEFAULTS.fetch(:query) },
+        description: -> { DEFAULTS.fetch(:description) },
+        monitor_ids: -> { DEFAULTS.fetch(:monitor_ids) },
+        thresholds: -> { DEFAULTS.fetch(:thresholds) },
+        groups: -> { DEFAULTS.fetch(:groups) }
+      )
+
+      def initialize(*)
+        super
+        if thresholds.any? { |t| t[:warning] && t[:warning].to_f <= t[:critical].to_f }
+          raise ValidationError, "Threshold warning must be greater-than critical value"
+        end
+      end
+
+      def as_json
+        return @as_json if @as_json
+        data = {
+          name: "#{name}#{LOCK}",
+          description: description,
+          thresholds: thresholds,
+          monitor_ids: monitor_ids,
+          tags: tags.uniq,
+          type: type
+        }
+
+        if v = query
+          data[:query] = v
+        end
+        if v = id
+          data[:id] = v
+        end
+        if v = groups
+          data[:groups] = v
+        end
+
+        @as_json = data
+      end
+
+      def self.api_resource
+        "slo"
+      end
+
+      def url(id)
+        Utils.path_to_url "/slo?slo_id=#{id}"
+      end
+
+      def self.parse_url(url)
+        url[/\/slo\?slo_id=([a-z\d]+)/, 1]
+      end
+
+      def resolve_linked_tracking_ids!(id_map, **args)
+        as_json[:monitor_ids] = as_json[:monitor_ids].map do |id|
+          id.is_a?(String) ? resolve_link(id, :monitor, id_map, **args) : id
+        end
+      end
+
+      def self.normalize(expected, actual)
+        super
+
+        # remove readonly values
+        actual[:thresholds]&.each do |threshold|
+          threshold.delete(:warning_display)
+          threshold.delete(:target_display)
+        end
+
+        # tags come in a semi-random order and order is never updated
+        expected[:tags]&.sort!
+        actual[:tags].sort!
+
+        ignore_default(expected, actual, DEFAULTS)
+      end
+    end
+  end
+end

data/lib/kennel/models/team.rb

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