wavefront-client 3.4.0 → 3.5.1

data/lib/wavefront/cli/write.rb

@@ -9,7 +9,6 @@ require 'socket'
 # backward compatibility.
 #
 class Wavefront::Cli::Write < Wavefront::Cli
-
   include Wavefront::Constants
   include Wavefront::Mixins
 
@@ -19,7 +18,7 @@ class Wavefront::Cli::Write < Wavefront::Cli
     ts = options[:time] ? parse_time(options[:time]) : false
 
     [:proxy, :host].each do |h|
-      raise Wavefront::Exception::InvalidHostname unless valid_host?(h)
+      fail Wavefront::Exception::InvalidHostname unless valid_host?(h)
     end
 
     write_opts = {
@@ -28,7 +27,7 @@ class Wavefront::Cli::Write < Wavefront::Cli
       metric_name:  options[:'<metric>'],
       point_tags:   prep_tags(options[:tag]),
       timestamp:    ts,
-      noop:         options[:noop],
+      noop:         options[:noop]
     }
 
     write_metric(options[:'<value>'].to_i, options[:'<metric>'], write_opts)
@@ -54,7 +53,7 @@ class Wavefront::Cli::Write < Wavefront::Cli
     #
     unless value.is_a?(Numeric) || value.match(/^-?\d*\.?\d*$/) ||
            value.match(/^-?\d*\.?\d*e\d+$/)
-      raise Wavefront::Exception::InvalidMetricValue
+      fail Wavefront::Exception::InvalidMetricValue
     end
     true
   end
@@ -66,12 +65,12 @@ class Wavefront::Cli::Write < Wavefront::Cli
     # through odd characters or whitespace.
     #
     begin
-      raise unless metric.is_a?(String) &&
-                   metric.split('.').length > 1 &&
-                   metric.match(/^[\w\-\._]+$/) &&
-                   metric.length < 1024
+      fail unless metric.is_a?(String) &&
+                  metric.split('.').length > 1 &&
+                  metric.match(/^[\w\-\._]+$/) &&
+                  metric.length < 1024
     rescue
-      fail Wavefront::Exception::InvalidMetricName
+      raise Wavefront::Exception::InvalidMetricName
     end
     true
   end

data/lib/wavefront/cli.rb

@@ -35,24 +35,17 @@ module Wavefront
       #
       # 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: it's not
-      # entirely reasonable to demand the user has one. Options
-      # passed on the command-line trump the same values in the
-      # file.
+      # not there, we don't consider that an error.
       #
       return unless options[:config].is_a?(String)
       cf = Pathname.new(options[:config])
       return unless cf.exist?
 
       pf = options[:profile] || 'default'
-      raw = IniFile.load(cf)
-      profile = raw[pf]
-
       puts "using #{pf} profile from #{cf}" if options[:debug]
 
-      profile.each_with_object({}) do |(k, v), memo|
-        k = k.to_sym
-        memo[k] = (options.include?(k) && options[k]) ? options[k] : v
+      IniFile.load(cf)[pf].each_with_object({}) do |(k, v), memo|
+        memo[k.to_sym] = v
       end
     end
   end

data/lib/wavefront/client/version.rb

@@ -16,6 +16,6 @@ See the License for the specific language governing permissions and
 
 module Wavefront
   class Client
-    VERSION = "3.4.0"
+    VERSION = "3.5.1"
   end
 end

data/lib/wavefront/events.rb

@@ -4,6 +4,7 @@ require 'rest_client'
 require 'uri'
 require 'logger'
 require 'wavefront/constants'
+require 'wavefront/mixins'
 #
 # Add basic support to cover Wavefront's events API. I have followed
 # the standards and conventions established in the files already in
@@ -19,6 +20,7 @@ module Wavefront
   #
   class Events
     include Wavefront::Constants
+    include Wavefront::Mixins
     DEFAULT_PATH = '/api/events/'
 
     attr_reader :headers
@@ -95,14 +97,6 @@ module Wavefront
       RestClient.post(uri.to_s, query, headers)
     end
 
-    def hash_to_qs(payload)
-      #
-      # Make a properly escaped query string out of a key: value
-      # hash.
-      #
-      URI.escape(payload.map { |k, v| [k, v].join('=') }.join('&'))
-    end
-
     def debug(enabled)
       RestClient.log = 'stdout' if enabled
     end

data/lib/wavefront/exception.rb

@@ -31,5 +31,7 @@ module Wavefront
     class InvalidHostname < ::Exception; end
     class InvalidEndpoint < ::Exception; end
     class InvalidSource < ::Exception; end
+    class InvalidString < ::Exception; end
+    class ValueOutOfRange < ::Exception; end
   end
 end

data/lib/wavefront/metadata.rb

@@ -1,4 +1,4 @@
-=begin 
+=begin
     Copyright 2015 Wavefront Inc.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,26 +17,48 @@ See the License for the specific language governing permissions and
 require "wavefront/client/version"
 require "wavefront/constants"
 require "wavefront/exception"
+require 'wavefront/validators'
 require 'rest_client'
 require 'uri'
 require 'logger'
 
 module Wavefront
+  #
+  # Because of the way the 'manage' API is laid out, this class doesn't
+  # reflect it as clearly as, say the 'alerts' class. There is a small
+  # amount of duplication in method names too, as it merges a new class
+  # and an old one.
+  #
+  # Note that the following methods do not do any exception handling. It
+  # is up to your client code to decide how to deal with, for example, a
+  # RestClient::ResourceNotFound exception.
+  #
   class Metadata
     include Wavefront::Constants
-    DEFAULT_PATH = '/api/manage/source/'
+    include Wavefront::Mixins
+    include Wavefront::Validators
+    DEFAULT_PATH = '/api/manage/source/'.freeze
 
-    attr_reader :headers, :base_uri
+    attr_reader :headers, :host
 
     def initialize(token, host=DEFAULT_HOST, debug=false)
+      #
+      # 'host' is the Wavefront API endpoint
+      #
       @headers = {'X-AUTH-TOKEN' => token}
       @base_uri = URI::HTTPS.build(:host => host, :path => DEFAULT_PATH)
       debug(debug)
     end
 
     def get_tags(hostname='', limit=100)
+      #
+      # This method is capable of making two distinct API calls,
+      # depending on the arguments. It is left here for backward
+      # compatibility, but you are recommended to use show_source() and
+      # show_sources() instead.
+      #
       uri = @base_uri
-      
+
       unless hostname.empty?
         uri = URI.join(@base_uri.to_s, hostname)
       end
@@ -44,54 +66,157 @@ module Wavefront
       if limit > 10000
         limit = 10000
       end
-      
+
       args = {:params => {:limit => limit}}.merge(@headers)
-      
+
       begin
         response = RestClient.get(uri.to_s, args)
       rescue RestClient::ResourceNotFound
         # If a 404 is returned, we return an empty JSON as this is the expected behaviour for untagged hosts
-        response = {}        
+        response = {}
       end
 
-      return response
- 
+      response
     end
 
     def add_tags(hostnames, tags)
-      
-      # Build and call tagging URI for each host and tag.
+
+      # Build and call tagging URI for each host and tag. A
+      # backward-compatibility wrapper for set_tag()
+      #
       hostnames.each do |hostname|
-        host_uri = URI.join(@base_uri.to_s,"#{hostname}/")
-        extended_uri = URI.join(host_uri.to_s,"tags/")        
-        tags.each do |tag|
-          final_uri = URI.join(extended_uri.to_s,tag)
-          RestClient.post(final_uri.to_s, {}, @headers)
-        end
+        tags.each { |tag| set_tag(hostname, tag) }
       end
-
     end
 
-    def remove_tags(hostnames, tags, options={})
-          
+    def remove_tags(hostnames, tags, _options = {})
+      #
+      # A backward-compatibilty wrapper to delete_tag().
+      #
       hostnames.each do |hostname|
-        host_uri = URI.join(@base_uri.to_s,"#{hostname}/")
-        extended_uri = URI.join(host_uri.to_s,"tags/")
-        tags.each do |tag|
-          final_uri = URI.join(extended_uri.to_s,tag)
-          RestClient.delete(final_uri.to_s, @headers)
+        tags.each { |tag| delete_tag(hostname, tag) }
+      end
+    end
+
+    def delete_tags(source)
+      #
+      # Delete all tags from a source. Maps to
+      # DELETE /api/manage/source/{source}/tags
+      #
+      fail Wavefront::Exception::InvalidSource unless valid_source?(source)
+      call_delete(build_uri(uri_concat(source, 'tags')))
+    end
+
+    def delete_tag(source, tag)
+      #
+      # Delete a given tag from a source. Maps to
+      # DELETE /api/manage/source/{source}/tags/{tag}
+      #
+      fail Wavefront::Exception::InvalidSource unless valid_source?(source)
+      fail Wavefront::Exception::InvalidString unless valid_string?(tag)
+      call_delete(build_uri(uri_concat(source, 'tags', tag)))
+    end
+
+    def show_sources(params = {})
+      #
+      # return a list of sources. Maps to
+      # GET /api/manage/source
+      # call it with a hash as described in the Wavefront API docs.
+      #
+      # At the time of writing, supported paramaters are:
+      #   lastEntityId (string)
+      #   desc         (bool)
+      #   limit        (int)
+      #   pattern      (string)
+      #
+      # Hash keys should be symbols.
+      #
+      if params.key?(:lastEntityId) &&
+         !params[:lastEntityId].is_a?(String)
+        fail TypeError
+      end
+
+      if params.key?(:pattern) && !params[:pattern].is_a?(String)
+        fail TypeError
+      end
+
+      if params.key?(:desc) && ! (params[:desc] == !!params[:desc])
+        fail TypeError
+      end
+
+      if params.key?(:limit)
+        fail TypeError unless params[:limit].is_a?(Numeric)
+
+        if params[:limit] < 0 || params[:limit] >= 10000
+          fail Wavefront::Exception::ValueOutOfRange
         end
       end
 
+      call_get(build_uri(nil, query: hash_to_qs(params)))
+    end
+
+    def show_source(source)
+      #
+      # return information about a single source. Maps to
+      # GET /api/manage/source/{source}
+      #
+      fail Wavefront::Exception::InvalidSource unless valid_source?(source)
+      call_get(build_uri(source))
+    end
+
+    def set_description(source, desc)
+      #
+      # set the description field for a source. Maps to
+      # POST /api/manage/source/{source}/description
+      #
+      fail Wavefront::Exception::InvalidSource unless valid_source?(source)
+      fail Wavefront::Exception::InvalidString unless valid_string?(desc)
+      call_post(build_uri(uri_concat(source, 'description')), desc)
+    end
+
+    def set_tag(source, tag)
+      #
+      # set a tag on a source. Maps to
+      # POST /api/manage/source/{source}/tags/{tag}
+      #
+      fail Wavefront::Exception::InvalidSource unless valid_source?(source)
+      fail Wavefront::Exception::InvalidString unless valid_string?(tag)
+      call_post(build_uri(uri_concat(source, 'tags', tag)))
     end
 
     private
 
-    def debug(enabled)
-      if enabled
-        RestClient.log = 'stdout'
-      end
+    def build_uri(path_ext = '', options = {})
+      options[:host] ||= DEFAULT_HOST
+      options[:path] ||= DEFAULT_PATH
+
+      URI::HTTPS.build(
+        host:  options[:host],
+        path:  uri_concat(options[:path], path_ext),
+        query: options[:query]
+      )
     end
 
+    def call_get(uri)
+      RestClient.get(uri.to_s, headers)
+    end
+
+    def call_delete(uri)
+      RestClient.delete(uri.to_s, headers)
+    end
+
+    def call_post(uri, query = nil)
+      h = headers
+
+      RestClient.post(uri.to_s, query,
+                      h.merge(:'Content-Type' => 'text/plain',
+                              :Accept         => 'application/json'
+                             )
+                     )
+    end
+
+    def debug(enabled)
+      RestClient.log = 'stdout' if enabled
+    end
   end
 end

data/lib/wavefront/mixins.rb

@@ -15,15 +15,18 @@ See the License for the specific language governing permissions and
 =end
 
 module Wavefront
+  #
+  # Various things which help around the place
+  #
   module Mixins
     def interpolate_schema(label, host, prefix_length)
       label_parts = label.split('.')
-      interpolated = Array.new
+      interpolated = []
       interpolated << label_parts.shift(prefix_length)
       interpolated << host
       interpolated << label_parts
       interpolated.flatten!
-      return interpolated.join('.')
+      interpolated.join('.')
     end
 
     def parse_time(t)
@@ -34,8 +37,7 @@ module Wavefront
         return t if t.is_a?(Integer)
         return t.to_i if t.is_a?(Time)
         return t.to_i if t.is_a?(String) && t.match(/^\d+$/)
-        return DateTime.parse("#{t} #{Time.now.getlocal.zone}").
-          to_time.utc.to_i
+        DateTime.parse("#{t} #{Time.now.getlocal.zone}").to_time.utc.to_i
       rescue
         raise "cannot parse timestamp '#{t}'."
       end
@@ -48,5 +50,17 @@ module Wavefront
       return false unless t.is_a?(Integer)
       (t.to_f * 1000).round
     end
+
+    def hash_to_qs(payload)
+      #
+      # Make a properly escaped query string out of a key: value
+      # hash.
+      #
+      URI.escape(payload.map { |k, v| [k, v].join('=') }.join('&'))
+    end
+
+    def uri_concat(*args)
+      args.join('/').squeeze('/')
+    end
   end
 end

data/lib/wavefront/response.rb

@@ -126,6 +126,8 @@ module Wavefront
             out = process_timeseries
           elsif self.respond_to?(:events)
             out = process_events
+          else
+            out = []
           end
         else
           out = self.warnings

data/lib/wavefront/validators.rb

@@ -0,0 +1,61 @@
+module Wavefront
+  #
+  # A module of mixins to validate input. The Wavefront documentation
+  # lays down restrictions on types and sizes of various inputs, which
+  # we will check on the user's behalf. Most of the information used in
+  # this file comes from https://community.wavefront.com/docs/DOC-1031
+  # some comes from the Swagger API documentation.
+  #
+  module Validators
+    def valid_source?(source)
+      #
+      # Check a source, according to
+      #
+      unless source.is_a?(String) && source.match(/^[a-z0-9\-_\.]+$/) &&
+             source.length < 1024
+        fail Wavefront::Exception::InvalidSource
+      end
+      true
+    end
+
+    def valid_string?(string)
+      #
+      # Only allows PCRE "word" characters, spaces, full-stops and
+      # commas in tags and descriptions. This might be too restrictive,
+      # but if it is, this is the only place we need to change it.
+      #
+      string.match(/^[\-\w \.,]*$/)
+    end
+
+    def valid_path?(path)
+      fail Wavefront::Exception::InvalidMetricName unless \
+        path.is_a?(String) && path.match(/^[a-z0-9\-_\.]+$/) &&
+        path.length < 1024
+      true
+    end
+
+    def valid_value?(value)
+      fail Wavefront::Exception::InvalidMetricValue unless value.is_a?(Numeric)
+      true
+    end
+
+    def valid_ts?(ts)
+      unless ts.is_a?(Time) || ts.is_a?(Date)
+        fail Wavefront::Exception::InvalidTimestamp
+      end
+      true
+    end
+
+    def valid_tags?(tags)
+      #
+      # Operates on a hash of key-value point tags. These are
+      # different from source tags.
+      #
+      tags.each do |k, v|
+        fail Wavefront::Exception::InvalidTag unless (k.length +
+             v.length < 254) && k.match(/^[a-z0-9\-_\.]+$/)
+      end
+      true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -21,11 +21,13 @@ require 'wavefront/metadata'
 require 'wavefront/alerting'
 require 'wavefront/events'
 require 'wavefront/batch_writer'
+require 'wavefront/validators'
 require 'wavefront/cli'
 require 'wavefront/cli/alerts'
 require 'wavefront/cli/events'
 require 'wavefront/cli/batch_write'
 require 'wavefront/cli/write'
+require 'wavefront/cli/sources'
 
 TEST_TOKEN = "test"
 TEST_HOST = "metrics.wavefront.com"
@@ -73,3 +75,7 @@ class Mocket
     return true
   end
 end
+
+def concat_url(*args)
+  'https://' + args.join('/').squeeze('/')
+end

data/spec/wavefront/batch_writer_spec.rb

@@ -408,116 +408,4 @@ describe Wavefront::BatchWriter do
 
   describe '#close_socket' do
   end
-
-  describe '#valid_path?' do
-    k = Wavefront::BatchWriter.new(opts)
-
-    it 'accepts a-z, 0-9, _ and -' do
-      expect(k.valid_path?('a.l33t.metric_path-passes')).to be(true)
-    end
-
-    it 'accepts nearly very long paths' do
-      expect(k.valid_path?('a' * 1023)).to be(true)
-    end
-
-    it 'rejects very long paths' do
-      expect{k.valid_path?('a' * 1024)}.to raise_exception(
-        Wavefront::Exception::InvalidMetricName)
-    end
-
-    it 'rejects upper-case letters' do
-      expect{k.valid_path?('NO.NEED.TO.SHOUT')}.to raise_exception(
-        Wavefront::Exception::InvalidMetricName)
-    end
-
-    it 'rejects odd characters' do
-      expect{k.valid_path?('metric.is.(>_<)')}.to raise_exception(
-        Wavefront::Exception::InvalidMetricName)
-    end
-  end
-
-  describe '#valid_value?' do
-    k = Wavefront::BatchWriter.new(opts)
-
-    it 'accepts integers' do
-      expect(k.valid_value?(123456)).to be(true)
-    end
-
-    it 'accepts 0' do
-      expect(k.valid_value?(0)).to be(true)
-    end
-
-    it 'accepts negative integers' do
-      expect(k.valid_value?(-10)).to be(true)
-    end
-
-    it 'accepts decimals' do
-      expect(k.valid_value?(1.2345678)).to be(true)
-    end
-
-    it 'accepts exponential notation' do
-      expect(k.valid_value?(1.23e04)).to be(true)
-    end
-
-    it 'rejects strings which look like numbers' do
-      expect { k.valid_value?('1.23')}.to raise_exception(
-        Wavefront::Exception::InvalidMetricValue)
-    end
-  end
-
-  describe '#valid_ts?' do
-    k = Wavefront::BatchWriter.new(opts)
-
-    it 'rejects integers' do
-      expect { k.valid_ts?(Time.now.to_i) }.to raise_exception(
-        Wavefront::Exception::InvalidTimestamp)
-    end
-
-    it 'accepts Times' do
-      expect(k.valid_ts?(Time.now)).to be(true)
-    end
-
-    it 'accepts DateTimes' do
-      expect(k.valid_ts?(DateTime.now)).to be(true)
-    end
-
-    it 'accepts Dates' do
-      expect(k.valid_ts?(Date.today)).to be(true)
-    end
-  end
-
-  describe '#valid_tags?' do
-    k = Wavefront::BatchWriter.new(opts)
-
-    it 'accepts zero tags' do
-      expect(k.valid_tags?({})).to be(true)
-    end
-
-    it 'accepts nice sensible tags' do
-      expect(k.valid_tags?({tag1: 'val1', tag2: 'val2'})).to be(true)
-    end
-
-    it 'accepts spaces and symbols in values' do
-      expect(k.valid_tags?({tag1: 'val 1', tag2: 'val 2'})).to be(true)
-      expect(k.valid_tags?({tag1: '(>_<)', tag2: '^_^'})).to be(true)
-    end
-
-    it 'rejects spaces and symbols in keys' do
-      expect { k.valid_tags?({'tag 1' => 'val1',
-                              'tag 2' => 'val2'}) }.to raise_exception(
-        Wavefront::Exception::InvalidTag)
-      expect { k.valid_tags?({'(>_<)' => 'val1',
-                              '^_^'   => 'val2'}) }.to raise_exception(
-        Wavefront::Exception::InvalidTag)
-    end
-
-    it 'rejects long keys and/or values' do
-      expect { k.valid_tags?({tag1: 'v' * 255}) }.to raise_exception(
-        Wavefront::Exception::InvalidTag)
-      expect { k.valid_tags?({'k' * 255 => 'val1'}) }.to raise_exception(
-        Wavefront::Exception::InvalidTag)
-      expect { k.valid_tags?({'k' * 130 => 'v' * 130}) }.to raise_exception(
-        Wavefront::Exception::InvalidTag)
-    end
-  end
 end

data/spec/wavefront/cli/sources_spec.rb

@@ -0,0 +1,40 @@
+#
+# Due to dependency requirements, webmock does not work with Ruby
+# 1.9.3. For as long as we have to support that, it's off the table.
+#
+require 'spec_helper'
+#require 'webmock/rspec'
+
+opts = {
+  token: TEST_TOKEN,
+}
+
+describe Wavefront::Cli::Sources do
+  attr_reader :wf, :host, :path, :headers, :post_headers
+
+  before do
+    @wf = Wavefront::Cli::Sources.new(opts, nil)
+    @wf.setup_wf
+    @host = Wavefront::Metadata::DEFAULT_HOST
+    @path = Wavefront::Metadata::DEFAULT_PATH
+    @headers = { :'X-AUTH-TOKEN' => TEST_TOKEN }
+    @post_headers =headers.merge(
+      { :'Content-Type' => 'text/plain', :Accept => 'application/json' })
+
+  end
+
+  #describe '#list_source_handler' do
+    #it 'makes API request with default options' do
+      #stub_request(:get, "https://metrics.wavefront.com/api/manage/source/?desc=false&limit=100&pattern=mysource").
+      #with(:headers => {'Accept'=>'*/*; q=0.5, application/xml', 'Accept-Encoding'=>'gzip, deflate', 'User-Agent'=>'Ruby', 'X-Auth-Token'=>'test'}).
+      #to_return(:status => 200, :body => "{}", :headers => {})
+      #wf.list_source_handler('mysource',)
+      #expect(wf).to receive(:display_data).with('list_source', '')
+    #end
+
+    #it 'handles an invalid source' do
+      #expect{wf.show_source('!INVALID!')}.
+        #to raise_exception(Wavefront::Exception::InvalidSource)
+    #end
+  #end
+end

data/spec/wavefront/cli_spec.rb

@@ -59,10 +59,10 @@ describe Wavefront::Cli do
     expect(pf[:token]).to eq('12345678-abcd-1234-abcd-123456789012')
   end
 
-  it 'prefers command-line options to config file values' do
+  it 'prefers config file values to command-line options' do
     k = Wavefront::Cli.new({config: cf, format: 'graphite'}, false)
     pf = k.load_profile
-    expect(pf[:format]).to eq('graphite')
+    expect(pf[:format]).to eq('human')
     expect(pf[:token]).to eq('12345678-abcd-1234-abcd-123456789012')
   end
 end