wavefront-client 3.2.0 → 3.3.0

data/lib/wavefront/cli/alerts.rb

@@ -24,27 +24,14 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
   attr_accessor :options, :arguments
 
   def run
-    alerts = Wavefront::Alerting.new(@options[:token])
-    queries = alerts.public_methods(false).sort
-    queries.delete(:token)
-
+    raise 'Missing token.' if ! @options[:token] || @options[:token].empty?
     raise 'Missing query.' if arguments.empty?
     query = arguments[0].to_sym
 
-    unless queries.include?(query)
-      raise 'State must be one of: ' + queries.each {|q| q.to_s}.join(', ')
-    end
-
-    unless Wavefront::Client::ALERT_FORMATS.include?(
-                                            @options[:format].to_sym)
-      raise 'Output format must be one of: ' +
-            Wavefront::Client::ALERT_FORMATS.join(', ')
-    end
-
-    # This isn't especially nice, but if require to
-    # avoiding breaking the Alerting interface :(
-    options = Hash.new
-    options[:host] = @options[:endpoint]
+    wfa = Wavefront::Alerting.new(@options[:token])
+    valid_state?(wfa, query)
+    valid_format?(@options[:format].to_sym)
+    options = { host: @options[:endpoint] }
 
     if @options[:shared]
       options[:shared_tags] = @options[:shared].delete(' ').split(',')
@@ -54,9 +41,22 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
       options[:private_tags] = @options[:private].delete(' ').split(',')
     end
 
-    result = alerts.send(query, options)
+    begin
+      result = wfa.send(query, options)
+    rescue
+      raise 'Unable to execute query.'
+    end
 
-    case @options[:format].to_sym
+    format_result(result, @options[:format].to_sym)
+    exit
+  end
+
+  def format_result(result, format)
+    #
+    # Call a suitable method to display the output of the API call,
+    # which is JSON.
+    #
+    case format
     when :ruby
       pp result
     when :json
@@ -64,11 +64,32 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
     when :human
       puts humanize(JSON.parse(result))
     else
-      puts "Invalid output format, See --help for more detail."
-      exit 1
+      raise "Invalid output format '#{format}'. See --help for more detail."
+    end
+  end
+
+  def valid_format?(fmt)
+    fmt = fmt.to_sym if fmt.is_a?(String)
+
+    unless Wavefront::Client::ALERT_FORMATS.include?(fmt)
+      raise 'Output format must be one of: ' +
+        Wavefront::Client::ALERT_FORMATS.join(', ') + '.'
     end
+    true
+  end
 
-    exit 0
+  def valid_state?(wfa, state)
+    #
+    # Check the alert type we've been given is valid. There needs to
+    # be a public method in the 'alerting' class for every one.
+    #
+    s = wfa.public_methods(false).sort
+    s.delete(:token)
+    unless s.include?(state)
+      raise 'State must be one of: ' + s.each { |q| q.to_s }.join(', ') +
+        '.'
+    end
+    true
   end
 
   def humanize(alerts)
@@ -104,7 +125,7 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
   end
 
   def human_line(k, v)
-    '%-22s%s' % [k, v]
+    ('%-22s%s' % [k, v]).rstrip
   end
 
   def human_line_created(k, v)
@@ -121,9 +142,10 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
 
   def human_line_hostsUsed(k, v)
     #
-    # Put each host on its own line, indented.
+    # Put each host on its own line, indented. Does this by
+    # returning an array.
     #
-    return k unless v
+    return k unless v && v.is_a?(Array) && ! v.empty?
     v.sort!
     [human_line(k, v.shift)] + v.map {|el| human_line('', el)}
   end
@@ -144,6 +166,7 @@ class Wavefront::Cli::Alerts < Wavefront::Cli
     #
     # hanging indent long lines to fit in an 80-column terminal
     #
-    line.gsub(/(.{1,#{cols - offset}})(\s+|\Z)/, "\\1\n#{' ' * offset}")
+    line.gsub(/(.{1,#{cols - offset}})(\s+|\Z)/, "\\1\n#{' ' *
+              offset}").rstrip
   end
 end

data/lib/wavefront/cli/batch_write.rb

@@ -0,0 +1,227 @@
+require 'socket'
+require 'pathname'
+require 'wavefront/cli'
+require 'wavefront/batch_writer'
+#
+# Push datapoints into Wavefront, via a proxy. Uses the
+# 'batch_writer' class.
+#
+class Wavefront::Cli::BatchWrite < Wavefront::Cli
+  attr_reader :opts, :sock, :fmt, :wf
+
+  include Wavefront::Constants
+  include Wavefront::Mixins
+
+  def run
+    raise 'Invalid format string.' unless valid_format?(options[:format])
+
+    file = options[:'<file>']
+    setup_opts(options)
+
+    if options.key?(:format)
+      setup_fmt(options[:format])
+    else
+      setup_fmt
+    end
+
+    @wf = Wavefront::BatchWriter.new(options)
+
+    begin
+      wf.open_socket
+    rescue
+      raise 'unable to connect to proxy'
+    end
+
+    begin
+      if file == '-'
+        STDIN.each_line { |l| wf.write(process_line(l.strip)) }
+      else
+        process_filedata(load_data(Pathname.new(file)))
+      end
+    ensure
+      wf.close_socket
+    end
+
+    puts "Point summary: " + (%w(sent unsent rejected).map do |p|
+      [wf.summary[p.to_sym], p].join(' ')
+    end.join(', ')) + '.'
+  end
+
+  def setup_fmt(fmt = DEFAULT_INFILE_FORMAT)
+    @fmt = fmt.split('')
+  end
+
+  def setup_opts(options)
+    @opts = {
+      prefix:   options[:metric] || '',
+      source:   options[:host] || Socket.gethostname,
+      tags:     tags_to_hash(options[:tag]),
+      endpoint: options[:proxy],
+      port:     options[:port],
+      verbose:  options[:verbose],
+      noop:     options[:noop],
+    }
+  end
+
+  def tags_to_hash(tags)
+    #
+    # Turn a docopt array of key=value tags into a hash for the
+    # batch_writer class. If key or value are quoted, we remove the
+    # quotes.
+    #
+    tags = [tags] if tags.is_a?(String)
+    tags = {} unless tags.is_a?(Array)
+
+    tags.each_with_object({}) do |t, m|
+      k, v = t.split('=', 2)
+      m[k.gsub(/^["']|["']$/, '').to_sym] =
+        v.to_s.gsub(/^["']|["']$/, '') if v
+    end
+  end
+
+  def load_data(file)
+    begin
+      IO.read(file)
+    rescue
+      raise "Cannot open file '#{file}'." unless file.exist?
+    end
+  end
+
+  def process_filedata(data)
+    #
+    # we know what order the fields are in from the format string,
+    # which contains 't', 'm', and 'v' in some order
+    #
+    data.split("\n").each { |l| wf.write(process_line(l)) }
+  end
+
+  def valid_format?(fmt)
+    # The format string must contain a 'v'. It must not contain
+    # anything other than 'm', 't', 'T' or 'v', and the 'T', if
+    # there, must be at the end. No letter must appear more than
+    # once.
+    #
+    fmt.include?('v') && fmt.match(/^[mtv]+T?$/) && fmt ==
+      fmt.split('').uniq.join
+  end
+
+  def valid_line?(l)
+    #
+    # 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.
+    #
+    ncols = l.split.length
+
+    if fmt.include?('T')
+      return false unless ncols >= fmt.length
+    else
+      return false unless ncols == fmt.length
+    end
+
+    true
+  end
+
+  def valid_timestamp?(ts)
+    #
+    # Another attempt to stop the user accidentally sending nonsense
+    # data. 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.
+    #
+    (ts.is_a?(Integer) || ts.match(/^\d+$/)) &&
+      ts.to_i > 946684800 && ts.to_i < (Time.now.to_i + 31557600)
+  end
+
+  def valid_value?(val)
+    val.is_a?(Numeric) || (val.match(/^-?[\d\.e]+$/) && val.count('.') < 2)
+  end
+
+  def process_line(l)
+    #
+    # Process a line of input, as described by the format string
+    # held in opts[:fmt]. Produces a hash suitable for batch_writer
+    # 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.
+    #
+    return true if l.empty?
+    m_prefix = opts[:prefix]
+    chunks = l.split(/\s+/, fmt.length)
+
+    begin
+      raise 'wrong number of fields' unless valid_line?(l)
+
+      begin
+        v = chunks[fmt.index('v')]
+
+        if valid_value?(v)
+          point = { value: v.to_f }
+        else
+          raise "invalid value '#{v}'"
+        end
+
+      rescue TypeError
+        raise "no value in '#{l}'"
+      end
+
+
+      # The user can supply a time. If they have told us they won't
+      # be, we'll use the current time.
+      #
+
+      point[:ts] = begin
+        ts = chunks[fmt.index('t')]
+
+        if valid_timestamp?(ts)
+          Time.at(parse_time(ts))
+        else
+          raise "invalid timestamp '#{ts}'"
+        end
+
+      rescue TypeError
+        Time.now.utc.to_i
+      end
+
+      # The source is normally the local hostname, but the user can
+      # override that.
+
+      point[:source] = begin
+        chunks[fmt.index('s')]
+      rescue TypeError
+        opts[:source]
+      end
+
+      # The metric 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.
+      #
+      begin
+        m = chunks[fmt.index('m')]
+        point[:path] = m_prefix.empty? ? m : [m_prefix, m].join('.')
+      rescue TypeError
+        if m_prefix
+          point[:path] = m_prefix
+        else
+          raise "metric path in '#{l}'"
+        end
+      end
+    rescue => e
+      puts "WARNING: #{e}. Skipping."
+      return false
+    end
+
+    if fmt.last == 'T'
+      point[:tags] =
+        tags_to_hash(chunks.last.split(/\s(?=(?:[^"]|"[^"]*")*$)/))
+    end
+
+    point
+  end
+end

data/lib/wavefront/cli/events.rb

@@ -60,7 +60,7 @@ class Wavefront::Cli::Events < Wavefront::Cli
     options[t] ? time_to_ms(parse_time(options[t])) : false
   end
 
-  def prep_hosts(hosts)
+  def prep_hosts(hosts = false)
     #
     # We allow the user to associate an event with multiple hosts,
     # or to pass in some identifer other than the hostname. If they

data/lib/wavefront/cli/ts.rb

@@ -48,11 +48,11 @@ class Wavefront::Cli::Ts < Wavefront::Cli
     options[:prefix_length] = @options[:prefixlength].to_i
 
     if @options[:start]
-      options[:start_time] = parse_time(@options[:start])
+      options[:start_time] = Time.at(parse_time(@options[:start]))
     end
 
     if @options[:end]
-      options[:end_time] = parse_time(@options[:end])
+      options[:end_time] = Time.at(parse_time(@options[:end]))
     end
 
     wave = Wavefront::Client.new(@options[:token], @options[:endpoint], @options[:debug])

data/lib/wavefront/cli/write.rb

@@ -0,0 +1,89 @@
+require 'wavefront/writer'
+require 'wavefront/cli'
+require 'socket'
+#
+# Push datapoints into Wavefront, via a proxy. This class deals in
+# single points. It cannot batch, or deal with files or streams of
+# data. This is because it depends on the very simple 'writer'
+# class, which cannot be significantly changed, so as to maintain
+# backward compatibility.
+#
+class Wavefront::Cli::Write < Wavefront::Cli
+
+  include Wavefront::Constants
+  include Wavefront::Mixins
+
+  def run
+    valid_value?(options[:'<value>'])
+    valid_metric?(options[:'<metric>'])
+    ts = options[:time] ? parse_time(options[:time]) : false
+
+    [:proxy, :host].each do |h|
+      raise Wavefront::Exception::InvalidHostname unless valid_host?(h)
+    end
+
+    write_opts = {
+      agent_host:   options[:proxy],
+      host_name:    options[:host],
+      metric_name:  options[:'<metric>'],
+      point_tags:   prep_tags(options[:tag]),
+      timestamp:    ts,
+      noop:         options[:noop],
+    }
+
+    write_metric(options[:'<value>'].to_i, options[:'<metric>'], write_opts)
+  end
+
+  def write_metric(value, name, opts)
+    wf = Wavefront::Writer.new(opts)
+    wf.write(value, name, opts)
+  end
+
+  def valid_host?(hostname)
+    #
+    # quickly make sure a hostname looks vaguely sensible
+    #
+    hostname.match(/^[\w\.\-]+$/) && hostname.length < 1024
+  end
+
+  def valid_value?(value)
+    #
+    # Values, it seems, will always come in as strings. We need to
+    # cast them to numbers. I don't think there's any reasonable way
+    # to allow exponential notation.
+    #
+    unless value.is_a?(Numeric) || value.match(/^-?\d*\.?\d*$/) ||
+           value.match(/^-?\d*\.?\d*e\d+$/)
+      raise Wavefront::Exception::InvalidMetricValue
+    end
+    true
+  end
+
+  def valid_metric?(metric)
+    #
+    # Apply some common-sense rules to metric paths. Check it's a
+    # string, and that it has at least one dot in it. Don't allow
+    # through odd characters or whitespace.
+    #
+    begin
+      raise unless metric.is_a?(String) &&
+                   metric.split('.').length > 1 &&
+                   metric.match(/^[\w\-\._]+$/) &&
+                   metric.length < 1024
+    rescue
+      fail Wavefront::Exception::InvalidMetricName
+    end
+    true
+  end
+
+  def prep_tags(tags)
+    #
+    # Takes an array of key=value tags (as produced by docopt) and
+    # turns it into an array of [key, value] arrays (as required
+    # by various of our own methods). Anything not of the form
+    # key=val is dropped.
+    #
+    return [] unless tags.is_a?(Array)
+    tags.map { |t| t.split('=') }.select { |e| e.length == 2 }
+  end
+end