kennel 1.75.0

data/lib/kennel/optional_validations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Kennel
+  module OptionalValidations
+    def self.included(base)
+      base.settings :validate
+      base.defaults(validate: -> { true })
+    end
+
+    private
+
+    def validate_json(data)
+      bad = Kennel::Utils.all_keys(data).grep_v(Symbol)
+      return if bad.empty?
+      invalid!(
+        "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
+  end
+end

data/lib/kennel/progress.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "benchmark"
+
+module Kennel
+  class Progress
+    # print what we are doing and a spinner until it is done ... then show how long it took
+    def self.progress(name)
+      Kennel.err.print "#{name} ... "
+
+      animation = "-\\|/"
+      count = 0
+      stop = false
+      result = nil
+
+      spinner = Thread.new do
+        loop do
+          break if stop
+          Kennel.err.print animation[count % animation.size]
+          sleep 0.2
+          Kennel.err.print "\b"
+          count += 1
+        end
+      end
+
+      time = Benchmark.realtime { result = yield }
+
+      stop = true
+      spinner.join
+      Kennel.err.print "#{time.round(2)}s\n"
+
+      result
+    end
+  end
+end

data/lib/kennel/settings_as_methods.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Kennel
+  module SettingsAsMethods
+    SETTING_OVERRIDABLE_METHODS = [].freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.instance_variable_set(:@settings, [])
+    end
+
+    module ClassMethods
+      def settings(*names)
+        duplicates = (@settings & names)
+        if duplicates.any?
+          raise ArgumentError, "Settings #{duplicates.map(&:inspect).join(", ")} are already defined"
+        end
+
+        overrides = ((instance_methods - self::SETTING_OVERRIDABLE_METHODS) & names)
+        if overrides.any?
+          raise ArgumentError, "Settings #{overrides.map(&:inspect).join(", ")} are already used as methods"
+        end
+
+        @settings.concat names
+
+        names.each do |name|
+          next if method_defined?(name)
+          define_method name do
+            raise_with_location ArgumentError, "'#{name}' on #{self.class} was not set or passed as option"
+          end
+        end
+      end
+
+      def defaults(options)
+        options.each do |name, block|
+          validate_setting_exist name
+          define_method name, &block
+        end
+      end
+
+      private
+
+      def validate_setting_exist(name)
+        return if !@settings || @settings.include?(name)
+        supported = @settings.map(&:inspect)
+        raise ArgumentError, "Unsupported setting #{name.inspect}, supported settings are #{supported.join(", ")}"
+      end
+
+      def inherited(child)
+        super
+        child.instance_variable_set(:@settings, (@settings || []).dup)
+      end
+    end
+
+    def initialize(options = {})
+      super()
+
+      unless options.is_a?(Hash)
+        raise ArgumentError, "Expected #{self.class.name}.new options to be a Hash, got a #{options.class}"
+      end
+
+      options.each do |k, v|
+        next if v.class == Proc
+        raise ArgumentError, "Expected #{self.class.name}.new option :#{k} to be Proc, for example `#{k}: -> { 12 }`"
+      end
+
+      options.each do |name, block|
+        self.class.send :validate_setting_exist, name
+        define_singleton_method name, &block
+      end
+
+      # need expand_path so it works wih rake and when run individually
+      pwd = /^#{Regexp.escape(Dir.pwd)}\//
+      @invocation_location = caller.detect do |l|
+        if found = File.expand_path(l).sub!(pwd, "")
+          break found
+        end
+      end
+    end
+
+    def raise_with_location(error, message)
+      message = message.dup
+      message << " on #{@invocation_location}" if @invocation_location
+      raise error, message
+    end
+  end
+end

data/lib/kennel/subclass_tracking.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Kennel
+  module SubclassTracking
+    def recursive_subclasses
+      subclasses + subclasses.flat_map(&:recursive_subclasses)
+    end
+
+    def subclasses
+      @subclasses ||= []
+    end
+
+    private
+
+    def inherited(child)
+      super
+      subclasses << child
+    end
+  end
+end

data/lib/kennel/syncer.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+module Kennel
+  class Syncer
+    CACHE_FILE = "tmp/cache/details" # keep in sync with .travis.yml caching
+    TRACKING_FIELDS = [:message, :description].freeze
+    DELETE_ORDER = ["dashboard", "slo", "monitor"].freeze # dashboards references monitors + slos, slos reference monitors
+
+    def initialize(api, expected, project: nil)
+      @api = api
+      @project_filter = project
+      @expected = expected
+      if @project_filter
+        original = @expected
+        @expected = @expected.select { |e| e.project.kennel_id == @project_filter }
+        if @expected.empty?
+          possible = original.map { |e| e.project.kennel_id }.uniq.sort
+          raise "#{@project_filter} does not match any projects, try any of these:\n#{possible.join("\n")}"
+        end
+      end
+      @expected.each { |e| add_tracking_id e }
+      calculate_diff
+      prevent_irreversible_partial_updates
+    end
+
+    def plan
+      Kennel.out.puts "Plan:"
+      if noop?
+        Kennel.out.puts Utils.color(:green, "Nothing to do")
+      else
+        print_plan "Create", @create, :green
+        print_plan "Update", @update, :yellow
+        print_plan "Delete", @delete, :red
+      end
+    end
+
+    def confirm
+      ENV["CI"] || !STDIN.tty? || Utils.ask("Execute Plan ?") unless noop?
+    end
+
+    def update
+      changed = (@create + @update).map { |_, e| e } unless @create.empty?
+
+      @create.each do |_, e|
+        e.resolve_linked_tracking_ids!({}, force: true)
+
+        reply = @api.create e.class.api_resource, e.as_json
+        id = reply.fetch(:id)
+
+        # resolve ids we could previously no resolve
+        changed.delete e
+        resolve_linked_tracking_ids! from: [reply], to: changed
+
+        Kennel.out.puts "Created #{e.class.api_resource} #{tracking_id(e.as_json)} #{e.url(id)}"
+      end
+
+      @update.each do |id, e|
+        e.resolve_linked_tracking_ids!({}, force: true)
+        @api.update e.class.api_resource, id, e.as_json
+        Kennel.out.puts "Updated #{e.class.api_resource} #{tracking_id(e.as_json)} #{e.url(id)}"
+      end
+
+      @delete.each do |id, _, a|
+        @api.delete a.fetch(:api_resource), id
+        Kennel.out.puts "Deleted #{a.fetch(:api_resource)} #{tracking_id(a)} #{id}"
+      end
+    end
+
+    private
+
+    def noop?
+      @create.empty? && @update.empty? && @delete.empty?
+    end
+
+    def calculate_diff
+      @update = []
+      @delete = []
+
+      actual = Progress.progress("Downloading definitions") { download_definitions }
+      resolve_linked_tracking_ids! from: actual, to: @expected
+      filter_by_project! actual
+
+      Progress.progress "Diffing" do
+        items = actual.map do |a|
+          e = matching_expected(a)
+          if e && @expected.delete(e)
+            [e, a]
+          else
+            [nil, a]
+          end
+        end
+
+        details_cache do |cache|
+          # fill details of things we need to compare (only do this part in parallel for safety & balancing)
+          Utils.parallel(items.select { |e, _| e && e.class::API_LIST_INCOMPLETE }) { |_, a| fill_details(a, cache) }
+        end
+
+        # pick out things to update or delete
+        items.each do |e, a|
+          id = a.fetch(:id)
+          if e
+            diff = e.diff(a)
+            @update << [id, e, a, diff] if diff.any?
+          elsif tracking_id(a) # was previously managed
+            @delete << [id, nil, a]
+          end
+        end
+
+        ensure_all_ids_found
+        @create = @expected.map { |e| [nil, e] }
+        @create.sort_by! { |_, e| -DELETE_ORDER.index(e.class.api_resource) }
+      end
+
+      @delete.sort_by! { |_, _, a| DELETE_ORDER.index a.fetch(:api_resource) }
+    end
+
+    # Make diff work even though we cannot mass-fetch definitions
+    def fill_details(a, cache)
+      resource = a.fetch(:api_resource)
+      args = [resource, a.fetch(:id)]
+      full = cache.fetch(args, a[:modified] || a.fetch(:modified_at)) do
+        @api.show(*args)
+      end
+      a.merge!(full)
+    end
+
+    def details_cache(&block)
+      cache = FileCache.new CACHE_FILE, Kennel::VERSION
+      cache.open(&block)
+    end
+
+    def download_definitions
+      Utils.parallel(Models::Record.subclasses.map(&:api_resource)) do |api_resource|
+        results = @api.list(api_resource, with_downtimes: false) # lookup monitors without adding unnecessary downtime information
+        results = results[results.keys.first] if results.is_a?(Hash) # dashboards are nested in {dashboards: []}
+        results.each { |c| c[:api_resource] = api_resource } # store api resource for later diffing
+      end.flatten(1)
+    end
+
+    def ensure_all_ids_found
+      @expected.each do |e|
+        next unless id = e.id
+        raise "Unable to find existing #{e.class.api_resource} with id #{id}"
+      end
+    end
+
+    def matching_expected(a)
+      # index list by all the thing we look up by: tracking id and actual id
+      @lookup_map ||= @expected.each_with_object({}) do |e, all|
+        keys = [tracking_id(e.as_json)]
+        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
+
+      @lookup_map["#{a.fetch(:api_resource)}:#{a.fetch(:id)}"] || @lookup_map[tracking_id(a)]
+    end
+
+    def print_plan(step, list, color)
+      return if list.empty?
+      list.each do |_, e, a, diff|
+        api_resource = (e ? e.class.api_resource : a.fetch(:api_resource))
+        Kennel.out.puts Utils.color(color, "#{step} #{api_resource} #{e&.tracking_id || tracking_id(a)}")
+        print_diff(diff) if diff # only for update
+      end
+    end
+
+    def print_diff(diff)
+      diff.each do |type, field, old, new|
+        if type == "+"
+          temp = Utils.pretty_inspect(new)
+          new = Utils.pretty_inspect(old)
+          old = temp
+        else # ~ and -
+          old = Utils.pretty_inspect(old)
+          new = Utils.pretty_inspect(new)
+        end
+
+        if (old + new).size > 100
+          Kennel.out.puts "  #{type}#{field}"
+          Kennel.out.puts "    #{old} ->"
+          Kennel.out.puts "    #{new}"
+        else
+          Kennel.out.puts "  #{type}#{field} #{old} -> #{new}"
+        end
+      end
+    end
+
+    # Do not add tracking-id when working with existing ids on a branch,
+    # so resource do not get deleted fr:om merges to master.
+    # Also make sure the diff still makes sense, by kicking out the now noop-update.
+    #
+    # Note: ideally we'd never add tracking in the first place, but at that point we do not know the diff yet
+    def prevent_irreversible_partial_updates
+      return unless @project_filter
+      @update.select! do |_, e, _, diff|
+        next true unless e.id # short circuit for performance
+
+        diff.select! do |field_diff|
+          (_, field, old, new) = field_diff
+          next true unless tracking_field?(field)
+
+          if (old_tracking = tracking_value(old))
+            old_tracking == tracking_value(new) || raise("do not update! (atm unreachable)")
+          else
+            field_diff[3] = remove_tracking_id(e) # make plan output match update
+            old != field_diff[3]
+          end
+        end
+
+        !diff.empty?
+      end
+    end
+
+    def resolve_linked_tracking_ids!(from:, to:)
+      map = from.each_with_object({}) { |a, lookup| lookup[tracking_id(a)] = a.fetch(:id) }
+      to.each { |e| map[e.tracking_id] ||= :new }
+      to.each { |e| e.resolve_linked_tracking_ids!(map, force: false) }
+    end
+
+    def filter_by_project!(definitions)
+      return unless @project_filter
+      definitions.select! do |a|
+        id = tracking_id(a)
+        !id || id.start_with?("#{@project_filter}:")
+      end
+    end
+
+    def add_tracking_id(e)
+      json = e.as_json
+      field = tracking_field(json)
+      raise "remove \"-- Managed by kennel\" line it from #{field} to copy a resource" if tracking_value(json[field])
+      json[field] = "#{json[field]}\n-- Managed by kennel #{e.tracking_id} in #{e.project.class.file_location}, do not modify manually".lstrip
+    end
+
+    def remove_tracking_id(e)
+      json = e.as_json
+      field = tracking_field(json)
+      value = json[field]
+      json[field] = value.dup.sub!(/\n?-- Managed by kennel .*/, "") || raise("did not find tracking id in #{value}")
+    end
+
+    def tracking_id(a)
+      tracking_value a[tracking_field(a)]
+    end
+
+    def tracking_value(content)
+      content.to_s[/-- Managed by kennel (\S+:\S+)/, 1]
+    end
+
+    def tracking_field(a)
+      TRACKING_FIELDS.detect { |f| a.key?(f) }
+    end
+
+    def tracking_field?(field)
+      TRACKING_FIELDS.include?(field.to_sym)
+    end
+  end
+end

data/lib/kennel/tasks.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+require "English"
+require "kennel"
+require "kennel/unmuted_alerts"
+require "kennel/importer"
+
+module Kennel
+  module Tasks
+    class << self
+      def abort(message = nil)
+        Kennel.err.puts message if message
+        raise SystemExit.new(1), message
+      end
+    end
+  end
+end
+
+namespace :kennel do
+  desc "Ensure there are no uncommited changes that would be hidden from PR reviewers"
+  task no_diff: :generate do
+    result = `git status --porcelain generated/`.strip
+    Kennel::Tasks.abort "Diff found:\n#{result}\nrun `rake generate` and commit the diff to fix" unless result == ""
+    Kennel::Tasks.abort "Error during diffing" unless $CHILD_STATUS.success?
+  end
+
+  # ideally do this on every run, but it's slow (~1.5s) and brittle (might not find all + might find false-positives)
+  # https://help.datadoghq.com/hc/en-us/requests/254114 for automatic validation
+  desc "Verify that all used monitor  mentions are valid"
+  task validate_mentions: :environment do
+    known = Kennel.send(:api)
+      .send(:request, :get, "/monitor/notifications")
+      .fetch(:handles)
+      .values
+      .flatten(1)
+      .map { |v| v.fetch(:value) }
+
+    known += ENV["KNOWN"].to_s.split(",")
+
+    bad = []
+    Dir["generated/**/*.json"].each do |f|
+      next unless message = JSON.parse(File.read(f))["message"]
+      used = message.scan(/\s(@[^\s{,'"]+)/).flatten(1)
+        .grep(/^@.*@|^@.*-/) # ignore @here etc handles ... datadog uses @foo@bar.com for emails and @foo-bar for integrations
+      (used - known).each { |v| bad << [f, v] }
+    end
+
+    if bad.any?
+      url = Kennel::Utils.path_to_url "/account/settings"
+      puts "Invalid mentions found, either ignore them by adding to `KNOWN` env var or add them via #{url}"
+      bad.each { |f, v| puts "Invalid mention #{v} in monitor message of #{f}" }
+      Kennel::Tasks.abort
+    end
+  end
+
+  desc "generate local definitions"
+  task generate: :environment do
+    Kennel.generate
+  end
+
+  # also generate parts so users see and commit updated generated automatically
+  desc "show planned datadog changes (scope with PROJECT=name)"
+  task plan: :generate do
+    Kennel.plan
+  end
+
+  desc "update datadog (scope with PROJECT=name)"
+  task update_datadog: :environment do
+    Kennel.update
+  end
+
+  desc "update on push to the default branch, otherwise show plan"
+  task :ci do
+    branch = (ENV["TRAVIS_BRANCH"] || ENV["GITHUB_REF"]).to_s.sub(/^refs\/heads\//, "")
+    on_default_branch = (branch == (ENV["DEFAULT_BRANCH"] || "master"))
+    is_push = (ENV["TRAVIS_PULL_REQUEST"] == "false" || ENV["GITHUB_EVENT_NAME"] == "push")
+    task_name =
+      if on_default_branch && is_push
+        "kennel:update_datadog"
+      else
+        "kennel:plan" # show plan in CI logs
+      end
+
+    Rake::Task[task_name].invoke
+  end
+
+  desc "show unmuted alerts filtered by TAG, for example TAG=team:foo"
+  task alerts: :environment do
+    tag = ENV["TAG"] || Kennel::Tasks.abort("Call with TAG=foo:bar")
+    Kennel::UnmutedAlerts.print(Kennel.send(:api), tag)
+  end
+
+  desc "show monitors with no data by TAG, for example TAG=team:foo"
+  task nodata: :environment do
+    tag = ENV["TAG"] || Kennel::Tasks.abort("Call with TAG=foo:bar")
+    monitors = Kennel.send(:api).list("monitor", monitor_tags: tag, group_states: "no data")
+    monitors.select! { |m| m[:overall_state] == "No Data" }
+    monitors.reject! { |m| m[:tags].include? "nodata:ignore" }
+    if monitors.any?
+      Kennel.err.puts <<~TEXT
+        This is a useful task to find monitors that have mis-spelled metrics or never received data at any time.
+        To ignore monitors with nodata, tag the monitor with "nodata:ignore"
+
+      TEXT
+    end
+
+    monitors.each do |m|
+      Kennel.out.puts m[:name]
+      Kennel.out.puts Kennel::Utils.path_to_url("/monitors/#{m[:id]}")
+      Kennel.out.puts
+    end
+  end
+
+  desc "Convert existing resources to copy-pasteable definitions to import existing resources (call with URL= or call with RESOURCE= and ID=)"
+  task import: :environment do
+    if (id = ENV["ID"]) && (resource = ENV["RESOURCE"])
+      id = Integer(id) if id =~ /^\d+$/ # dashboards can have alphanumeric ids
+    elsif (url = ENV["URL"])
+      resource, id = Kennel::Models::Record.parse_any_url(url) || Kennel::Tasks.abort("Unable to parse url")
+    else
+      possible_resources = Kennel::Models::Record.subclasses.map(&:api_resource)
+      Kennel::Tasks.abort("Call with URL= or call with RESOURCE=#{possible_resources.join(" or ")} and ID=")
+    end
+
+    Kennel.out.puts Kennel::Importer.new(Kennel.send(:api)).import(resource, id)
+  end
+
+  desc "Dump ALL of datadog config as raw json ... useful for grep/search TYPE=slo|monitor|dashboard"
+  task dump: :environment do
+    Kennel.send(:api).list(ENV.fetch("TYPE")).each do |r|
+      Kennel.out.puts JSON.pretty_generate(r)
+    end
+  end
+
+  task :environment do
+    require "kennel"
+    gem "dotenv"
+    require "dotenv"
+    source = ".env"
+
+    # warn when users have things like DATADOG_TOKEN already set and it will not be loaded from .env
+    unless ENV["KENNEL_SILENCE_UPDATED_ENV"]
+      updated = Dotenv.parse(source).select { |k, v| ENV[k] && ENV[k] != v }
+      warn "Environment variables #{updated.keys.join(", ")} need to be unset to be sourced from #{source}" if updated.any?
+    end
+
+    Dotenv.load(source)
+  end
+end