kennel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b0f8c0885f03a37f8cd2c60d8aadb1596953267
+  data.tar.gz: 91428cc5840c0530f25103c5d94569badbd5c832
+SHA512:
+  metadata.gz: c8399a1eaa4f9f59e16e60c781f20bf9d682f49df8ba43d37bd5d103125922d97cb6371aa583212ac498759ea331084cd26371bb951d4a955244a8779862bcac
+  data.tar.gz: bfa9c9132785e9a01066cfc1c2c9fcfec66a41648636f0551bfd3f8ec94e0036a3c4b5883fcc227973b5c1f89d5d100c12d78597c51ad4f1808189d290e927bf

data/lib/kennel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require "faraday"
+require "json"
+require "English"
+
+require "kennel/utils"
+require "kennel/progress"
+require "kennel/syncer"
+require "kennel/api"
+require "kennel/github_reporter"
+require "kennel/subclass_tracking"
+require "kennel/file_cache"
+
+require "kennel/models/base"
+require "kennel/models/monitor"
+require "kennel/models/dash"
+require "kennel/models/project"
+require "kennel/models/team"
+
+module Kennel
+  class << self
+    def generate
+      FileUtils.rm_rf("generated")
+      generated.each do |part|
+        path = "generated/#{part.tracking_id.sub(":", "/")}.json"
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(part.as_json) << "\n")
+      end
+    end
+
+    def plan
+      syncer.plan
+    end
+
+    def update
+      syncer.plan
+      syncer.update if syncer.confirm
+    end
+
+    def report_plan_to_github
+      reporter = GithubReporter.new(ENV.fetch("GITHUB_TOKEN"))
+      reporter.report { plan }
+    end
+
+    private
+
+    def syncer
+      @syncer ||= Syncer.new(api, generated)
+    end
+
+    def api
+      @api ||= Api.new(ENV.fetch("DATADOG_APP_KEY"), ENV.fetch("DATADOG_API_KEY"))
+    end
+
+    def generated
+      @generated ||= begin
+        Progress.progress "Generating" do
+          load_all
+          Models::Project.recursive_subclasses.flat_map do |project_class|
+            project_class.new.parts
+          end
+        end
+      end
+    end
+
+    def load_all
+      Dir["{parts,teams,projects}/**/*.rb"].each { |f| require "./#{f}" }
+    end
+  end
+end

data/lib/kennel/api.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Kennel
+  class Api
+    def initialize(app_key, api_key)
+      @app_key = app_key
+      @api_key = api_key
+      @client = Faraday.new(url: "https://app.datadoghq.com")
+    end
+
+    def show(api_resource, id)
+      request :get, "/api/v1/#{api_resource}/#{id}"
+    end
+
+    def list(api_resource, params)
+      request :get, "/api/v1/#{api_resource}", params: params
+    end
+
+    def create(api_resource, attributes)
+      request :post, "/api/v1/#{api_resource}", body: attributes
+    end
+
+    def update(api_resource, id, attributes)
+      request :put, "/api/v1/#{api_resource}/#{id}", body: attributes
+    end
+
+    def delete(api_resource, id)
+      request :delete, "/api/v1/#{api_resource}/#{id}"
+    end
+
+    private
+
+    def request(method, path, body: nil, params: {})
+      params = params.merge(application_key: @app_key, api_key: @api_key)
+      query = Faraday::FlatParamsEncoder.encode(params)
+      response = @client.send(method, "#{path}?#{query}") do |request|
+        request.body = JSON.generate(body) if body
+        request.headers["Content-type"] = "application/json"
+      end
+      raise "Error #{method} #{path} -> #{response.status}:\n#{response.body}" unless response.success?
+      JSON.parse(response.body, symbolize_names: true)
+    end
+  end
+end

data/lib/kennel/file_cache.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# cache that reads everything from a single file
+# to avoid doing multiple disk reads while interating all definitions
+# it also replaces updated keys and has an overall expiry to not keep deleted things forever
+module Kennel
+  class FileCache
+    def initialize(file)
+      @file = file
+      @data =
+        begin
+          Marshal.load(File.read(@file)) # rubocop:disable Security/MarshalLoad
+        rescue StandardError
+          {}
+        end
+      @now = Time.now.to_i
+      @expires = @now + (30 * 24 * 60 * 60) # 1 month
+      @data.reject! { |_, (_, _, ex)| ex < @now } # expire old data
+    end
+
+    def fetch(key, version)
+      old_value, old_version = @data[key]
+      return old_value if old_version == version
+
+      new_value = yield
+      @data[key] = [new_value, version, @expires]
+      new_value
+    end
+
+    def persist
+      FileUtils.mkdir_p(File.dirname(@file))
+      File.write(@file, Marshal.dump(@data))
+    end
+  end
+end

data/lib/kennel/github_reporter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Kennel
+  class GithubReporter
+    def initialize(token)
+      @token = token
+      @git_sha = Utils.capture_sh("git rev-parse HEAD").strip
+      origin = ENV["PROJECT_REPOSITORY"] || Utils.capture_sh("git remote -v").split("\n").first
+      @repo_part = origin[%r{github\.com[:/](.+?)(\.git|$)}, 1] || raise("no origin found")
+    end
+
+    def report
+      output = Utils.strip_shell_control(Utils.capture_stdout { yield }.strip)
+    ensure
+      comment "```\n#{output || "Error"}\n```"
+    end
+
+    private
+
+    # https://developer.github.com/v3/repos/comments/#create-a-commit-comment
+    def comment(body)
+      post "commits/#{@git_sha}/comments", body: body
+    end
+
+    def post(path, data)
+      url = "https://api.github.com/repos/#{@repo_part}/#{path}"
+      response = Faraday.post(url, data.to_json, authorization: "token #{@token}")
+      raise "failed to POST to github:\n#{url} -> #{response.status}\n#{response.body}" unless response.status == 201
+    end
+  end
+end

data/lib/kennel/models/base.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+require "hashdiff"
+
+module Kennel
+  module Models
+    class Base
+      LOCK = "\u{1F512}"
+      READONLY_ATTRIBUTES = [
+        :deleted, :matching_downtimes, :id, :created, :created_at, :creator, :org_id, :modified,
+        :overall_state_modified, :overall_state, :api_resource
+      ].freeze
+
+      class << self
+        include SubclassTracking
+
+        def settings(*names)
+          duplicates = (@set & names)
+          if duplicates.any?
+            raise ArgumentError, "Settings #{duplicates.map(&:inspect).join(", ")} are already defined"
+          end
+
+          @set.concat names
+          names.each do |name|
+            next if method_defined?(name)
+            define_method name do
+              raise ArgumentError, "Trying to call #{name} for #{self.class} but it was never set or passed as option"
+            end
+          end
+        end
+
+        def defaults(options)
+          options.each do |name, block|
+            validate_setting_exists name
+            define_method name, &block
+          end
+        end
+
+        def inherited(child)
+          super
+          child.instance_variable_set(:@set, (@set || []).dup)
+        end
+
+        def validate_setting_exists(name)
+          return if !@set || @set.include?(name)
+          supported = @set.map(&:inspect)
+          raise ArgumentError, "Unsupported setting #{name.inspect}, supported settings are #{supported.join(", ")}"
+        end
+      end
+
+      def initialize(options = {})
+        validate_options(options)
+
+        options.each do |name, block|
+          self.class.validate_setting_exists name
+          define_singleton_method name, &block
+        end
+      end
+
+      def kennel_id
+        @kennel_id ||= Utils.snake_case self.class.name
+      end
+
+      def name
+        self.class.name
+      end
+
+      def diff(actual)
+        expected = as_json
+        expected.delete(:id)
+
+        READONLY_ATTRIBUTES.each { |k| actual.delete k }
+
+        diff = HashDiff.diff(actual, expected, use_lcs: false)
+        diff if diff.any?
+      end
+
+      def tracking_id
+        "#{project.kennel_id}:#{kennel_id}"
+      end
+
+      private
+
+      def validate_options(options)
+        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
+      end
+    end
+  end
+end

data/lib/kennel/models/dash.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Dash < Base
+      settings :id, :title, :description, :graphs, :kennel_id, :graphs, :definitions, :template_variables
+
+      defaults(
+        id: -> { nil },
+        description: -> { "" },
+        definitions: -> { [] },
+        graphs: -> { [] },
+        template_variables: -> { [] }
+      )
+
+      attr_reader :project
+
+      def initialize(project, *args)
+        @project = project
+        super(*args)
+      end
+
+      def self.api_resource
+        "dash"
+      end
+
+      def as_json
+        return @json if @json
+        @json = {
+          id: id,
+          title: "#{title}#{LOCK}",
+          description: description,
+          read_only: false,
+          template_variables: render_template_variables,
+          graphs: render_graphs
+        }
+
+        validate_json(@json)
+
+        @json
+      end
+
+      def diff(actual)
+        actual.delete :resource
+        actual.delete :created_by
+        actual[:template_variables] ||= []
+        actual[:graphs].each do |g|
+          g[:definition].delete(:status)
+          g[:definition][:requests].each { |r| r.delete(:aggregator) }
+        end
+        super
+      end
+
+      def url(id)
+        Utils.path_to_url "/dash/#{id}"
+      end
+
+      private
+
+      def validate_json(data)
+        variables = data.fetch(:template_variables).map { |v| "$#{v.fetch(:name)}" }
+        queries = data[:graphs].flat_map { |g| g[:definition][:requests].map { |r| r.fetch(:q) } }
+        bad = queries.grep_v(/(#{variables.map { |v| Regexp.escape(v) }.join("|")})\b/)
+        if bad.any?
+          raise "#{tracking_id} queries #{bad.join(", ")} must use the template variables #{variables.join(", ")}"
+        end
+      end
+
+      def render_template_variables
+        template_variables.map do |v|
+          v.is_a?(String) ? { default: "*", prefix: v, name: v } : v
+        end
+      end
+
+      def render_graphs
+        all = definitions.map do |title, viz, type, query|
+          { title: title, definition: { viz: viz, requests: [{ q: query, type: type }] } }
+        end + graphs
+
+        all.each do |g|
+          g[:definition][:requests].each { |r| r[:conditional_formats] ||= [] }
+          g[:definition][:autoscale] = true unless g[:definition].key?(:autoscale)
+        end
+      end
+    end
+  end
+end

data/lib/kennel/models/monitor.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Monitor < Base
+      RENOTIFY_INTERVALS = [0, 10, 20, 30, 40, 50, 60, 90, 120, 180, 240, 300, 360, 720, 1440].freeze # minutes
+      QUERY_INTERVALS = ["1m", "5m", "10m", "15m", "30m", "1h", "2h", "4h", "24h"].freeze
+      METRIC_TYPES = ["query alert", "metric alert"].freeze
+
+      settings(
+        :query, :name, :message, :escalation_message, :critical, :kennel_id, :type, :renotify_interval, :warning,
+        :ok, :id, :no_data_timeframe, :notify_no_data, :tags, :multi
+      )
+      defaults(
+        message: -> { "" },
+        escalation_message: -> { "" },
+        type: -> { "metric alert" }, # TODO: can we auto-determine that ?
+        renotify_interval: -> { 120 },
+        warning: -> { nil },
+        ok: ->  { nil },
+        id: ->  { nil },
+        notify_no_data: -> { true },
+        no_data_timeframe: -> { notify_no_data ? 60 : nil },
+        tags: -> { [] },
+        multi: ->  { !METRIC_TYPES.include?(type) || query.include?(" by ") }
+      )
+
+      attr_reader :project
+
+      def initialize(project, *args)
+        @project = project
+        super(*args)
+      end
+
+      def kennel_id
+        if self.class == Kennel::Models::Monitor
+          raise "Need to set :kennel_id when defining monitors from Kennel::Models::Monitor"
+        end
+        super
+      end
+
+      def as_json
+        return @as_json if @as_json
+        data = {
+          name: "#{name}#{LOCK}",
+          type: type,
+          query: query,
+          message: <<~TEXT.strip,
+            #{message}
+
+            @slack-#{project.team.slack}
+          TEXT
+          tags: @project.tags + tags,
+          multi: multi,
+          options: {
+            timeout_h: 0,
+            notify_no_data: notify_no_data,
+            no_data_timeframe: no_data_timeframe,
+            notify_audit: true,
+            require_full_window: true,
+            new_host_delay: 300,
+            include_tags: true,
+            escalation_message: Utils.presence(escalation_message.strip),
+            evaluation_delay: nil,
+            locked: false, # setting this to true prevents any edit and breaks updates when using replace workflow
+            renotify_interval: renotify_interval || 0,
+            thresholds: {
+              critical: critical
+            }
+          }
+        }
+
+        options = data[:options]
+        thresholds = options[:thresholds]
+
+        data[:id] = id if id
+
+        # warning and ok are optional
+        thresholds[:warning] = warning if warning
+        thresholds[:ok] = ok if ok
+
+        # metric and query values are stored as float by datadog
+        if ["metric alert", "query alert"].include? data.fetch(:type)
+          thresholds.each { |k, v| thresholds[k] = Float(v) }
+        end
+
+        validate_json(data)
+
+        @as_json = data
+      end
+
+      def self.api_resource
+        "monitor"
+      end
+
+      def url(id)
+        Utils.path_to_url "/monitors##{id}/edit"
+      end
+
+      def diff(actual)
+        options = actual.fetch(:options)
+        options.delete(:silenced) # we do not manage silenced, so ignore it when diffing
+        options[:escalation_message] ||= nil # unset field is not returned and would break the diff
+
+        # 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
+
+        # setting 0 results in thresholds not getting returned from the api
+        if actual[:type] == "event alert"
+          options[:thresholds] ||= { critical: 0 }
+        end
+
+        # fields are not returned when set to true
+        if actual[:type] == "service check"
+          options[:thresholds][:critical] ||= 1
+          options[:thresholds][:warning] ||= 1
+          options[:thresholds][:ok] ||= 1
+        end
+
+        # nil or "" are not returned from the api
+        options[:evaluation_delay] ||= nil
+
+        # datadog uses these types randomly
+        actual[:type] = type if METRIC_TYPES.include?(actual[:type])
+
+        super
+      end
+
+      private
+
+      def validate_json(data)
+        type = data.fetch(:type)
+
+        if type == "service check" && [ok, warning, critical].compact.map(&:class).uniq != [Integer]
+          raise "#{tracking_id} :ok, :warning and :critical must be integers for service check type"
+        end
+
+        if query_value = data.fetch(:query)[/\s*[<>]\s*(\d+(\.\d+)?)\s*$/, 1]
+          if Float(query_value) != Float(data.dig(:options, :thresholds, :critical))
+            raise "#{tracking_id} critical and value used in query must match"
+          end
+        end
+
+        unless RENOTIFY_INTERVALS.include? data.dig(:options, :renotify_interval)
+          raise "#{tracking_id} renotify_interval must be one of #{RENOTIFY_INTERVALS.join(", ")}"
+        end
+
+        if ["metric alert", "query alert"].include?(type)
+          interval = data.fetch(:query)[/\(last_(\S+?)\)/, 1]
+          unless QUERY_INTERVALS.include?(interval)
+            raise "#{tracking_id} query interval was #{interval}, but must be one of #{QUERY_INTERVALS.join(", ")}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kennel/models/project.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Project < Base
+      settings :team, :parts, :tags
+      defaults(
+        tags: -> { ["service:#{kennel_id}"] }
+      )
+
+      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
+    end
+  end
+end

data/lib/kennel/models/team.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Kennel
+  module Models
+    class Team < Base
+      # TODO: validate slack has no leading #
+      settings :slack, :email
+    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)
+      print "#{name} ... "
+
+      animation = "-\\|/"
+      count = 0
+      stop = false
+      result = nil
+
+      spinner = Thread.new do
+        loop do
+          break if stop
+          print animation[count % animation.size]
+          sleep 0.2
+          print "\b"
+          count += 1
+        end
+      end
+
+      time = Benchmark.realtime { result = yield }
+
+      stop = true
+      spinner.join
+      print "#{time.round(2)}s\n"
+
+      result
+    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,176 @@
+# frozen_string_literal: true
+module Kennel
+  class Syncer
+    CACHE_FILE = "tmp/cache/details" # keep in sync with .travis.yml caching
+
+    def initialize(api, expected)
+      @api = api
+      @expected = expected
+      @expected.each { |e| add_tracking_id e }
+      calculate_diff
+    end
+
+    def plan
+      puts "Plan:"
+      if noop?
+        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
+      !STDIN.tty? || Utils.ask("Execute Plan ?") unless noop?
+    end
+
+    def update
+      @create.each do |_, e|
+        reply = @api.create e.class.api_resource, e.as_json
+        puts "Created #{e.class.api_resource} #{tracking_id(e.as_json)} #{e.url(reply.fetch(:id))}"
+      end
+
+      @update.each do |id, e|
+        @api.update e.class.api_resource, id, e.as_json
+        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
+        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" do
+        download_definitions
+      end
+
+      Progress.progress "Diffing" do
+        details_cache do |cache|
+          actual.each do |a|
+            id = a.fetch(:id)
+
+            if e = delete_matching_expected(a)
+              fill_details(a, cache) if a[:api_resource] == "dash"
+              if diff = e.diff(a)
+                @update << [id, e, a, diff]
+              end
+            elsif tracking_id(a) # was previously managed
+              @delete << [id, nil, a]
+            end
+          end
+        end
+
+        ensure_all_ids_found
+        @create = @expected.map { |e| [nil, e] }
+      end
+    end
+
+    # Hack to get diff to work until we can mass-fetch definitions
+    def fill_details(a, cache)
+      args = [a.fetch(:api_resource), a.fetch(:id)]
+      full = cache.fetch(args, a.fetch(:modified)) do
+        @api.show(*args).fetch(a.fetch(:api_resource).to_sym)
+      end
+      a.merge!(full)
+    end
+
+    def details_cache
+      cache = FileCache.new CACHE_FILE
+      yield cache
+      cache.persist
+    end
+
+    def download_definitions
+      api_resources = Models::Base.subclasses.map do |m|
+        next unless m.respond_to?(:api_resource)
+        m.api_resource
+      end
+
+      api_resources.compact.uniq.flat_map do |api_resource|
+        # lookup monitors without adding unnecessary downtime information
+        results = @api.list(api_resource, with_downtimes: false)
+        if results.is_a?(Hash) # dashes
+          results = results.fetch("#{api_resource}es".to_sym) # dash reply is returned under dashes
+          results.each { |r| r[:id] = Integer(r.fetch(:id)) }
+        end
+        results.each { |c| c[:api_resource] = api_resource }
+      end
+    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 delete_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
+
+      e = @lookup_map["#{a.fetch(:api_resource)}:#{a.fetch(:id)}"] || @lookup_map[tracking_id(a)]
+      @expected.delete(e) if e
+    end
+
+    def print_plan(step, list, color)
+      return if list.empty?
+      list.each do |_, e, a, diff|
+        puts Utils.color(color, "#{step} #{tracking_id(e&.as_json || 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 = new.inspect
+          new = old.inspect
+          old = temp
+        else # ~ and -
+          old = old.inspect
+          new = new.inspect
+        end
+
+        if (old + new).size > 100
+          puts "  #{type}#{field}"
+          puts "    #{old} ->"
+          puts "    #{new}"
+        else
+          puts "  #{type}#{field} #{old} -> #{new}"
+        end
+      end
+    end
+
+    def add_tracking_id(e)
+      e.as_json[tracking_field(e.as_json)] +=
+        "\n-- Managed by kennel #{e.tracking_id} in #{e.project.class.file_location}, do not modify manually"
+    end
+
+    def tracking_id(a)
+      a[tracking_field(a)][/-- Managed by kennel (\S+:\S+)/, 1]
+    end
+
+    def tracking_field(a)
+      a[:message] ? :message : :description
+    end
+  end
+end

data/lib/kennel/utils.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module Kennel
+  module Utils
+    class << self
+      def snake_case(string)
+        string.gsub(/::/, "_") # Foo::Bar -> foo_bar
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2') # FOOBar -> foo_bar
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2') # fooBar -> foo_bar
+          .downcase
+      end
+
+      def presence(value)
+        value.empty? ? nil : value
+      end
+
+      def ask(question)
+        printf color(:red, "#{question} -  press 'y' to continue: ")
+        begin
+          STDIN.gets.chomp == "y"
+        rescue Interrupt # do not show a backtrace if user decides to Ctrl+C here
+          printf "\n"
+          exit 1
+        end
+      end
+
+      def color(color, text)
+        code = { red: 31, green: 32, yellow: 33 }.fetch(color)
+        "\e[#{code}m#{text}\e[0m"
+      end
+
+      def strip_shell_control(text)
+        text.gsub(/\e\[\d+m(.*?)\e\[0m/, "\\1").tr("\b", "")
+      end
+
+      def capture_stdout
+        $stdout = StringIO.new
+        yield
+        $stdout.string
+      ensure
+        $stdout = STDOUT
+      end
+
+      def capture_sh(command)
+        result = `#{command} 2>&1`
+        raise "Command failed:\n#{command}\n#{result}" unless $CHILD_STATUS.success?
+        result
+      end
+
+      def path_to_url(path)
+        if subdomain = ENV["DATADOG_SUBDOMAIN"]
+          "https://#{subdomain}.datadoghq.com#{path}"
+        else
+          path
+        end
+      end
+    end
+  end
+end

data/lib/kennel/version.rb

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

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: kennel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashdiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: michael@grosser.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kennel.rb
+- lib/kennel/api.rb
+- lib/kennel/file_cache.rb
+- lib/kennel/github_reporter.rb
+- lib/kennel/models/base.rb
+- lib/kennel/models/dash.rb
+- lib/kennel/models/monitor.rb
+- lib/kennel/models/project.rb
+- lib/kennel/models/team.rb
+- lib/kennel/progress.rb
+- lib/kennel/subclass_tracking.rb
+- lib/kennel/syncer.rb
+- lib/kennel/utils.rb
+- lib/kennel/version.rb
+homepage: https://github.com/grosser/kennel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Keep datadog monitors/dashboards/etc in version control, avoid chaotic management
+  via UI
+test_files: []