wavefront-cli 2.18.0 → 3.0.0

data/lib/wavefront-cli/display/printer/terse.rb

@@ -1,57 +1,34 @@
-require_relative 'base'
+require_relative '../../stdlib/array'
 
 module WavefrontDisplayPrinter
   #
   # Print things which are per-row. The terse listings, primarily
   #
-  class Terse < Base
-    attr_reader :data, :keys, :fmt_string
+  class Terse
+    attr_reader :data, :fmt
 
-    def initialize(data, *keys)
-      @data = data
-      @keys = keys
-      @fmt_string = format_string.rstrip
-      @out = prep_output
+    # @param data [Hash] data to display, from a response object
+    # @param keys [Array[Symbol]] keys to display, in order
+    #
+    def initialize(data, keys)
+      @data = stringify(data, keys)
+      @fmt  = format_string(data, keys)
     end
 
-    # @return [String] a Ruby format string for each line
-    #
-    def format_string
-      return '%s' if keys.length == 1
-      lk = longest_keys
-      keys.each_with_object('') { |k, out| out.<< "%-#{lk[k]}s  " }
+    def format_string(data, keys)
+      keys.map { |k| "%-#{data.longest_value_of(k)}<#{k}>s" }.join('  ')
     end
 
-    # Find the length of the longest value for each member of @keys,
-    # in @data.
-    #
-    # @return [Hash] with the same keys as :keys and Integer values
-    #
-    # rubocop:disable Metrics/AbcSize
-    def longest_keys
-      keys.each_with_object(Hash[*keys.map { |k| [k, 0] }.flatten]) \
-      do |k, aggr|
-        data.each do |obj|
-          next unless obj.key?(k)
-          val = obj[k]
-          val = val.join(', ') if val.is_a?(Array)
-          aggr[k] = val.size if val.size > aggr[k]
-        end
-      end
+    def stringify(data, keys)
+      data.map { |e| e.tap { keys.each { |k| e[k] = to_list(e[k]) } } }
     end
-    # rubocop:enable Metrics/AbcSize
 
-    # Print multiple column output. This method does no word
-    # wrapping.
-    #
-    # @param keys [Symbol] the keys you want in the output. They
-    #   will be printed in the order given.
-    #
-    def prep_output
-      data.each_with_object([]) do |o, aggr|
-        args = keys.map { |k| o[k].is_a?(Array) ? o[k].join(', ') : o[k] }
-        aggr.<< format(fmt_string, *args).rstrip
-      end
+    def to_list(thing)
+      thing.is_a?(Array) ? thing.join(', ') : thing
+    end
+
+    def to_s
+      data.map { |e| format(fmt, e).rstrip }.join("\n")
     end
   end
 end

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

@@ -22,6 +22,12 @@ module WavefrontDisplay
     end
     # rubocop:enable Metrics/AbcSize
 
+    # Prioritizing keys does not make sense in this context
+    #
+    def prioritize_keys(data, _keys)
+      data
+    end
+
     def mk_timeseries(data)
       return [] unless data.key?(:timeseries)
 

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

@@ -0,0 +1,21 @@
+require_relative 'base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for external links.
+  #
+  class Settings < Base
+    def do_list_permissions
+      options[:long] ? long_output : multicolumn(:groupName)
+    end
+
+    def do_list_usergroups
+      if options[:long]
+        readable_time_arr(:createdEpochMillis)
+        long_output
+      else
+        multicolumn(:id, :name)
+      end
+    end
+  end
+end

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

@@ -2,21 +2,28 @@ require_relative 'base'
 
 module WavefrontDisplay
   # Format human-readable output when writing points.
+  # In this context data is a Hash of the form
+  # { sent: 1, rejected: 0, unsent: 0 }
   #
   class Write < Base
-    # rubocop:disable Metrics/AbcSize
+    attr_reader :not_sent
+
     def do_point
-      report unless options[:quiet] || (data[:unsent] + data[:rejected] > 0)
-      exit(data.rejected.zero? && data.unsent.zero? ? 0 : 1)
+      @not_sent = data['rejected'] + data['unsent']
+      report unless nothing_to_say?
+      exit not_sent.zero? ? 0 : 1
+    end
+
+    def nothing_to_say?
+      options[:quiet] || not_sent.positive?
     end
-    # rubocop:enable Metrics/AbcSize
 
     def do_file
       do_point
     end
 
     def report
-      %i[sent rejected unsent].each do |k|
+      %w[sent rejected unsent].each do |k|
         puts format('  %12s %d', k.to_s, data[k])
       end
     end

data/lib/wavefront-cli/event.rb

@@ -68,7 +68,7 @@ module WavefrontCli
       abort "No locally stored event matches '#{id}'." unless ev
 
       res = wf.close(ev)
-      ev_file.unlink if ev_file && ev_file.exist? && res.status.code == 200
+      ev_file.unlink if ev_file&.exist? && res.status.code == 200
       res
     end
     # rubocop:enable Metrics/AbcSize

data/lib/wavefront-cli/exception.rb

@@ -17,5 +17,6 @@ module WavefrontCli
     class UnsupportedNoop < RuntimeError; end
     class UnsupportedOperation < RuntimeError; end
     class UnsupportedOutput < RuntimeError; end
+    class UserGroupNotFound < RuntimeError; end
   end
 end

data/lib/wavefront-cli/settings.rb

@@ -0,0 +1,37 @@
+require_relative 'base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'settings' API.
+  #
+  class Settings < WavefrontCli::Base
+    def do_list_permissions
+      wf.permissions
+    end
+
+    def do_show_preferences
+      wf.preferences
+    end
+
+    def do_default_usergroups
+      wf.default_user_groups
+    end
+
+    def do_update
+      body = options[:'<key=value>'].each_with_object({}) do |o, a|
+        k, v = o.split('=', 2)
+        next unless v && !v.empty?
+
+        if %w[invitePermissions defaultUserGroups].include?(k)
+          v = v.include?(',') ? v.split(',') : [v]
+        end
+
+        a[k] = v
+      end
+
+      pp body
+
+      wf.update_preferences(body)
+    end
+  end
+end

data/lib/wavefront-cli/stdlib/array.rb

@@ -0,0 +1,20 @@
+# Extensions to stdlib's Array
+#
+class Array
+  # @return [Integer] the length of the longest string or symbol in
+  #   an array
+  #
+  def max_length
+    return 0 if empty?
+    map(&:to_s).map(&:length).max
+  end
+
+  # @return [Integer] the length of the longest value in an array of
+  #   hashes with the given key
+  #
+  # @param key [String, Symbol] key to search for
+  #
+  def longest_value_of(key)
+    map { |v| v[key] }.max_length
+  end
+end

data/lib/wavefront-cli/stdlib/string.rb

@@ -54,6 +54,14 @@ class String
     tr('^', ' ')
   end
 
+  # Fold long value lines in two-column output. The returned string
+  # is appended to a key, so the first line is not indented.
+  #
+  def value_fold(indent = 0, twidth = TW)
+    max_line_length = twidth - indent - 4
+    scan_line(max_line_length).join("\n" + ' ' * indent)
+  end
+
   # @param width [Integer] length of longest string (width of
   #   terminal less some margin)
   # @return [Array] original string chunked into an array width

data/lib/wavefront-cli/user.rb

@@ -65,7 +65,7 @@ module WavefrontCli
     # ourselves.
     #
     def extra_validation
-      options[:'<user>'].each { |u| validate_user(u) }
+      options[:'<user>']&.each { |u| validate_user(u) }
     end
 
     def validate_user(user)

data/lib/wavefront-cli/version.rb

@@ -1 +1 @@
-WF_CLI_VERSION = '2.18.0'.freeze
+WF_CLI_VERSION = '3.0.0'.freeze

data/lib/wavefront-cli/write.rb

@@ -1,4 +1,5 @@
-require_relative 'base_write'
+require 'wavefront-sdk/support/mixins'
+require_relative 'base'
 
 module WavefrontCli
   #
@@ -6,14 +7,39 @@ module WavefrontCli
   # as Report, but has to do a couple of things differently, as it
   # speaks to a proxy rather than to the API.
   #
-  class Write < BaseWrite
+  class Write < Base
+    attr_reader :fmt
+    include Wavefront::Mixins
+    SPLIT_PATTERN = /\s(?=(?:[^"]|"[^"]*")*$)/
+
+    # rubocop:disable Metrics/AbcSize
+    def do_point
+      p = { path:  options[:'<metric>'],
+            value: options[:'<value>'].delete('\\').to_f }
+
+      tags = tags_to_hash(options[:tag])
+
+      p[:tags] = tags unless tags.empty?
+      p[:source] = options[:host] if options[:host]
+      p[:ts] = parse_time(options[:time]) if options[:time]
+      send_point(p)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def do_file
+      valid_format?(options[:infileformat])
+      setup_fmt(options[:infileformat] || 'tmv')
+      process_input(options[:'<file>'])
+    end
+
     # rubocop:disable Metrics/AbcSize
     def do_distribution
       p = { path:     options[:'<metric>'],
             interval: options[:interval] || 'M',
-            value:    mk_dist,
-            tags:     tags_to_hash(options[:tag]) }
+            value:    mk_dist }
 
+      tags = tags_to_hash(options[:tag])
+      p[:tags] = tags unless tags.empty?
       p[:source] = options[:host] if options[:host]
       p[:ts] = parse_time(options[:time]) if options[:time]
       send_point(p)
@@ -44,7 +70,7 @@ module WavefrontCli
 
     def distribution?
       return true if options[:distribution]
-      options[:infileformat] && options[:infileformat].include?('d')
+      options[:infileformat]&.include?('d')
     end
 
     def mk_creds
@@ -72,11 +98,10 @@ module WavefrontCli
     end
 
     def validate_opts_file
-      unless options[:metric] || (options.key?(:infileformat) &&
-                                  options[:infileformat].include?('m'))
-        raise(WavefrontCli::Exception::InsufficientData,
-              "Supply a metric path in the file or with '-m'.")
-      end
+      return true if options[:metric] || options[:infileformat]&.include?('m')
+
+      raise(WavefrontCli::Exception::InsufficientData,
+            "Supply a metric path in the file or with '-m'.")
     end
 
     def open_connection
@@ -86,5 +111,280 @@ module WavefrontCli
     def close_connection
       wf.close
     end
+
+    def send_point(point)
+      call_write(point)
+    rescue Wavefront::Exception::InvalidEndpoint
+      abort format("Could not connect to proxy '%s:%s'.",
+                   options[:proxy], options[:port])
+    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
+        call_write(
+          process_input_file(load_data(Pathname.new(file)).split("\n"))
+        )
+      end
+    end
+
+    # @param data [Array[String]] array of lines
+    #
+    def process_input_file(data)
+      data.each_with_object([]) do |l, a|
+        begin
+          a.<< process_line(l)
+        rescue WavefrontCli::Exception::UnparseableInput => e
+          puts "Bad input. #{e.message}."
+          next
+        end
+      end
+    end
+
+    # A wrapper which lets us send normal points, deltas, or
+    # distributions
+    #
+    def call_write(data, openclose = true)
+      if options[:delta]
+        wf.write_delta(data, openclose)
+      else
+        wf.write(data, openclose)
+      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| call_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)
+      if fmt.include?('v')
+        v = chunks[fmt.index('v')]
+        v.to_f
+      else
+        raw = chunks[fmt.index('d')].split(',')
+        xpanded = expand_dist(raw)
+        wf.mk_distribution(xpanded)
+      end
+    end
+
+    # We will let users write a distribution as '1 1 1' or '3x1' or
+    # even a mix of the two
+    #
+    def expand_dist(dist)
+      dist.map do |v|
+        if v.is_a?(String) && v.include?('x')
+          x, val = v.split('x', 2)
+          Array.new(x.to_i, val.to_f)
+        else
+          v.to_f
+        end
+      end.flatten
+    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.
+    #
+    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
+
+    # @param chunks [Array] an input line broken into tokens. The
+    #   final token will be a space-separated list of point tags.
+    # @return [Hash] of k = v tags.
+    #
+    def extract_tags(chunks)
+      tags_to_hash(chunks.last.split(SPLIT_PATTERN))
+    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')]
+      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)
+      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.
+    #
+    # @param line [String] a line of an input file
+    # @return [Hash]
+    # @raise WavefrontCli::Exception::UnparseableInput if the line
+    #   doesn't look right
+    #
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def process_line(line)
+      return true if line.empty?
+      chunks = line.split(SPLIT_PATTERN, fmt.length)
+      enough_fields?(line) # can raise exception
+
+      point = { path:  extract_path(chunks),
+                value: extract_value(chunks) }
+
+      tags = line_tags(chunks)
+
+      point.tap do |p|
+        p[:tags]     = tags unless tags.empty?
+        p[:ts]       = extract_ts(chunks)        if fmt.include?('t')
+        p[:source]   = extract_source(chunks)    if fmt.include?('s')
+        p[:interval] = options[:interval] || 'm' if fmt.include?('d')
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    # 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[String]]
+    # @return [Hash] of k: v tags
+    #
+    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.to_sym] = v.to_s.gsub(/^["']|["']$/, '') if v
+      end
+    end
+
+    # The format string must contain values. They can be single
+    # values or distributions. So we must have 'v' xor 'd'. It must
+    # not contain anything other than 'm', 't', 'T', 's', 'd', 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
+    #
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def valid_format?(fmt)
+      err = if fmt.include?('v') && fmt.include?('d')
+              "'v' and 'd' are mutually exclusive"
+            elsif !fmt.include?('v') && !fmt.include?('d')
+              "format string must include 'v' or 'd'"
+            elsif !fmt.match(/^[dmstTv]+$/)
+              'unsupported field in format string'
+            elsif fmt != fmt.squeeze
+              'repeated field in format string'
+            elsif fmt.include?('T') && !fmt.end_with?('T')
+              "if used, 'T' must come at end of format string"
+            end
+
+      return true if err.nil?
+
+      raise(WavefrontCli::Exception::UnparseableInput, err)
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    # 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.
+    #
+    # @param line [String] input line
+    # @return [True] if the number of fields is correct
+    # @raise WavefrontCli::Exception::UnparseableInput if there
+    #   are not the right number of fields.
+    #
+    def enough_fields?(line)
+      ncols = line.split(SPLIT_PATTERN).length
+      return true if fmt.include?('T') && ncols >= fmt.length
+      return true if ncols == fmt.length
+      raise(WavefrontCli::Exception::UnparseableInput,
+            format('Expected %s fields, got %s', fmt.length, ncols))
+    end
+
+    # Although the SDK does value checking, we'll add another layer
+    # of input checking 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.
+    # @param timestamp [String, Integer] epoch timestamp
+    # @return [Bool]
+    #
+    def valid_timestamp?(timestamp)
+      (timestamp.is_a?(Integer) ||
+        timestamp.is_a?(String) && timestamp.match(/^\d+$/)) &&
+        timestamp.to_i > 946_684_800 &&
+        timestamp.to_i < (Time.now.to_i + 31_557_600)
+    end
+
+    def setup_fmt(fmt)
+      @fmt = fmt.split('')
+    end
+
+    def load_data(file)
+      IO.read(file)
+    rescue StandardError
+      raise WavefrontCli::Exception::FileNotFound
+    end
   end
 end