doggy 0.2.2 → 2.0.0

data/lib/doggy/model/dash.rb

@@ -1,93 +0,0 @@
-module Doggy
-  class Dash
-    def self.upload_all
-      objects = Doggy.all_local_items.find_all { |(type, id), object| type == 'dash' }
-      puts "Uploading #{objects.size} dashboards"
-      upload(objects.map { |(type, id), object| id })
-    rescue => e
-      puts "Exception: #{e.message}"
-    end
-
-    def self.download(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).save }.call([*ids])
-    end
-
-    def self.upload(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).push }.call([*ids])
-    end
-
-    def self.edit(id)
-      system %{open "https://app.datadoghq.com/dash/#{id}"}
-      if SharedHelpers.agree("Are you done?")
-        puts 'Here is the output of your edit:'
-        puts Doggy::Serializer::Json.dump(new(id: id).raw)
-      else
-        puts "run, rabbit run / dig that hole, forget the sun / and when at last the work is done / don't sit down / it's time to dig another one"
-        edit(id)
-      end
-    end
-
-    def initialize(**options)
-      @id = options[:id]
-      @title = options[:title] || raw_local['title']
-      @description = options[:description] || raw_local['description']
-      @graphs = options[:graphs] || raw_local['graphs']
-      @template_variables = options[:template_variables] || raw_local['template_variables']
-    end
-
-    def raw
-      @raw ||= begin
-        status, result = Doggy.client.dog.get_dashboard(@id)
-        result && result['dash'] && result['dash'].sort.to_h || {}
-      end
-    end
-
-    def raw_local
-      return {} unless File.exists?(path)
-      @raw_local ||= begin
-        object = Doggy.serializer.load(File.read(path))
-        object['dash'] ? object['dash'] : object
-      end
-    end
-
-    def save
-      return if raw.nil? || raw.empty?                # do not save if it's empty
-      return if raw['errors']                         # do not save if there are any errors
-      return if raw['title'] =~ Doggy::DOG_SKIP_REGEX # do not save if it had skip tag in title
-
-      File.write(path, Doggy.serializer.dump(raw))
-    end
-
-    def push
-      return unless File.exists?(path)
-      return if @title =~ Doggy::DOG_SKIP_REGEX
-      return unless Doggy.determine_type(raw_local) == 'dash'
-
-      # Managed by doggy (TM)
-      @title = @title =~ MANAGED_BY_DOGGY_REGEX ? @title : @title + " 🐶"
-
-      if @id
-        SharedHelpers.with_retry do
-          Doggy.client.dog.update_dashboard(@id, @title, @description, @graphs, @template_variables)
-        end
-      else
-        SharedHelpers.with_retry do
-          dash = Doggy.client.dog.create_dashboard(@title, @description, @graphs)
-        end
-        # FIXME: Remove duplication
-        @id = dash[1]['id']
-        @graphs = dash[1]['graphs']
-      end
-    end
-
-    def delete
-      Doggy.client.dog.delete_dashboard(@id)
-    end
-
-    private
-
-    def path
-      "#{Doggy.objects_path}/#{@id}.json"
-    end
-  end
-end

data/lib/doggy/model/monitor.rb

@@ -1,142 +0,0 @@
-module Doggy
-  class Monitor
-    def self.upload_all
-      objects = Doggy.all_local_items.find_all { |(type, id), object| type == 'monitor' }
-      puts "Uploading #{objects.size} monitors"
-      upload(objects.map { |(type, id), object| id })
-    rescue => e
-      puts "Exception: #{e.message}"
-    end
-
-    def self.download(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).save }.call([*ids])
-    end
-
-    def self.upload(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).push }.call([*ids])
-    end
-
-    def self.mute(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).mute }.call([*ids])
-    end
-
-    def self.unmute(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).unmute }.call([*ids])
-    end
-
-    def self.edit(id)
-      system %{open "https://app.datadoghq.com/monitors##{id}"}
-      if SharedHelpers.agree("Are you done?")
-        puts 'Here is the output of your edit:'
-        puts Doggy::Serializer::Json.dump(new(id: id).raw)
-      else
-        puts "run, rabbit run / dig that hole, forget the sun / and when at last the work is done / don't sit down / it's time to dig another one"
-        edit(id)
-      end
-    end
-
-    def initialize(**options)
-      @id = options[:id]
-      @query = options[:query]
-      @silenced = options[:silenced]
-      @name = options[:name]
-      @timeout_h = options[:timeout_h]
-      @message = options[:message]
-      @notify_audit = options[:notify_audit]
-      @notify_no_data = options[:notify_no_data]
-      @renotify_interval = options[:renotify_interval]
-      @escalation_message = options[:escalation_message]
-      @no_data_timeframe = options[:no_data_timeframe]
-      @silenced_timeout_ts = options[:silenced_timeout_ts]
-    end
-
-    def raw
-      @raw ||= begin
-        status, alert = Doggy.client.dog.get_monitor(@id)
-
-        return if status != '200'
-
-        alert.delete('state')                                              # delete unnecessary state
-        alert.delete('overall_state')                                      # delete unnecessary state
-        if alert['options']
-          alert['options'].delete('silenced')                              # delete unnecessary state
-          alert['options'] = alert['options'].sort.to_h                    # sort option keys; DataDog response is not ordered
-        end
-        alert && alert.sort.to_h
-      end
-    end
-
-    def raw_local
-      return unless File.exists?(path)
-      @raw_local ||= Doggy.serializer.load(File.read(path))
-    end
-
-    def save
-      return if raw.nil? || raw.empty?               # do not save if it's empty
-      return if raw['errors']                        # do not save if there are any errors
-      return if raw['name'] =~ Doggy::DOG_SKIP_REGEX # do not save if it had skip tag in title
-
-      File.write(path, Doggy.serializer.dump(raw))
-    end
-
-    def mute
-      Doggy.client.dog.mute_monitor(@id)
-    end
-
-    def unmute
-      Doggy.client.dog.unmute_monitor(@id)
-    end
-
-    def push
-      @name ||= raw_local['name']
-
-      return if @name =~ Doggy::DOG_SKIP_REGEX
-      return unless Doggy.determine_type(raw_local) == 'monitor'
-
-      # Managed by doggy (TM)
-      @name = @name =~ MANAGED_BY_DOGGY_REGEX ? @name : @name + " 🐶"
-
-      if @id
-        return unless File.exists?(path)
-
-        SharedHelpers.with_retry do
-          Doggy.client.dog.update_monitor(@id, @query || raw_local['query'], {
-            name: @name || raw_local['name'],
-            timeout_h: @timeout_h || raw_local['timeout_h'],
-            message: @message || raw_local['message'],
-            notify_audit: @notify_audit || raw_local['notify_audit'],
-            notify_no_data: @notify_no_data || raw_local['notify_no_data'],
-            renotify_interval: @renotify_interval || raw_local['renotify_interval'],
-            escalation_message: @escalation_message || raw_local['escalation_message'],
-            no_data_timeframe: @no_data_timeframe || raw_local['no_data_timeframe'],
-            silenced_timeout_ts: @silenced_timeout_ts || raw_local['silenced_timeout_ts'],
-            options: {
-              silenced: mute_state_for(@id),
-            },
-          })
-        end
-      else
-        SharedHelpers.with_retry do
-          result = Doggy.client.dog.monitor('metric alert', @query, name: @name)
-        end
-        @id = result[1]['id']
-      end
-    end
-
-    def delete
-      Doggy.client.dog.delete_alert(@id)
-    end
-
-    private
-
-    def path
-      "#{Doggy.objects_path}/#{@id}.json"
-    end
-
-    def mute_state_for(id)
-      if remote_state = Doggy.all_local_items.detect { |key, value| key == [ 'monitor', id.to_i ] }
-        remote_state[1]['options']['silenced'] if remote_state[1]['options']
-      end
-    end
-  end
-end

data/lib/doggy/model/screen.rb

@@ -1,80 +0,0 @@
-module Doggy
-  class Screen
-    def self.upload_all
-      objects = Doggy.all_local_items.find_all { |(type, id), object| type == 'screen' }
-      puts "Uploading #{objects.size} screens"
-      upload(objects.map { |(type, id), object| id })
-    rescue => e
-      puts "Exception: #{e.message}"
-    end
-
-    def self.download(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).save }.call([*ids])
-    end
-
-    def self.upload(ids)
-      Doggy::Worker.new(threads: Doggy::Worker::CONCURRENT_STREAMS) { |id| new(id: id).push }.call([*ids])
-    end
-
-    def self.edit(id)
-      system %{open "https://app.datadoghq.com/screen/#{id}"}
-      if SharedHelpers.agree("Are you done?")
-        puts 'Here is the output of your edit:'
-        puts Doggy::Serializer::Json.dump(new(id: id).raw)
-      else
-        puts "run, rabbit run / dig that hole, forget the sun / and when at last the work is done / don't sit down / it's time to dig another one"
-        edit(id)
-      end
-    end
-
-    def initialize(**options)
-      @id = options[:id]
-      @description = options[:description] || raw_local
-    end
-
-    def raw
-      @raw ||= begin
-        status, result = Doggy.client.dog.get_screenboard(@id)
-        result && result.sort.to_h
-      end
-    end
-
-    def raw_local
-      return {} unless File.exists?(path)
-      @raw_local ||= Doggy.serializer.load(File.read(path))
-    end
-
-    def save
-      return if raw['errors'] # do now download an item if it doesn't exist
-      return if raw['board_title'] =~ Doggy::DOG_SKIP_REGEX
-      return if raw.empty?
-      File.write(path, Doggy.serializer.dump(raw))
-    end
-
-    def push
-      return if @description =~ Doggy::DOG_SKIP_REGEX
-      return unless Doggy.determine_type(raw_local) == 'screen'
-      if @id
-        SharedHelpers.with_retry do
-          Doggy.client.dog.update_screenboard(@id, @description)
-        end
-      else
-        SharedHelpers.with_retry do
-          result = Doggy.client.dog.create_screenboard(@description)
-        end
-        @id = result[1]['id']
-        @description = result[1]
-      end
-    end
-
-    def delete
-      Doggy.client.dog.delete_screenboard(@id)
-    end
-
-    private
-
-    def path
-      "#{Doggy.objects_path}/#{@id}.json"
-    end
-  end
-end

data/lib/doggy/serializer/json.rb

@@ -1,15 +0,0 @@
-module Doggy
-  module Serializer
-    class Json
-      # De-serialize a Hash from JSON string
-      def self.load(string)
-        ::JSON.load(string)
-      end
-
-      # Serialize a Hash to JSON string
-      def self.dump(object, options = {})
-        ::JSON.pretty_generate(object, options) + "\n"
-      end
-    end
-  end
-end

data/lib/doggy/serializer/yaml.rb

@@ -1,15 +0,0 @@
-module Doggy
-  module Serializer
-    class Yaml
-      # De-serialize a Hash from YAML string
-      def self.load(string)
-        ::YAML.load(string)
-      end
-
-      # Serialize a Hash to YAML string
-      def self.dump(object, options = {})
-        ::YAML.dump(object, options)
-      end
-    end
-  end
-end

data/lib/doggy/shared_helpers.rb

@@ -1,63 +0,0 @@
-module Doggy
-  module SharedHelpers
-    MAX_TRIES = 5
-
-    def self.strip_heredoc(string)
-      indent = string.scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
-      string.gsub(/^[ \t]{#{indent}}/, '')
-    end
-
-    def self.with_retry(times: MAX_TRIES, reraise: false)
-      tries = 0
-      while tries < times
-        begin
-          yield
-          break
-        rescue => e
-          error "Caught error! Attempt #{tries}..."
-          error "#{e.class.name}: #{e.message}"
-          error "#{e.backtrace.join("\n")}"
-          tries += 1
-
-          raise e if tries >= times && reraise
-        end
-      end
-    end
-
-    def self.agree(prompt)
-      raise Error, "Not a tty" unless $stdin.tty?
-
-      puts prompt + " (Y/N)"
-      line = $stdin.readline.chomp.upcase
-      puts
-      line == "Y"
-    end
-
-    def self.error(msg)
-      puts "[ERROR] #{ msg }"
-    end
-
-    def self.find_root
-      File.dirname(find_file("Gemfile"))
-    end
-
-    def self.find_file(*names)
-      search_up(*names) do |filename|
-        return filename if File.file?(filename)
-      end
-    end
-
-    def self.search_up(*names)
-      previous = nil
-      current  = File.expand_path(Pathname.pwd)
-
-      until !File.directory?(current) || current == previous
-        names.each do |name|
-          filename = File.join(current, name)
-          yield filename
-        end
-        current, previous = File.expand_path("..", current), current
-      end
-    end
-  end
-end

data/lib/doggy/worker.rb

@@ -1,31 +0,0 @@
-require 'thread'
-require 'thread/pool'
-
-Thread.abort_on_exception = true
-
-module Doggy
-  class Worker
-    # Spawn 10 threads for HTTP requests.
-    CONCURRENT_STREAMS = 10
-
-    def initialize(options = {}, &runner)
-      @runner = runner
-      @threads = options.fetch(:threads)
-    end
-
-    def call(jobs)
-      results = []
-      pool = Thread::Pool.new(@threads)
-      tasks = jobs.map { |job|
-        pool.process {
-          results << [ job, @runner.call(job) ]
-        }
-      }
-      pool.shutdown
-      if task_with_errors = tasks.detect { |task| task.exception }
-        raise task_with_errors.exception
-      end
-      results
-    end
-  end
-end