datadog_backup 0.9.0

data/bin/datadog_backup

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+
+require 'logger'
+require 'optparse'
+
+require 'datadog_backup'
+require 'dogapi'
+
+$stdout.sync = $stderr.sync = true
+LOGGER = Logger.new($stderr) unless defined?(LOGGER)
+LOGGER.level = Logger::INFO
+
+##
+# Default parameters
+@options = {
+  action: nil,
+  datadog_api_key: ENV.fetch('DATADOG_API_KEY'),
+  datadog_app_key: ENV.fetch('DATADOG_APP_KEY'),
+  backup_dir: File.join(ENV.fetch('PWD'), 'backup'),
+  diff_format: :color,
+  resources: [DatadogBackup::Dashboards, DatadogBackup::Monitors],
+  output_format: :yaml,
+  logger: LOGGER
+}
+
+def prereqs
+  ARGV << '--help' if ARGV.empty?
+
+  options = OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} <backup|diffs>"
+    opts.separator ''
+    opts.on_tail('-h', '--help', 'Show this message') do
+      puts opts
+      exit 0
+    end
+    opts.on('--debug', 'debug logging') do
+      LOGGER.level = Logger::DEBUG
+    end
+    opts.on('--backup-dir PATH', '`backup` by default') do |path|
+      @options[:backup_dir] = path
+    end
+    opts.on('--monitors-only') do
+      @options[:resources] = [DatadogBackup::Monitors]
+    end
+    opts.on('--dashboards-only') do
+      @options[:resources] = [DatadogBackup::Dashboards]
+    end
+    opts.on('--json', 'format backups as JSON instead of YAML. Does not impact `diffs` nor `restore`, but do not mix.') do
+      @options[:output_format] = :json
+    end
+    opts.on('--no-color', 'removes colored output from diff format') do
+      @options[:diff_format] = nil
+    end
+    opts.on('--diff-format FORMAT', 'one of `color`, `html_simple`, `html`') do |format|
+      @options[:diff_format] = format.to_sym
+    end
+  end
+  options.parse!
+
+  @options[:action] = ARGV.first
+  if %w[backup diffs restore].include?(@options[:action])
+  else
+    puts options
+    exit 0
+  end
+end
+
+prereqs
+
+DatadogBackup::Cli.new(@options).run!

data/datadog_backup.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'datadog_backup/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'datadog_backup'
+  spec.version       = DatadogBackup::VERSION
+  spec.authors       = ['Kamran Farhadi', 'Jim Park']
+  spec.email         = ['kamranf@scribd.com', 'jimp@scribd.com']
+  spec.summary       = 'A utility to backup and restore Datadog accounts'
+  spec.description   = 'A utility to backup and restore Datadog accounts'
+  spec.homepage      = 'https://github.com/scribd/datadog_backup'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'amazing_print', '1.2.1'
+  spec.add_dependency 'concurrent-ruby', '1.1.6'
+  spec.add_dependency 'concurrent-ruby-edge', '0.6.0'
+  spec.add_dependency 'deepsort', '0.4.5'
+  spec.add_dependency 'diffy', '3.3.0'
+  spec.add_dependency 'dogapi', '1.41.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+end

data/example/.github/workflows/backup.yml

@@ -0,0 +1,31 @@
+name: backup
+
+on:
+  schedule:
+    - cron: "0 * * * *"
+  workflow_dispatch:
+
+jobs:
+  backup:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.7.1
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.7.1
+    - name: perform backup
+      env:
+        DATADOG_API_KEY: ${{ secrets.DATADOG_API_KEY }}
+        DATADOG_APP_KEY: ${{ secrets.DATADOG_APP_KEY }}
+      run: |
+          gem install --no-document bundler
+          bundle install --jobs 4 --retry 3
+          bundle exec datadog_backup backup
+    - name: commit changes
+      uses: stefanzweifel/git-auto-commit-action@v4
+      with:
+        commit_message: "Changes as of run: ${{ github.run_id }}"
+        file_pattern: backup/
+        repository: .

data/example/.gitignore

@@ -0,0 +1 @@
+.bundle/

data/example/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'datadog_backup', :source => 'https://scribd.jfrog.io/artifactory/gems-local'

data/example/README.md

@@ -0,0 +1,17 @@
+# Example-datadog-backups
+Dashboards and monitors are backed up here on an hourly basis. 
+
+Github Actions uses the [datadog_backup gem](https://github.com/scribd/datadog_backup) in order to sync the latest copy of what's in Datadog. 
+
+## Performing edits to Datadog monitors and dashboards
+1. Do it in the Datadog UI
+2. At the top of the hour, the changes will be recorded here.
+3. If you're in a rush, click on "Run workflow" from the Github Actions workflow menus
+
+## Performing bulk edits to Datadog monitors and dashboards
+1. Clone this repo
+2. `bundle install`
+3. `bundle exec datadog_backup backup` to download the latest changes in Datadog.
+4. Make your changes locally.
+5. `bundle exec datadog_backup restore` to apply your changes.
+6. Review each change and apply it (r), or download the latest copy from Datadog (d).

data/lib/datadog_backup.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'concurrent-edge'
+
+require 'dogapi'
+
+require_relative 'datadog_backup/local_filesystem'
+require_relative 'datadog_backup/options'
+
+require_relative 'datadog_backup/cli'
+require_relative 'datadog_backup/core'
+require_relative 'datadog_backup/dashboards'
+require_relative 'datadog_backup/monitors'
+require_relative 'datadog_backup/thread_pool'
+require_relative 'datadog_backup/version'
+
+module DatadogBackup
+end

data/lib/datadog_backup/cli.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'logger'
+require 'amazing_print'
+
+module DatadogBackup
+  class Cli
+    include ::DatadogBackup::Options
+
+    def all_diff_futures
+      logger.info("Starting diffs on #{::DatadogBackup::ThreadPool::TPOOL.max_length} threads")
+      any_resource_instance
+        .all_file_ids_for_selected_resources
+        .map do |id|
+        Concurrent::Promises.future_on(::DatadogBackup::ThreadPool::TPOOL, id) do |id|
+          [id, getdiff(id)]
+        end
+      end
+    end
+
+    def any_resource_instance
+      resource_instances.first
+    end
+
+    def backup
+      resource_instances.each(&:purge)
+      resource_instances.each(&:backup)
+      any_resource_instance.all_files
+    end
+
+    def initialize_client
+      @options[:client] ||= Dogapi::Client.new(
+        datadog_api_key,
+        datadog_app_key
+      )
+    end
+
+    def definitive_resource_instance(id)
+      matching_resource_instance(any_resource_instance.class_from_id(id))
+    end
+
+    def diffs
+      futures = all_diff_futures
+      ::DatadogBackup::ThreadPool.watcher(logger).join
+
+      format_diff_output(
+        Concurrent::Promises
+          .zip(*futures)
+          .value!
+          .reject { |_k, v| v.nil? }
+      )
+    end
+
+    def getdiff(id)
+      result = definitive_resource_instance(id).diff(id)
+      case result
+      when ''
+        nil
+      when "\n"
+        nil
+      when '<div class="diff"></div>'
+        nil
+      else
+        result
+      end
+    end
+
+    def format_diff_output(diff_output)
+      case diff_format
+      when nil, :color
+        diff_output.map do |id, diff|
+          " ---\n id: #{id}\n#{diff}"
+        end.join("\n")
+      when :html
+        '<html><head><style>' +
+          Diffy::CSS +
+          '</style></head><body>' +
+          diff_output.map do |id, diff|
+            "<br><br> ---<br><strong> id: #{id}</strong><br>" + diff
+          end.join('<br>') +
+          '</body></html>'
+      else
+        raise 'Unexpected diff_format.'
+      end
+    end
+
+    def initialize(options)
+      @options = options
+      initialize_client
+    end
+
+    def matching_resource_instance(klass)
+      resource_instances.select { |resource_instance| resource_instance.class == klass }.first
+    end
+
+    def resource_instances
+      @resource_instances ||= resources.map do |resource|
+        resource.new(@options)
+      end
+    end
+
+    def restore
+      futures = all_diff_futures
+      watcher = ::DatadogBackup::ThreadPool.watcher(logger)
+
+      futures.each do |future|
+        id, diff = *future.value!
+        next unless diff
+
+        puts '--------------------------------------------------------------------------------'
+        puts format_diff_output([id, diff])
+        puts '(r)estore to Datadog, overwrite local changes and (d)ownload, (s)kip, or (q)uit?'
+        response = $stdin.gets.chomp
+        case response
+        when 'q'
+          exit
+        when 'r'
+          puts "Restoring #{id} to Datadog."
+          definitive_resource_instance(id).update_with_200(id, definitive_resource_instance(id).load_from_file_by_id(id))
+        when 'd'
+          puts "Downloading #{id} from Datadog."
+          definitive_resource_instance(id).get_and_write_file(id)
+        when 's'
+          next
+        else
+          puts 'Invalid response, please try again.'
+          response = $stdin.gets.chomp
+        end
+      end
+
+      watcher.join if watcher.status
+    end
+
+    def run!
+      puts(send(action.to_sym))
+    rescue SystemExit, Interrupt
+      ::DatadogBackup::ThreadPool.shutdown(logger)
+    end
+  end
+end

data/lib/datadog_backup/core.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'diffy'
+require 'deepsort'
+
+module DatadogBackup
+  class Core
+    include ::DatadogBackup::LocalFilesystem
+    include ::DatadogBackup::Options
+
+    def api_service
+      raise 'subclass is expected to implement #api_service'
+    end
+
+    def api_version
+      raise 'subclass is expected to implement #api_version'
+    end
+
+    def api_resource_name
+      raise 'subclass is expected to implement #api_resource_name'
+    end
+
+    def backup
+      raise 'subclass is expected to implement #backup'
+    end
+
+    # Calls out to Datadog and checks for a '200' response
+    def client_with_200(method, *id)
+      max_retries = 6
+      retries ||= 0
+
+      response = client.send(method, *id)
+
+      # logger.debug response
+      raise "Method #{method} failed with error #{response}" unless response[0] == '200'
+
+      response[1]
+    rescue ::Net::OpenTimeout => e
+      if (retries += 1) <= max_retries
+        sleep(0.1 * retries**5) # 0.1, 3.2, 24.3, 102.4 seconds per retry
+        retry
+      else
+        raise "Method #{method} failed with error #{e.message}"
+      end
+    end
+
+    # Returns the diffy diff.
+    # Optionally, supply an array of keys to remove from comparison
+    def diff(id, banlist = [])
+      current = except(get_by_id(id), banlist).deep_sort.to_yaml
+      filesystem = except(load_from_file_by_id(id), banlist).deep_sort.to_yaml
+      result = ::Diffy::Diff.new(current, filesystem, include_plus_and_minus_in_html: true).to_s(diff_format)
+      logger.debug("Compared ID #{id} and found #{result}")
+      result
+    end
+
+    # Returns a hash with banlist elements removed
+    def except(hash, banlist)
+      hash.tap do # tap returns self
+        banlist.each do |key|
+          hash.delete(key) # delete returns the value at the deleted key, hence the tap wrapper
+        end
+      end
+    end
+
+    def get_and_write_file(id)
+      write_file(dump(get_by_id(id)), filename(id))
+    end
+
+    def get_by_id(_id)
+      raise 'subclass is expected to implement #get_by_id(id)'
+    end
+
+    def initialize(options)
+      @options = options
+      ::FileUtils.mkdir_p(mydir)
+    end
+
+    def myclass
+      self.class.to_s.split(':').last.downcase
+    end
+
+    def restore
+      raise 'subclass is expected to implement #restore'
+    end
+
+    def update(id, body)
+      api_service.request(Net::HTTP::Put, "/api/#{api_version}/#{api_resource_name}/#{id}", nil, body, true)
+    end
+
+    # Calls out to Datadog and checks for a '200' response
+    def update_with_200(id, body)
+      max_retries = 6
+      retries ||= 0
+
+      response = update(id, body)
+
+      # logger.debug response
+      raise "Update failed with error #{response}" unless response[0] == '200'
+
+      logger.warn "Successfully restored #{id} to datadog."
+
+      response[1]
+    rescue ::Net::OpenTimeout => e
+      if (retries += 1) <= max_retries
+        sleep(0.1 * retries**5) # 0.1, 3.2, 24.3, 102.4 seconds per retry
+        retry
+      else
+        raise "Update failed with error #{e.message}"
+      end
+    end
+  end
+end

data/lib/datadog_backup/dashboards.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DatadogBackup
+  class Dashboards < Core
+    BANLIST = %w[modified_at url]
+
+    def all_boards
+      client_with_200(:get_all_boards).fetch('dashboards')
+    end
+
+    def api_service
+      # The underlying class from Dogapi that talks to datadog
+      client.instance_variable_get(:@dashboard_service)
+    end
+
+    def api_version
+      'v1'
+    end
+
+    def api_resource_name
+      'dashboard'
+    end
+
+    def backup
+      logger.info("Starting diffs on #{::DatadogBackup::ThreadPool::TPOOL.max_length} threads")
+
+      futures = all_boards.map do |board|
+        Concurrent::Promises.future_on(::DatadogBackup::ThreadPool::TPOOL, board) do |board|
+          id = board['id']
+          get_and_write_file(id)
+        end
+      end
+
+      watcher = ::DatadogBackup::ThreadPool.watcher(logger)
+      watcher.join if watcher.status
+
+      Concurrent::Promises.zip(*futures).value!
+    end
+
+    def diff(id)
+      super(id, BANLIST)
+    end
+
+    def get_by_id(id)
+      except(client_with_200(:get_board, id), BANLIST)
+    end
+
+    def restore!; end
+  end
+end