wavefront-cli 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0712d7ce74bb2e1b5d61a0bbbe33f90fdd36c9d79d41d481b392f903f46228b3
-  data.tar.gz: 6fd070960f3e2184d31f3ce6b3c25c2ebbdbb512934e7236b4468d3ee26fa094
+  metadata.gz: 903c8e5083d5ea318618590cf9e366f451e6cf044037c9771791dd647703ec68
+  data.tar.gz: 7e4fe291218861044b5d117806eaecc17457da88079704fc3394eaebfcfabeca
 SHA512:
-  metadata.gz: 84a8143458a13242879ffb590abcee1d98b505e85ce59889423bc83d76d11394193baf17c66a112af20c9e8b16b140907ee0e4d674c8a7f422f850c30edf0fa5
-  data.tar.gz: 99c7f6877e10db8f529b3bda1dbdfc8ff3e15db2aa595e69d35ac3cf09f514342b33ce91397fcf7cda100c246e1a279801bf76adff3c0ffff3f682eda268f902
+  metadata.gz: eb2afd54929d82f8f97dfee37de753f8c25d4e9f4f31c8413e174446f0d90264122b1002162b3beab2ce0f0caaddf52d029a71ca61a3178b4a99c4e698626761
+  data.tar.gz: 234cb0155c0abaffac24583945bdd4311d049dfec3788f5961fdc579de9339fc6ef4033c83cbdac92e7e7e7301ab7a453178e5ae94137f9ba0d1d212e3d02a6f

data/.travis.yml

@@ -15,3 +15,7 @@ deploy:
     tags: true
     repo: snltd/wavefront-cli
     ruby: 2.3.6
+notifications:
+  email: false
+  slack:
+    secure: YrwfBiBscjUCHZIyPHH/FEm5VbHZN3AczHnlOJfETsAdsVpM+JOvHnoCaY0AGjvCvmFMPE9yg11yhwMfXZJVwjAC6b75VrXoCFIvC1tjLqFizuI4VBZXUZk3CQZK0pIh1ZRYVINa0LuYLDyxF0EG2N9KTYqQcMEsBwsVohsca+zjbjyIW5H0FeVWJC4QlFqVHBwFHvylfHnPjh0pQAn3sE9j7Of3W2HQVM753/lsOkMf3sHYOv8AOrzjTNqyrageTxUGnO91S41DirNdesrjF8Qg+/s1RSiNeYSZLkqI2pk+3sdkMkpA+2z2zQ/ZbgudS/38AVlh2Wb2KkmFw0+XhdpUGqQZgLlgWMDKoiS7j2dNQ3zA4guCZIQSW6gqR76wTUqeCZQ3UNalChAhACFnG0FmZj+AIE72r28dOH747zKEmTaoJt5FR7GlSoG6cH1EV9qTeIjZ/33ehL703E6qrWITjQ6VrNrPsTCt8rvoW2MV8TP9qb32JVJqWxabqUMBicIWLEeDjPyAmOZs32cWwfk9zcJ6hIJcFffkxgVJN0vU6Qi4tGWUmYK12EIclVgrKgvN1yHUrUN/r7+sUPX9WRj82RNFU6RSPircekV9oWj9Hr8A2imnFqiMTnPpSb56y02cG9FbwFPqxLSaNNV4lALzoBmluKv0RSeEWhRvrGI=

data/lib/wavefront-cli/base.rb

@@ -193,12 +193,20 @@ module WavefrontCli
 
       unless check_status(data.status)
         handle_error(method, data.status.code) if format_var == :human
-        abort "API #{data.status.code}: #{data.status.message}."
+        display_api_error(data.status)
       end
 
       handle_response(data.response, format_var, method)
     end
 
+    # @param status [Map] status object from SDK response
+    # @return System exit
+    #
+    def display_api_error(status)
+      msg = status.message || 'No further information'
+      abort format('ERROR: API code %s: %s.', status.code, msg)
+    end
+
     def display_no_api_response(data, method)
       handle_response(data, format_var, method)
     end
@@ -216,21 +224,29 @@ module WavefrontCli
     end
 
     def handle_response(resp, format, method)
-      case format
-      when :json
-        puts resp.to_json
-      when :yaml # We don't want the YAML keys to be symbols.
-        puts JSON.parse(resp.to_json).to_yaml
-      when :ruby
-        p resp
-      when :human
+      if format == :human
         k = load_display_class
         k.new(resp, options).run(method)
       else
-        raise "Unknown output format '#{format}'."
+        parseable_output(format, resp)
       end
     end
 
+    def parseable_output(format, resp)
+      options[:class] = klass_word
+      options[:hcl_fields] = hcl_fields
+      require_relative File.join('output', format.to_s)
+      oclass = Object.const_get(format('WavefrontOutput::%s',
+                              format.to_s.capitalize))
+      oclass.new(resp, options).run
+    rescue LoadError
+      raise "Unsupported output format '#{format}'."
+    end
+
+    def hcl_fields
+      []
+    end
+
     def load_display_class
       require_relative File.join('display', klass_word)
       Object.const_get(klass.name.sub('Wavefront', 'WavefrontDisplay'))

data/lib/wavefront-cli/base_write.rb

@@ -0,0 +1,231 @@
+require 'wavefront-sdk/mixins'
+require_relative './base'
+
+module WavefrontCli
+  #
+  # Send points to a proxy.
+  #
+  class BaseWrite < Base
+    attr_reader :fmt
+    include Wavefront::Mixins
+
+    def do_point
+      p = { path:  options[:'<metric>'],
+            value: options[:'<value>'].delete('\\').to_f,
+            tags:  tags_to_hash(options[:tag]) }
+
+      p[:source] = options[:host] if options[:host]
+      p[:ts] = parse_time(options[:time]) if options[:time]
+      send_point(p)
+    end
+
+    def send_point(p)
+      wf.write(p)
+    rescue Wavefront::Exception::InvalidEndpoint
+      abort "could not speak to proxy #{options[:proxy]}:#{options[:port]}."
+    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
+      open_connection
+      STDIN.each_line { |l| wf.write(process_line(l.strip), false) }
+      close_connection
+    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 > 946_684_800 && ts.to_i < (Time.now.to_i + 31_557_600)
+    end
+
+    private
+
+    def setup_fmt(fmt)
+      @fmt = fmt.split('')
+    end
+
+    def load_data(file)
+      raise "Cannot open file '#{file}'." unless file.exist?
+      IO.read(file)
+    end
+  end
+end

data/lib/wavefront-cli/commands/report.rb

@@ -0,0 +1,35 @@
+require_relative './base'
+
+# Define the report command.
+#
+class WavefrontCommandReport < WavefrontCommandBase
+  def description
+    'send data directly to Wavefront'
+  end
+
+  def _commands
+    ["point #{CMN} [-s time] [-H host] [-T tag...] <metric> <value>",
+     "file #{CMN} [-H host] [-F format] [-m metric] [-T tag...] <file>"]
+  end
+
+  def _options
+    [common_options,
+     '-s, --time=TIME            time of data point (omit to use ' \
+     'current time)',
+     '-H, --host=STRING          source host', \
+     '-T, --tag=TAG              point tag in key=value form',
+     '-F, --infileformat=STRING  format of input file or stdin',
+     '-m, --metric=STRING        the metric path to which contents of ' \
+     'a file will be assigned. If the file contains a metric name, ' \
+     'the two will be dot-concatenated, with this value first',
+     "-q, --quiet                don't report the points sent summary " \
+     '(unless there were errors)']
+  end
+
+  def postscript
+    'Files are whitespace separated, and fields can be defined ' \
+    "with the '-F' option.  Use 't' for timestamp; 'm' for metric " \
+    "name; 'v' for value, 's' for source, and 'T' for tags. Put 'T' " \
+    'last.'.cmd_fold(TW, 0)
+  end
+end

data/lib/wavefront-cli/commands/write.rb

@@ -8,9 +8,9 @@ class WavefrontCommandWrite < WavefrontCommandBase
   end
 
   def _commands
-    ['point [-DnV] [-c file] [-P profile] [-E proxy] [-t time] ' \
+    ['point [-DnViq] [-c file] [-P profile] [-E proxy] [-t time] ' \
      '[-p port] [-H host] [-T tag...] <metric> <value>',
-     'file [-DnV] [-c file] [-P profile] [-E proxy] [-H host] ' \
+     'file [-DnViq] [-c file] [-P profile] [-E proxy] [-H host] ' \
      '[-p port] [-F format] [-m metric] [-T tag...] ' \
      '[-r rate] <file>']
   end
@@ -25,6 +25,9 @@ class WavefrontCommandWrite < WavefrontCommandBase
      '-m, --metric=STRING        the metric path to which contents of ' \
      'a file will be assigned. If the file contains a metric name, ' \
      'the two will be dot-concatenated, with this value first',
+     '-i, --delta                increment metric by given value',
+     "-q, --quiet                don't report the points sent summary " \
+     '(unless there were errors)',
      '-r, --rate=INTEGER         throttle point sending to this many ' \
      'points per second']
   end

data/lib/wavefront-cli/controller.rb

@@ -1,9 +1,13 @@
 # For development against a local checkout of the SDK, uncomment
-# this block
+# this definition
 #
-# dir = Pathname.new(__FILE__).dirname.realpath.parent.parent.parent
-# $LOAD_PATH.<< dir + 'lib'
-# $LOAD_PATH.<< dir + 'wavefront-sdk' + 'lib'
+# DEVELOPMENT = true
+
+if defined?(DEVELOPMENT)
+  dir = Pathname.new(__FILE__).dirname.realpath.parent.parent.parent
+  $LOAD_PATH.<< dir + 'lib'
+  $LOAD_PATH.<< dir + 'wavefront-sdk' + 'lib'
+end
 
 require 'pathname'
 require 'pp'

data/lib/wavefront-cli/display/report.rb

@@ -0,0 +1,17 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output when writing points directly to
+  # Wavefront.
+  #
+  class Report < Base
+    def do_point
+      puts 'Point received.' unless options[:quiet]
+    end
+
+    def do_file
+      do_point
+    end
+  end
+end

data/lib/wavefront-cli/display/write.rb

@@ -5,15 +5,18 @@ module WavefrontDisplay
   #
   class Write < Base
     def do_point
-      %i[sent rejected unsent].each do |k|
-        puts format('  %12s %d', k.to_s, data[k])
-      end
-
+      report unless options[:quiet] || (data[:unsent] + data[:rejected] > 0)
       exit(data.rejected.zero? && data.unsent.zero? ? 0 : 1)
     end
 
     def do_file
       do_point
     end
+
+    def report
+      %i[sent rejected unsent].each do |k|
+        puts format('  %12s %d', k.to_s, data[k])
+      end
+    end
   end
 end

data/lib/wavefront-cli/output/base.rb

@@ -0,0 +1,10 @@
+module WavefrontOutput
+  class Base
+    attr_reader :resp, :options
+
+    def initialize(resp, options)
+      @resp = resp
+      @options = options
+    end
+  end
+end