wavefront-cli 0.0.2

data/lib/wavefront-cli/exception.rb

@@ -0,0 +1,5 @@
+module WavefrontCli
+  class Exception
+    class UnhandledCommand < ::Exception; end
+  end
+end

data/lib/wavefront-cli/externallink.rb

@@ -0,0 +1,16 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'externallink' API.
+  #
+  class ExternalLink < WavefrontCli::Base
+    def validator_method
+      :wf_link_id?
+    end
+
+    def validator_exception
+      Wavefront::Exception::InvalidExternalLinkId
+    end
+  end
+end

data/lib/wavefront-cli/maintenancewindow.rb

@@ -0,0 +1,16 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'maintenancewindow' API.
+  #
+  class MaintenanceWindow < WavefrontCli::Base
+    def validator_method
+      :wf_maintenance_window_id?
+    end
+
+    def validator_exception
+      Wavefront::Exception::InvalidMaintenanceWindowId
+    end
+  end
+end

data/lib/wavefront-cli/message.rb

@@ -0,0 +1,19 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'message' API.
+  #
+  class Message < WavefrontCli::Base
+    #
+    # There's an extra flag to "list" that no other commands have.
+    #
+    def do_list
+      wf.list(options[:offset] || 0, options[:limit] || 100, !options[:all])
+    end
+
+    def do_mark
+      wf.read(options[:'<id>'])
+    end
+  end
+end

data/lib/wavefront-cli/metric.rb

@@ -0,0 +1,24 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'metric' API.
+  #
+  class Metric < WavefrontCli::Base
+    #
+    # There's an extra describe flag that other classes don't have.
+    #
+    def do_describe
+      wf.detail(options[:'<metric>'], options[:glob] || [], options[:offset])
+    end
+
+    def extra_validation
+      return unless options[:'<metric>']
+      begin
+        wf_metric_name?(options[:'<metric>'])
+      rescue Wavefront::Exception::InvalidMetricName
+        abort "'#{options[:'<metric>']}' is not a valid metric."
+      end
+    end
+  end
+end

data/lib/wavefront-cli/opt_handler.rb

@@ -0,0 +1,62 @@
+require 'inifile'
+require 'pathname'
+require_relative './constants.rb'
+
+module WavefrontCli
+  #
+  # Options to commands can come from three sources, with the
+  # following order of precedence: program defaults, a configuration
+  # file, and command-line options. Docopt is not well suited to
+  # this, as it will "fill in" any missing options with defaults,
+  # producing a single hash which must be merged with values from
+  # the config file. Assuming we give the command-line higher
+  # precedence, a default value, not supplied by the user, will
+  # override a value in the config file. The other way round, and
+  # you can't override anything in the config file from the
+  # command-line. I think this behaviour is far from unique to
+  # Docopt.
+  #
+  # So, we have a hash of defaults, and we do the merging ourselves,
+  # in this class. We trick Docopt into not using the defaults by
+  # avoiding the magic string 'default: ' in our options stanzas.
+  #
+  class OptHandler
+    include WavefrontCli::Constants
+
+    attr_reader :opts, :cli_opts, :conf_file
+
+    def initialize(conf_file, cli_opts = {})
+      @conf_file = if cli_opts.key?(:config) && cli_opts[:config]
+                     Pathname.new(cli_opts[:config])
+                   else
+                     conf_file
+                   end
+
+      @cli_opts = cli_opts.reject { |_k, v| v.nil? }
+
+      @opts = DEFAULT_OPTS.merge(load_profile).merge(@cli_opts)
+    end
+
+    def load_profile
+      #
+      # Load in configuration options from the (optionally) given
+      # section of an ini-style configuration file. If the file's
+      # not there, we don't consider that an error. Returns a hash
+      # of options which matches what Docopt gives us.
+      #
+      unless conf_file.exist?
+        puts "config file '#{conf_file}' not found. Taking options " \
+             'from command-line.'
+        return {}
+      end
+
+      pf = cli_opts.fetch(:profile, 'default')
+
+      puts "reading '#{pf}' profile from '#{conf_file}'" if cli_opts[:debug]
+
+      IniFile.load(conf_file)[pf].each_with_object({}) do |(k, v), memo|
+        memo[k.to_sym] = v
+      end
+    end
+  end
+end

data/lib/wavefront-cli/proxy.rb

@@ -0,0 +1,22 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'proxy' API.
+  #
+  class Proxy < WavefrontCli::Base
+    def do_rename
+      wf_string?(options[:'<name>'])
+      wf.rename(options[:'<id>'], options[:'<name>'])
+    end
+
+    def extra_validation
+      return unless options[:'<name>']
+      begin
+        wf_string?(options[:'<name>'])
+      rescue Wavefront::Exception::InvalidString
+        abort "'#{options[:'<name>']}' is not a valid proxy name."
+      end
+    end
+  end
+end

data/lib/wavefront-cli/query.rb

@@ -0,0 +1,74 @@
+require 'wavefront-sdk/mixins'
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'query' API.
+  #
+  class Query < WavefrontCli::Base
+    include Wavefront::Mixins
+
+    def do_default
+      opts = {
+        autoEvents:             options[:events],
+        i:                      options[:inclusive],
+        summarization:          options[:summarize] || 'mean',
+        listMode:               true,
+        strict:                 true,
+        includeObsoleteMetrics: options[:obsolete],
+        sorted:                 true
+      }
+
+      if options[:start]
+        options[:start] = parse_time(options[:start], true)
+      else
+        options[:start] = (Time.now - 600).to_i
+      end
+
+      if options[:end]
+        options[:end] = parse_time(options[:end], true)
+        t_end = options[:end]
+      else
+        t_end = Time.now.to_i
+      end
+
+      options[:granularity] ||= default_granularity((t_end -
+                                                    options[:start]).to_i)
+
+      opts[:n] = options[:name] if options[:name]
+      opts[:p] = options[:points] if options[:points]
+
+      wf.query(options[:'<query>'], options[:granularity],
+               options[:start], options[:end] || nil, opts)
+    end
+
+
+    # Work out a sensible granularity based on the time window
+    #
+    def default_granularity(window)
+      if window < 300
+        :s
+      elsif window < 10800
+        :m
+      elsif window < 259200
+        :h
+      else
+        :d
+      end
+    end
+
+    def extra_validation
+      return unless options[:granularity]
+      begin
+        wf_granularity?(options[:granularity])
+      rescue Wavefront::Exception::InvalidGranularity
+        abort "'#{options[:granularity]}' is not a valid granularity."
+      end
+    end
+
+    def do_raw
+      wf.raw(options[:'<metric>'], options[:host], options[:start],
+             options[:end])
+    end
+  end
+end

data/lib/wavefront-cli/savedsearch.rb

@@ -0,0 +1,24 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'savedsearch' API.
+  #
+  class SavedSearch < WavefrontCli::Base
+    def do_list
+      wf.list(options[:offset] || 0, options[:limit] || 100)
+    end
+
+    def do_describe
+      wf.describe(options[:'<id>'])
+    end
+
+    def do_delete
+      wf.delete(options[:'<id>'])
+    end
+
+    def validator_exception
+      Wavefront::Exception::InvalidSavedSearchId
+    end
+  end
+end

data/lib/wavefront-cli/source.rb

@@ -0,0 +1,20 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'source' API.
+  #
+  class Source < WavefrontCli::Base
+    def do_clear
+      wf.delete(options[:'<id>'])
+    end
+
+    def do_description_set
+      wf.update(options[:'<id>'], description: options[:'<description>'])
+    end
+
+    def do_description_clear
+      wf.update(options[:'<id>'], { description: ''}, false)
+    end
+  end
+end

data/lib/wavefront-cli/user.rb

@@ -0,0 +1,25 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'user' API.
+  #
+  class User < WavefrontCli::Base
+    def do_list
+      wf.list
+    end
+
+    def do_grant
+      wf.grant(options[:'<id>'], options[:'<privilege>'])
+    end
+
+    def do_revoke
+      wf.revoke(options[:'<id>'], options[:'<privilege>'])
+    end
+
+    def import_to_create(raw)
+      raw['emailAddress'] = raw['identifier']
+      raw.delete_if { |k, _v| k == 'customer' || k == 'identifier' }
+    end
+  end
+end

data/lib/wavefront-cli/version.rb

@@ -0,0 +1 @@
+WF_CLI_VERSION = '0.0.2'.freeze

data/lib/wavefront-cli/webhook.rb

@@ -0,0 +1,8 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'webhook' API.
+  #
+  class Webhook < WavefrontCli::Base; end
+end

data/lib/wavefront-cli/write.rb

@@ -0,0 +1,244 @@
+require 'wavefront-sdk/mixins'
+require_relative './base'
+
+module WavefrontCli
+  #
+  # Send points to a proxy.
+  #
+  class Write < Base
+    attr_reader :fmt
+    include Wavefront::Mixins
+
+    def mk_creds
+      { proxy: options[:proxy], port: options[:port] || 2878 }
+    end
+
+    def do_point
+      p = { path:  options[:'<metric>'],
+            value: options[:'<value>'].to_f,
+            tags:  tags_to_hash(options[:tag]) }
+
+      p[:source] = options[:host] if options[:host]
+      p[:ts] = parse_time(options[:time]) if options[:time]
+
+      begin
+        wf.write(p)
+      rescue Wavefront::Exception::InvalidEndpoint
+        abort 'could not speak to proxy ' \
+              "'#{options[:proxy]}:#{options[:port]}'."
+      end
+    end
+
+    def do_file
+      valid_format?(options[:infileformat])
+      setup_fmt(options[:infileformat] || 'tmv')
+      process_input(options[:'<file>'])
+    end
+
+    # Read the input, from a file or from STDIN, and turn each line
+    # into Wavefront points.
+    #
+    def process_input(file)
+      if file == '-'
+        read_stdin
+      else
+        data = load_data(Pathname.new(file)).split("\n").map do |l|
+          process_line(l)
+        end
+
+        wf.write(data)
+      end
+    end
+
+    # Read from standard in and stream points through an open
+    # socket. If the user hits ctrl-c, close the socket and exit
+    # politely.
+    #
+    def read_stdin
+      wf.open
+      STDIN.each_line { |l| wf.write(process_line(l.strip), false) }
+      wf.close
+    rescue SystemExit, Interrupt
+      puts 'ctrl-c. Exiting.'
+      wf.close
+      exit 0
+    end
+
+    # Find and return the value in a chunked line of input
+    #
+    # param chunks [Array] a chunked line of input from #process_line
+    # return [Float] the value
+    # raise TypeError if field does not exist
+    # raise Wavefront::Exception::InvalidValue if it's not a value
+    #
+    def extract_value(chunks)
+      v = chunks[fmt.index('v')]
+      v.to_f
+    end
+
+    # Find and return the source in a chunked line of input.
+    #
+    # param chunks [Array] a chunked line of input from #process_line
+    # return [Float] the timestamp, if it is there, or the current
+    #   UTC time if it is not.
+    # raise TypeError if field does not exist
+    #
+    def extract_ts(chunks)
+      ts = chunks[fmt.index('t')]
+      return parse_time(ts) if valid_timestamp?(ts)
+    rescue TypeError
+      Time.now.utc.to_i
+    end
+
+    def extract_tags(chunks)
+      tags_to_hash(chunks.last.split(/\s(?=(?:[^"]|"[^"]*")*$)/))
+    end
+
+    # Find and return the metric path in a chunked line of input.
+    # The path can be in the data, or passed as an option, or both.
+    # If the latter, then we assume the option is a prefix, and
+    # concatenate the value in the data.
+    #
+    # param chunks [Array] a chunked line of input from #process_line
+    # return [String] the metric path
+    # raise TypeError if field does not exist
+    #
+    def extract_path(chunks)
+      m = chunks[fmt.index('m')]
+      return options[:metric] ? [options[:metric], m].join('.') : m
+    rescue TypeError
+      return options[:metric] if options[:metric]
+      raise
+    end
+
+    # Find and return the source in a chunked line of input.
+    #
+    # param chunks [Array] a chunked line of input from #process_line
+    # return [String] the source, if it is there, or if not, the
+    #   value passed through by -H, or the local hostname.
+    #
+    def extract_source(chunks)
+      return chunks[fmt.index('s')]
+    rescue TypeError
+      options[:source] || Socket.gethostname
+    end
+
+    # Process a line of input, as described by the format string
+    # held in @fmt. Produces a hash suitable for the SDK to send on.
+    #
+    # We let the user define most of the fields, but anything beyond
+    # what they define is always assumed to be point tags.  This is
+    # because you can have arbitrarily many of those for each point.
+    #
+    def process_line(l)
+      return true if l.empty?
+      chunks = l.split(/\s+/, fmt.length)
+      raise 'wrong number of fields' unless enough_fields?(l)
+
+      begin
+        point = { path:  extract_path(chunks),
+                  value: extract_value(chunks) }
+        point[:ts] = extract_ts(chunks) if fmt.include?('t')
+        point[:source] = extract_source(chunks) if fmt.include?('s')
+        point[:tags] = line_tags(chunks)
+      rescue TypeError
+        raise "could not process #{l}"
+      end
+
+      point
+    end
+
+    # We can get tags from the file, from the -T option, or both.
+    # Merge them, making the -T win if there is a collision.
+    #
+    def line_tags(chunks)
+      file_tags =  fmt.last == 'T' ? extract_tags(chunks) : {}
+      opt_tags = tags_to_hash(options[:tag])
+      file_tags.merge(opt_tags)
+    end
+
+    # Takes an array of key=value tags (as produced by docopt) and
+    # turns it into a hash of key: value tags.  Anything not of the
+    # form key=val is dropped.  If key or value are quoted, we
+    # remove the quotes.
+    #
+    # @param tags [Array]
+    # return Hash
+    #
+    def tags_to_hash(tags)
+      return nil unless tags
+
+      [tags].flatten.each_with_object({}) do |t, ret|
+        k, v = t.split('=', 2)
+        k.gsub!(/^["']|["']$/, '')
+        ret[k] = v.to_s.gsub(/^["']|["']$/, '') if v
+      end
+    end
+
+    # The format string must contain a 'v'. It must not contain
+    # anything other than 'm', 't', 'T', 's', or 'v', and the 'T',
+    # if there, must be at the end. No letter must appear more than
+    # once.
+    #
+    # @param fmt [String] format of input file
+    #
+    def valid_format?(fmt)
+      if fmt.include?('v') && fmt.match(/^[mstv]+T?$/) &&
+         fmt == fmt.split('').uniq.join
+        return true
+      end
+
+      raise 'Invalid format string.'
+    end
+
+    # Make sure we have the right number of columns, according to
+    # the format string. We want to take every precaution we can to
+    # stop users accidentally polluting their metric namespace with
+    # junk.
+    #
+    # If the format string says we are expecting point tags, we
+    # may have more columns than the length of the format string.
+    #
+    def enough_fields?(l)
+      ncols = l.split.length
+
+      if fmt.include?('T')
+        return false unless ncols >= fmt.length
+      else
+        return false unless ncols == fmt.length
+      end
+
+      true
+    end
+
+    # Although the SDK does value checking, we'll add another layer
+    # of input checing here.  See if the time looks valid. We'll
+    # assume anything before 2000/01/01 or after a year from now is
+    # wrong.  Arbitrary, but there has to be a cut-off somewhere.
+    #
+    def valid_timestamp?(ts)
+      (ts.is_a?(Integer) || ts.match(/^\d+$/)) &&
+        ts.to_i > 946684800 && ts.to_i < (Time.now.to_i + 31557600)
+    end
+
+    def validate_opts
+      unless options[:metric] || options[:format].include?('m')
+        abort "Supply a metric path in the file or with '-m'."
+      end
+
+      raise 'Please supply a proxy address.' unless options[:proxy]
+    end
+
+    private
+
+    def setup_fmt(fmt)
+      @fmt = fmt.split('')
+    end
+
+    def load_data(file)
+      IO.read(file)
+    rescue
+      raise "Cannot open file '#{file}'." unless file.exist?
+    end
+  end
+end