wavefront-cli 2.8.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 397350925432eb596a2268652590b0690ee115d0f351f4406e807eec465db61c
-  data.tar.gz: e85b47160b148fc9067ea9d14b6265c8fa27004661a65a62dd4bdca67645c4e1
+  metadata.gz: ceaedf1118ace74decdfe51ad1e4c1c019e532b492c66fba499106c15f8ac021
+  data.tar.gz: 016ef2f6fdd75a958dc17b70375e74ac35b33acfe5d1296c75c68ce1bfbf1de9
 SHA512:
-  metadata.gz: 0f9d17a9f4ceebbadc18e41813b6766b86c07f6a881a1b30814ab747e82782f67ef97d6a5f876d28719c8182b8b6e1ae14b514cfc649efe80f265bdefc623c0f
-  data.tar.gz: 7071d861a7da1bad3322fac62601cc05ed773898b04833384d16178ce67d260861603d36ff669f36dff43d333e9805608d0c6e520513fdf179f9ae074286b93d
+  metadata.gz: 51931ddb036a749b9989c35999be1e276b2d1832f5fe7d04a02cb897bceeed7b960e627667e79dff7bd3240c4a3b22352d23a4baba2ca4feca86659ade6b0c8b
+  data.tar.gz: e6f40465692ae30d9d4fdd8ef68d6d6f21443127237ba14fdc726096af0bb8a3b7f2562e2c6342bbc84f24fd5bd25ec3a272b4b012827c2e612761068cc98ead

data/.rubocop.yml

@@ -0,0 +1,11 @@
+---
+
+Style/FormatStringToken:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 13
+

data/HISTORY.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 2.9.0 (22/08/2018)
+* Create external links with new `link create` sub-command.
+* Fix bug which stopped you writing points without a `.wavefront`
+  configuration file.
+* Improved error reporting.
+* Bugfix on external link searching.
+* Modify external link filters.
+* Use 1.6.1 of [wavefront-sdk](https://github.com/snltd/wavefront-sdk).
+
+## 2.8.0 (08/08/2018)
+* Add `wavefront` format to the `query` command. This outputs the
+  result of a raw or timeseries query in a format which can be fed
+  back into Wavefront via a proxy.
+* Use 1.6.0 of [wavefront-sdk](https://github.com/snltd/wavefront-sdk).
+* Restructure the way different output formats are handled in a
+  better, more flexible way.
+
 ## 2.7.0 (04/07/2018)
 
 * Add a `-i` option to the `report` command, to send delta metrics.

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubocop/rake_task'
 
 task default: :test
 
-Rake::TestTask.new do |t|
+Rake::TestTask.new(test: :rubocop) do |t|
   t.pattern = 'spec/wavefront-cli/**/*_spec.rb'
   t.warning = false
 end

data/bin/wf

@@ -6,7 +6,7 @@ require_relative '../lib/wavefront-cli/controller'
 
 begin
   tw = IO.console.winsize.last
-rescue
+rescue RuntimeError
   tw = 80
 end
 

data/lib/wavefront-cli/base.rb

@@ -84,7 +84,8 @@ module WavefrontCli
         begin
           send(:wf_tag?, t)
         rescue Wavefront::Exception::InvalidTag
-          abort "'#{t}' is not a valid tag."
+          raise(WavefrontCli::Exception::InvalidInput,
+                "'#{t}' is not a valid tag.")
         end
       end
     end
@@ -135,9 +136,10 @@ module WavefrontCli
     # method, and displays whatever it returns.
     #
     # @return [nil]
-    # @raise 'unsupported command', if the command does not match a
-    #   `do_` method.
+    # @raise WavefrontCli::Exception::UnhandledCommand if the
+    #   command does not match a `do_` method.
     #
+    # rubocop:disable Metrics/AbcSize
     def dispatch
       #
       # Take a list of do_ methods, remove the 'do_' from their name,
@@ -166,6 +168,7 @@ module WavefrontCli
 
       raise WavefrontCli::Exception::UnhandledCommand
     end
+    # rubocop:enable Metrics/AbcSize
 
     # Display a Ruby object as JSON, YAML, or human-readable.  We
     # provide a default method to format human-readable output, but
@@ -180,6 +183,7 @@ module WavefrontCli
     # @param method [String] the name of the method which produced
     #   this output. Used to find a suitable humanize method.
     #
+    # rubocop:disable Metrics/AbcSize
     def display(data, method)
       if no_api_response.include?(method)
         return display_no_api_response(data, method)
@@ -198,6 +202,7 @@ module WavefrontCli
 
       handle_response(data.response, format_var, method)
     end
+    # rubocop:enable Metrics/AbcSize
 
     # @param status [Map] status object from SDK response
     # @return System exit
@@ -232,19 +237,20 @@ module WavefrontCli
       end
     end
 
+    # rubocop:disable Metrics/AbcSize
     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))
+                                       format.to_s.capitalize))
       oclass.new(resp, options).run
     rescue LoadError
-      raise WavefrontCli::Exception::UnsupportedOutput.new(
-        format("The '%s' command does not support '%s' output.",
-               options[:class], format)
-      )
+      raise(WavefrontCli::Exception::UnsupportedOutput,
+            format("The '%s' command does not support '%s' output.",
+                   options[:class], format))
     end
+    # rubocop:enable Metrics/AbcSize
 
     def hcl_fields
       []
@@ -262,8 +268,14 @@ module WavefrontCli
     # writer, for instance, uses a proxy and has no token.
     #
     def validate_opts
-      raise 'Please supply an API token.' unless options[:token]
-      raise 'Please supply an API endpoint.' unless options[:endpoint]
+      unless options[:token]
+        raise(WavefrontCli::Exception::CredentialError,
+              'Missing API token.')
+      end
+
+      return true if options[:endpoint]
+      raise(WavefrontCli::Exception::CredentialError,
+            'Missing API endpoint.')
     end
 
     # Give it a path to a file (as a string) and it will return the
@@ -273,23 +285,27 @@ module WavefrontCli
     #
     # @param path [String] the file to load
     # @return [Hash] a Ruby object of the loaded file
-    # @raise 'Unsupported file format.' if the filetype is unknown.
+    # @raise WavefrontCli::Exception::UnsupportedFileFormat if the
+    #   filetype is unknown.
     # @raise pass through any error loading or parsing the file
     #
+    # rubocop:disable Metrics/AbcSize
     def load_file(path)
       return load_from_stdin if path == '-'
 
       file = Pathname.new(path)
-      raise 'Import file does not exist.' unless file.exist?
+
+      raise WavefrontCli::Exception::FileNotFound unless file.exist?
 
       if file.extname == '.json'
         JSON.parse(IO.read(file))
       elsif file.extname == '.yaml' || file.extname == '.yml'
         YAML.safe_load(IO.read(file))
       else
-        raise 'Unsupported file format.'
+        raise WavefrontCli::Exception::UnsupportedFileFormat
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # Read STDIN and return a Ruby object, assuming that STDIN is
     # valid JSON or YAML. This is a dumb method, it does no
@@ -297,7 +313,8 @@ module WavefrontCli
     # appears to be a valid assumption for use-cases of this CLI.
     #
     # @return [Object]
-    # @raise 'cannot parse stdin' if it, well you know.
+    # @raise Wavefront::Exception::UnparseableInput if the input
+    #   does not parse
     #
     def load_from_stdin
       raw = STDIN.read
@@ -307,8 +324,8 @@ module WavefrontCli
       else
         JSON.parse(raw)
       end
-    rescue
-      raise 'Cannot parse stdin.'
+    rescue RuntimeError
+      raise Wavefront::Exception::UnparseableInput
     end
 
     # Below here are common methods. Most are used by most classes,
@@ -331,7 +348,7 @@ module WavefrontCli
         prepped = import_to_create(raw)
       rescue StandardError => e
         puts e if options[:debug]
-        raise 'could not parse input.'
+        raise WavefrontCli::Exception::UnparseableInput
       end
 
       wf.create(prepped)
@@ -348,6 +365,10 @@ module WavefrontCli
     def do_update
       k, v = options[:'<key=value>'].split('=', 2)
       wf.update(options[:'<id>'], k => v)
+    rescue NoMethodError
+      raise(WavefrontCli::Exception::UnsupportedOperation,
+            'Updates require two API calls. We cannot do the second ' \
+            'when -n is set.')
     end
 
     def do_search(cond = options[:'<condition>'])
@@ -356,11 +377,18 @@ module WavefrontCli
 
       query = conds_to_query(cond)
 
-      wfs.search(klass_word, query, limit: options[:limit],
+      wfs.search(search_key, query, limit:  options[:limit],
                                     offset: options[:offset] ||
                                             options[:cursor])
     end
 
+    # The search URI pattern doesn't always match the command name,
+    # or class name. Override this method if this is the case.
+    #
+    def search_key
+      klass_word
+    end
+
     # Turn a list of search conditions into an API query
     #
     def conds_to_query(conds)

data/lib/wavefront-cli/base_write.rb

@@ -9,6 +9,7 @@ module WavefrontCli
     attr_reader :fmt
     include Wavefront::Mixins
 
+    # rubocop:disable Metrics/AbcSize
     def do_point
       p = { path:  options[:'<metric>'],
             value: options[:'<value>'].delete('\\').to_f,
@@ -18,9 +19,10 @@ module WavefrontCli
       p[:ts] = parse_time(options[:time]) if options[:time]
       send_point(p)
     end
+    # rubocop:enable Metrics/AbcSize
 
-    def send_point(p)
-      call_write(p)
+    def send_point(point)
+      call_write(point)
     rescue Wavefront::Exception::InvalidEndpoint
       abort "could not speak to proxy #{options[:proxy]}:#{options[:port]}."
     end
@@ -38,14 +40,22 @@ module WavefrontCli
       if file == '-'
         read_stdin
       else
-        data = load_data(Pathname.new(file)).split("\n").map do |l|
-          process_line(l)
-        end
-
+        data = process_input_file(load_data(Pathname.new(file)).split("\n"))
         call_write(data)
       end
     end
 
+    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 or deltas
     #
     def call_write(data)
@@ -80,10 +90,9 @@ module WavefrontCli
 
     # 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
+    # @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')]
@@ -107,7 +116,7 @@ module WavefrontCli
     #
     def extract_path(chunks)
       m = chunks[fmt.index('m')]
-      return options[:metric] ? [options[:metric], m].join('.') : m
+      options[:metric] ? [options[:metric], m].join('.') : m
     rescue TypeError
       return options[:metric] if options[:metric]
       raise
@@ -120,7 +129,7 @@ module WavefrontCli
     #   value passed through by -H, or the local hostname.
     #
     def extract_source(chunks)
-      return chunks[fmt.index('s')]
+      chunks[fmt.index('s')]
     rescue TypeError
       options[:source] || Socket.gethostname
     end
@@ -132,23 +141,32 @@ module WavefrontCli
     # 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)
+    # @raise WavefrontCli::Exception::UnparseableInput if the line
+    #   doesn't look right
+    #
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def process_line(line)
+      return true if line.empty?
+      chunks = line.split(/\s+/, fmt.length)
+      enough_fields?(line) # can raise exception
 
       begin
         point = { path:  extract_path(chunks),
+                  tags:  line_tags(chunks),
                   value: extract_value(chunks) }
-        point[:ts] = extract_ts(chunks) if fmt.include?('t')
+
+        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}"
+        raise(WavefrontCli::Exception::UnparseableInput,
+              "could not process #{line}")
       end
 
       point
     end
+    # rubocop:enable Metrics/MethodLength
+    # 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.
@@ -190,7 +208,8 @@ module WavefrontCli
         return true
       end
 
-      raise 'Invalid format string.'
+      raise(WavefrontCli::Exception::UnparseableInput,
+            'Invalid format string.')
     end
 
     # Make sure we have the right number of columns, according to
@@ -201,16 +220,11 @@ module WavefrontCli
     # 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
+    def enough_fields?(line)
+      ncols = line.split.length
+      return true if fmt.include?('T') && ncols >= fmt.length
+      return true if ncols == fmt.length
+      raise WavefrontCli::Exception::UnparseableInput, 'wrong number of fields'
     end
 
     # Although the SDK does value checking, we'll add another layer
@@ -218,9 +232,10 @@ module WavefrontCli
     # 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)
+    def valid_timestamp?(timestamp)
+      (timestamp.is_a?(Integer) || timestamp.match(/^\d+$/)) &&
+        timestamp.to_i > 946_684_800 &&
+        timestamp.to_i < (Time.now.to_i + 31_557_600)
     end
 
     private
@@ -230,8 +245,9 @@ module WavefrontCli
     end
 
     def load_data(file)
-      raise "Cannot open file '#{file}'." unless file.exist?
       IO.read(file)
+    rescue StandardError
+      raise WavefrontCli::Exception::FileNotFound
     end
   end
 end

data/lib/wavefront-cli/commands/.rubocop.yml

@@ -0,0 +1,7 @@
+---
+
+inherit_from: ../../../.rubocop.yml
+
+# Some of these methods are long, but they're just lists
+Metrics/MethodLength:
+  Enabled: false

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

@@ -3,7 +3,6 @@ require_relative 'base'
 # Define the Alert command
 #
 class WavefrontCommandAlert < WavefrontCommandBase
-
   def description
     'view and manage alerts'
   end

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

@@ -1,4 +1,4 @@
-require_relative '../string'
+require_relative '../stdlib/string'
 
 CMN = '[-DnV] [-c file] [-P profile] [-E endpoint] [-t token]'.freeze
 

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

@@ -18,6 +18,8 @@ class WavefrontCommandLink < WavefrontCommandBase
   def _commands
     ["list #{CMN} [-l] [-f format] [-o offset] [-L limit]",
      "describe #{CMN} [-f format] <id>",
+     "create #{CMN} [-m regex] [-s regex] [-p str=regex...] <name> " \
+     '<description> <template>',
      "delete #{CMN} <id>",
      "import #{CMN} <file>",
      "update #{CMN} <key=value> <id>",
@@ -29,6 +31,9 @@ class WavefrontCommandLink < WavefrontCommandBase
      '-l, --long               list external links in detail',
      '-o, --offset=n           start from nth external link',
      '-L, --limit=COUNT        number of external link to list',
+     '-m, --metric-regex=REGEX metric filter regular expression',
+     '-s, --source-regex=REGEX source filter regular expression',
+     '-p, --point-regex=REGEX  point filter regular expression',
      '-f, --format=STRING      output format']
   end
 end