wavefront-client 3.5.4 → 3.6.0

data/lib/wavefront/cli/alerts.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 #     Copyright 2015 Wavefront Inc.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,24 +13,38 @@
 
 require 'wavefront/alerting'
 require 'wavefront/cli'
+require 'wavefront/mixins'
 require 'json'
+require 'yaml'
 require 'pp'
 require 'time'
 
 class Wavefront::Cli::Alerts < Wavefront::Cli
+  include Wavefront::Mixins
 
-  attr_accessor :options, :arguments
+  attr_accessor :options, :arguments, :wfa
 
   def run
     raise 'Missing token.' if ! @options[:token] || @options[:token].empty?
     raise 'Missing query.' if arguments.empty?
-    query = arguments[0].to_sym
+    valid_format?(@options[:alertformat].to_sym)
 
-    wfa = Wavefront::Alerting.new(@options[:token], @options[:endpoint],
+    @wfa = Wavefront::Alerting.new(@options[:token], @options[:endpoint],
                                   @options[:debug], {
       noop: @options[:noop], verbose: @options[:verbose]})
+
+    if options[:export]
+      export_alert(options[:'<timestamp>'])
+      return
+    end
+
+    if options[:import]
+      import_alert
+      return
+    end
+
+    query = arguments[0].to_sym
     valid_state?(wfa, query)
-    valid_format?(@options[:alertformat].to_sym)
     options = { host: @options[:endpoint] }
 
     if @options[:shared]
@@ -54,6 +66,46 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
     exit
   end
 
+  def import_alert
+    raw = load_file(options[:'<file>'])
+
+    begin
+      prepped = wfa.import_to_create(raw)
+    rescue => e
+      puts e if options[:debug]
+      raise 'could not parse input.'
+    end
+
+    begin
+      wfa.create_alert(prepped)
+      puts 'Alert imported.' unless options[:noop]
+    rescue RestClient::BadRequest
+      raise '400 error: alert probably exists.'
+    end
+  end
+
+  def export_alert(id)
+    begin
+      resp = wfa.get_alert(id)
+    rescue => e
+      puts e if @options[:debug]
+      raise 'Unable to retrieve alert.'
+    end
+
+    return if options[:noop]
+
+    case options[:alertformat].to_sym
+    when :json
+      puts JSON.pretty_generate(resp)
+    when :yaml
+      puts resp.to_yaml
+    when :human
+      puts humanize([resp])
+    else
+      puts 'unknown output format.'
+    end
+  end
+
   def format_result(result, format)
     #
     # Call a suitable method to display the output of the API call,
@@ -66,6 +118,8 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
       pp result
     when :json
       puts JSON.pretty_generate(JSON.parse(result))
+    when :yaml
+      puts JSON.parse(result).to_yaml
     when :human
       puts humanize(JSON.parse(result))
     else
@@ -137,7 +191,7 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
     # The 'created' and 'updated' timestamps are in epoch
     # milliseconds
     #
-    human_line(k, Time.at(v / 1000))
+    human_line(k, "#{Time.at(v / 1000)} (#{v})")
   end
 
   def human_line_updated(k, v)

data/lib/wavefront/cli/dashboards.rb

@@ -0,0 +1,138 @@
+require 'wavefront/dashboards'
+require 'wavefront/cli'
+require 'pathname'
+require 'json'
+require 'yaml'
+
+class Wavefront::Cli::Dashboards < Wavefront::Cli
+  attr_accessor :wfd
+
+  include Wavefront::Constants
+  include Wavefront::Mixins
+
+  def run
+    @wfd = Wavefront::Dashboards.new(
+      options[:token], options[:endpoint], options[:debug],
+      noop: options[:noop], verbose: options[:verbose]
+    )
+
+    list_dashboards if options[:list]
+    export_dash if options[:export]
+    create_dash if options[:create]
+    delete_dash if options[:delete]
+    undelete_dash if options[:undelete]
+    history_dash if options[:history]
+    clone_dash if options[:clone]
+    import_dash if options[:import]
+  end
+
+  def import_dash
+    wfd.import(load_file(options[:'<file>']).to_json, options[:force])
+    puts 'Dashboard imported' unless options[:noop]
+  rescue RestClient::BadRequest
+    raise '400 error: dashboard probably exists, and force not used'
+  end
+
+  def clone_dash
+    wfd.clone(options[:'<source_id>'], options[:'<new_id>'],
+              options[:'<new_name>'], options[:version])
+    puts 'Dashboard cloned' unless options[:noop]
+  rescue RestClient::BadRequest
+    raise '400 error: either target exists or source does not'
+  end
+
+  def history_dash
+    begin
+      resp = wfd.history(options[:'<dashboard_id>'],
+                         options[:start] || 100,
+                         options[:limit] || nil)
+    rescue RestClient::ResourceNotFound
+      raise 'Dashboard does not exist'
+    end
+
+    display_resp(resp, :human_history)
+  end
+
+  def undelete_dash
+    wfd.undelete(options[:'<dashboard_id>'])
+    puts 'dashboard undeleted' unless options[:noop]
+  rescue RestClient::ResourceNotFound
+    raise 'Dashboard does not exist'
+  end
+
+  def delete_dash
+    wfd.delete(options[:'<dashboard_id>'])
+    puts 'dashboard deleted' unless options[:noop]
+  rescue RestClient::ResourceNotFound
+    raise 'Dashboard does not exist'
+  end
+
+  def create_dash
+    wfd.create(options[:'<dashboard_id>'], options[:'<name>'])
+    puts 'dashboard created' unless options[:noop]
+  rescue RestClient::BadRequest
+    raise '400 error: dashboard probably exists'
+  end
+
+  def export_dash
+    resp = wfd.export(options[:'<dashboard_id>'], options[:version] || nil)
+    options[:dashformat] = :json if options[:dashformat] == :human
+    display_resp(resp)
+  end
+
+  def list_dashboards
+    resp = wfd.list({ private: options[:privatetag],
+                      shared: options[:sharedtag] })
+    display_resp(resp, :human_list)
+  end
+
+  def display_resp(resp, human_method = nil)
+    return if options[:noop]
+
+    case options[:dashformat].to_sym
+    when :json
+      if resp.is_a?(String)
+        puts resp
+      else
+        puts resp.to_json
+      end
+    when :yaml
+      puts resp.to_yaml
+    when :human
+      unless human_method
+        raise 'human output format is not supported by this subcommand'
+      end
+
+      send(human_method, JSON.parse(resp))
+    else
+      raise 'unsupported output format'
+    end
+  end
+
+  def human_history(resp)
+    resp.each do |rev|
+      puts format('%-4s%s (%s)', rev['version'],
+                  Time.at(rev['update_time'].to_i / 1000),
+                  rev['update_user'])
+
+      next unless rev['change_description']
+      rev['change_description'].each { |desc| puts '      ' + desc }
+    end
+  end
+
+  def human_list(resp)
+    #
+    # Simply list the dashboards we have. If the user wants more
+    #
+    max_id_width = resp.map { |s| s['url'].size }.max
+
+    puts format("%-#{max_id_width + 1}s%s", 'ID', 'NAME')
+
+    resp.each do |dash|
+      next if !options[:all] && dash['isTrash']
+      line = format("%-#{max_id_width + 1}s%s", dash['url'], dash['name'])
+      line.<< ' (in trash)' if dash['isTrash']
+      puts line
+    end
+  end
+end

data/lib/wavefront/client/version.rb

@@ -16,6 +16,6 @@ See the License for the specific language governing permissions and
 
 module Wavefront
   class Client
-    VERSION = "3.5.4"
+    VERSION = "3.6.0"
   end
 end

data/lib/wavefront/constants.rb

@@ -26,10 +26,12 @@ module Wavefront
     DEFAULT_STRICT = true
     DEFAULT_OBSOLETE_METRICS = false
     FORMATS = [ :raw, :ruby, :graphite, :highcharts, :human ]
-    ALERT_FORMATS = [:ruby, :json, :human]
+    ALERT_FORMATS = [:ruby, :json, :human, :yaml]
     SOURCE_FORMATS = [:ruby, :json, :human]
+    DASH_FORMATS = [:json, :human, :yaml]
     DEFAULT_ALERT_FORMAT = :human
     DEFAULT_SOURCE_FORMAT = :human
+    DEFAULT_DASH_FORMAT = :human
     GRANULARITIES = %w( s m h d )
     EVENT_STATE_DIR = Pathname.new('/var/tmp/wavefront/events')
     EVENT_LEVELS = %w(info smoke warn severe)
@@ -51,7 +53,8 @@ module Wavefront
       format:       DEFAULT_FORMAT,        # ts output format
       alertformat:  DEFAULT_ALERT_FORMAT,  # alert command output format
       infileformat: DEFAULT_INFILE_FORMAT, # batch writer file format
-      sourceformat: DEFAULT_SOURCE_FORMAT, # source more output format
+      sourceformat: DEFAULT_SOURCE_FORMAT, # source output format
+      dashformat:   DEFAULT_DASH_FORMAT,   # dashboard output format
     }.freeze
   end
 end

data/lib/wavefront/dashboards.rb

@@ -0,0 +1,106 @@
+require_relative 'client/version'
+require_relative 'exception'
+require 'rest_client'
+require 'uri'
+require 'logger'
+require 'wavefront/constants'
+require 'wavefront/mixins'
+
+module Wavefront
+  #
+  # Wrappers around the v1 dashboards API
+  #
+  class Dashboards
+    include Wavefront::Constants
+    include Wavefront::Mixins
+    DEFAULT_PATH = '/api/dashboard/'.freeze
+
+    attr_reader :headers, :noop, :verbose, :endpoint
+
+    def initialize(token, host = DEFAULT_HOST, debug = false, options = {})
+      #
+      # Following existing convention, 'host' is the Wavefront API endpoint.
+      #
+      @headers = { :'X-AUTH-TOKEN' => token }
+      @endpoint = host
+      debug(debug)
+      @noop = options[:noop]
+      @verbose = options[:verbose]
+    end
+
+    def import(schema, force = false)
+      #
+      # Imports a dashboard described as a JSON string (schema)
+      #
+      qs = force ? nil : 'rejectIfExists=true'
+      call_post(create_uri(qs: qs), schema, 'application/json')
+    end
+
+    def clone(source_id, dest_id, dest_name, source_ver = nil)
+      #
+      # Clone a dashboard. If source_ver is not truthy, the latest
+      # version of the source is used.
+      #
+      qs = hash_to_qs(name: dest_name, url: dest_id)
+      qs.<< "&v=#{source_ver}" if source_ver
+
+      call_post(create_uri(path: uri_concat(source_id, 'clone')), qs,
+                'application/x-www-form-urlencoded')
+    end
+
+    def history(id, start = 100, limit = nil)
+      qs = "start=#{start}"
+      qs.<< "&limit=#{limit}" if limit
+
+      call_get(create_uri(path: uri_concat(id, 'history'), qs: qs))
+    end
+
+    def list(opts = {})
+      qs = []
+
+      opts[:private].map { |t| qs.<< "userTag=#{t}" } if opts[:private]
+      opts[:shared].map { |t| qs.<< "customerTag=#{t}" } if opts[:shared]
+
+      call_get(create_uri(qs: qs.join('&')))
+    end
+
+    def undelete(id)
+      call_post(create_uri(path: uri_concat(id, 'undelete')))
+    end
+
+    def delete(id)
+      call_post(create_uri(path: uri_concat(id, 'delete')))
+    end
+
+    def export(id, version = nil)
+      path = version ? uri_concat(id, version) : id
+      resp = call_get(create_uri(path: path)) || '{}'
+      JSON.parse(resp)
+    end
+
+    def create(id, name)
+      call_post(create_uri(path: uri_concat([id, 'create'])),
+                "name=#{URI.encode(name)}",
+                'application/x-www-form-urlencoded')
+    end
+
+    def create_uri(options = {})
+      #
+      # Build the URI we use to send a 'create' request.
+      #
+      options[:host] ||= endpoint
+      options[:path] ||= ''
+      options[:qs]   ||= nil
+
+      URI::HTTPS.build(
+        host:  options[:host],
+        path:  uri_concat(DEFAULT_PATH, options[:path]),
+        query: options[:qs]
+      )
+    end
+
+    def debug(enabled)
+      RestClient.log = 'stdout' if enabled
+    end
+  end
+end

data/lib/wavefront/metadata.rb

@@ -209,40 +209,6 @@ module Wavefront
       )
     end
 
-    def call_get(uri)
-      if (verbose || noop)
-        puts 'GET ' + uri.to_s
-        puts 'HEADERS ' + headers.to_s
-      end
-      return if noop
-      RestClient.get(uri.to_s, headers)
-    end
-
-    def call_delete(uri)
-      if (verbose || noop)
-        puts 'DELETE ' + uri.to_s
-        puts 'HEADERS ' + headers.to_s
-      end
-      return if noop
-      RestClient.delete(uri.to_s, headers)
-    end
-
-    def call_post(uri, query = nil)
-      h = headers
-      if (verbose || noop)
-        puts 'POST ' + uri.to_s
-        puts 'QUERY ' + query if query
-        puts 'HEADERS ' + h.to_s
-      end
-      return if noop
-
-      RestClient.post(uri.to_s, query,
-                      h.merge(:'Content-Type' => 'text/plain',
-                              :Accept         => 'application/json'
-                             )
-                     )
-    end
-
     def debug(enabled)
       RestClient.log = 'stdout' if enabled
     end

data/lib/wavefront/mixins.rb

@@ -33,14 +33,12 @@ module Wavefront
       #
       # Return a time as an integer, however it might come in.
       #
-      begin
-        return t if t.is_a?(Integer)
-        return t.to_i if t.is_a?(Time)
-        return t.to_i if t.is_a?(String) && t.match(/^\d+$/)
-        DateTime.parse("#{t} #{Time.now.getlocal.zone}").to_time.utc.to_i
-      rescue
-        raise "cannot parse timestamp '#{t}'."
-      end
+      return t if t.is_a?(Integer)
+      return t.to_i if t.is_a?(Time)
+      return t.to_i if t.is_a?(String) && t.match(/^\d+$/)
+      DateTime.parse("#{t} #{Time.now.getlocal.zone}").to_time.utc.to_i
+    rescue
+      raise "cannot parse timestamp '#{t}'."
     end
 
     def time_to_ms(t)
@@ -62,5 +60,56 @@ module Wavefront
     def uri_concat(*args)
       args.join('/').squeeze('/')
     end
+
+    def call_get(uri)
+      if verbose || noop
+        puts 'GET ' + uri.to_s
+        puts 'HEADERS ' + headers.to_s
+      end
+      return if noop
+      RestClient.get(uri.to_s, headers)
+    end
+
+    def call_post(uri, query = nil, ctype = 'text/plain')
+      h = headers
+      if verbose || noop
+        puts 'POST ' + uri.to_s
+        puts 'QUERY ' + query if query
+        puts 'HEADERS ' + h.to_s
+      end
+      return if noop
+
+      RestClient.post(uri.to_s, query,
+                      h.merge(:'Content-Type' => ctype,
+                              :Accept         => 'application/json'))
+    end
+
+    def call_delete(uri)
+      if verbose || noop
+        puts 'DELETE ' + uri.to_s
+        puts 'HEADERS ' + headers.to_s
+      end
+      return if noop
+      RestClient.delete(uri.to_s, headers)
+    end
+
+    def load_file(path)
+      #
+      # Give it a path to a file (as a string) and it will return the
+      # contents of that file as a Ruby object. Automatically detects
+      # JSON and YAML. Raises an exception if it doesn't look like
+      # either.
+      #
+      file = Pathname.new(path)
+      raise 'Import file does not exist.' unless file.exist?
+
+      if file.extname == '.json'
+        JSON.parse(IO.read(file))
+      elsif file.extname == '.yaml' || file.extname == '.yml'
+        YAML.load(IO.read(file))
+      else
+        raise 'Unsupported file format.'
+      end
+    end
   end
 end