wavefront-sdk 1.6.2 → 2.0.0

data/lib/wavefront-sdk/writers/api.rb

@@ -0,0 +1,38 @@
+require_relative 'core'
+require_relative '../core/api_caller'
+
+module Wavefront
+  module Writer
+    #
+    # Send points direct to Wavefront's API. This requires an
+    # endpoint, a token, and HTTPS egress.
+    #
+    class Api < Core
+      def open
+        @conn = Wavefront::ApiCaller.new(self, creds, opts)
+      end
+
+      def api_path
+        '/report'
+      end
+
+      def validate_credentials(creds)
+        unless creds.key?(:endpoint)
+          raise(Wavefront::Exception::CredentialError,
+                'credentials must contain API endpoint')
+        end
+
+        return true if creds.key?(:token)
+
+        raise(Wavefront::Exception::CredentialError,
+              'credentials must contain API token')
+      end
+
+      private
+
+      def _send_point(point)
+        conn.post('/?f=wavefront', point, 'application/octet-stream')
+      end
+    end
+  end
+end

data/lib/wavefront-sdk/writers/core.rb

@@ -0,0 +1,146 @@
+require 'json'
+require_relative 'summary'
+require_relative '../core/response'
+require_relative '../validators'
+
+module Wavefront
+  module Writer
+    #
+    # Abstract class extended by the other writers. Methods
+    # required whatever mechanism actually sends the points.
+    #
+    # A point is defined as a hash with the following keys:
+    # path   [String] metric path. (mandatory)
+    # value  [Numeric] value of metric. Numeric. Mandatory.
+    # ts     [Time, Integer] timestamp for point. Defaults to
+    #                       current UTC time.
+    # source [String] originating source of metric. Defaults to
+    #                 the local hostname.
+    # tags   [Hash] key:value point tags which will be applied in
+    #               addition to any tags defined in the #initialize()
+    #               method.
+    #
+    class Core
+      attr_reader :creds, :opts, :logger, :summary, :conn, :calling_class
+
+      include Wavefront::Validators
+
+      def initialize(calling_class)
+        @calling_class = calling_class
+        @creds         = calling_class.creds
+        @opts          = calling_class.opts
+        @logger        = calling_class.logger
+        @summary       = Wavefront::Writer::Summary.new
+
+        validate_credentials(creds) if respond_to?(:validate_credentials)
+        post_initialize(creds, opts) if respond_to?(:post_initialize)
+      end
+
+      # Send multiple points to Wavefront.
+      #
+      # @param points [Array[Hash]] an array of points.
+      # @param openclose [Bool] if this is false, you must have
+      #   already opened a connection to the proxy. If it is true, a
+      #   connection will be opened for you, used, and closed.
+      # @param prefix [String] prefix all metrics with this string. No
+      #   trailing dot is required.
+      # @raise any unhandled point validation error is passed through
+      # @return [Wavefront::Response]
+      #
+      def write(points = [], openclose = true, prefix = nil)
+        open if openclose && respond_to?(:open)
+
+        points = screen_points(points)
+        points = prefix_points(points, prefix)
+
+        begin
+          write_loop(points)
+        ensure
+          close if openclose && respond_to?(:close)
+        end
+
+        respond
+      end
+
+      def respond
+        Wavefront::Response.new(
+          { status:   { result: summary.result, message: nil, code: nil },
+            response: summary.to_h }.to_json, nil, opts
+        )
+      end
+
+      # Call the inheriting class's #_send_point method, and handle
+      # the summary
+      #
+      def send_point(point)
+        _send_point(point)
+        summary.sent += 1
+        true
+      rescue StandardError => e
+        summary.unsent += 1
+        logger.log('WARNING: failed to send point.')
+        logger.log(e.to_s, :debug)
+        false
+      end
+
+      # Wrapper around calling_class's #_hash_to_wf to facilitate
+      # verbosity/debugging. (The actual work is done in the calling
+      # class because it is not always on the same data type.)
+      #
+      # @param point [Hash] a hash describing a point. See #write() for
+      #   the format.
+      # @return [String]
+      #
+      def hash_to_wf(point)
+        wf_point = calling_class.hash_to_wf(point)
+        logger.log(wf_point, :info)
+        wf_point
+      end
+
+      # Prefix points with a given string
+      # @param points [Array,Hash] one or more points
+      # @param prefix [String] prefix to apply to every point
+      # @return [Array] of points
+      #
+      def prefix_points(points, prefix = nil)
+        ret = [points].flatten
+        return ret unless prefix
+
+        ret.map { |pt| pt.tap { |p| p[:path] = prefix + '.' + p[:path] } }
+      end
+
+      # Filter invalid points out of an array of points
+      # @param points [Array,Hash] one or more points
+      # @return [Array] of points
+      #
+      def screen_points(points)
+        return points if opts[:novalidate]
+
+        [points].flatten.select { |p| valid_point?(p) }
+      end
+
+      def valid_point?(point)
+        send(calling_class.validation, point)
+      rescue Wavefront::Exception::InvalidMetricName,
+             Wavefront::Exception::InvalidMetricValue,
+             Wavefront::Exception::InvalidTimestamp,
+             Wavefront::Exception::InvalidSourceId,
+             Wavefront::Exception::InvalidTag => e
+        logger.log('Invalid point, skipping.', :info)
+        logger.log(e.class, :info)
+        logger.log(format('Invalid point: %s (%s)', point, e.to_s), :debug)
+        summary.rejected += 1
+        false
+      end
+
+      private
+
+      def write_loop(points)
+        points.each do |p|
+          p[:ts] = p[:ts].to_i if p[:ts].is_a?(Time)
+          send_point(hash_to_wf(p))
+        end
+      end
+    end
+  end
+end

data/lib/wavefront-sdk/writers/http.rb

@@ -0,0 +1,42 @@
+require_relative 'core'
+require_relative '../core/api_caller'
+
+module Wavefront
+  module Writer
+    #
+    # HTTP POST points to a local proxy. This method does not
+    # support any authentication or authorization, as these are not
+    # supported by the proxy at the time of writing. When the proxy
+    # acquires these functions, a new writer will be made.
+    #
+    class Http < Core
+      def open
+        creds[:endpoint] = format('%s:%s', creds[:proxy],
+                                  creds[:port] || default_port)
+        opts[:scheme] = 'http'
+        @conn = Wavefront::ApiCaller.new(self, creds, opts)
+      end
+
+      def api_path
+        nil
+      end
+
+      def default_port
+        2878
+      end
+
+      def validate_credentials(creds)
+        return true if creds.key?(:proxy)
+
+        raise(Wavefront::Exception::CredentialError,
+              'credentials must contain proxy')
+      end
+
+      private
+
+      def _send_point(point)
+        conn.post(nil, point).ok?
+      end
+    end
+  end
+end

data/lib/wavefront-sdk/writers/socket.rb

@@ -0,0 +1,66 @@
+require_relative 'core'
+
+module Wavefront
+  module Writer
+    #
+    # Everything specific to writing points to a Wavefront proxy, in
+    # native Wavefront format, to a socket. (The original and,
+    # once, only way to send points.)
+    #
+    class Socket < Core
+      # Open a socket to a Wavefront proxy, putting the descriptor
+      # in instance variable @conn.
+      # @return [TCPSocket]
+      #
+      # rubocop:disable Metrics/AbcSize
+      def open
+        if opts[:noop]
+          logger.log('No-op requested. Not opening connection to proxy.')
+          return true
+        end
+
+        port = creds[:port] || default_port
+        logger.log("Connecting to #{creds[:proxy]}:#{port}.", :debug)
+
+        begin
+          @conn = TCPSocket.new(creds[:proxy], port)
+        rescue StandardError => e
+          logger.log(e, :error)
+          raise Wavefront::Exception::InvalidEndpoint
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # Close the connection described by the @conn instance variable.
+      #
+      def close
+        return if opts[:noop]
+
+        logger.log('Closing connection to proxy.', :debug)
+        conn.close
+      end
+
+      def validate_credentials(creds)
+        return true if creds.key?(:proxy)
+
+        raise(Wavefront::Exception::CredentialError,
+              'creds must contain proxy address')
+      end
+
+      private
+
+      # @param point [String] point or points in native Wavefront
+      # format.
+      #
+      def _send_point(point)
+        conn.puts(point)
+      end
+
+      # return [Integer] the port to connect to, if none is supplied
+      #
+      def default_port
+        2878
+      end
+    end
+  end
+end

data/lib/wavefront-sdk/writers/summary.rb

@@ -0,0 +1,39 @@
+module Wavefront
+  module Writer
+    #
+    # Count and report on points we attempt to send to Wavefront.
+    #
+    class Summary
+      attr_accessor :sent, :rejected, :unsent
+
+      def initialize
+        @sent     = 0
+        @rejected = 0
+        @unsent   = 0
+      end
+
+      # @return [String] OK if all points were sent, ERROR if not
+      #
+      def result
+        ok? ? 'OK' : 'ERROR'
+      end
+
+      # Were all points sent successfully? (This does not
+      # necessarily mean they were received -- it depends on the
+      # writer class. Sockets are dumb, HTTP is smart.)
+      # @return [Bool]
+      #
+      def ok?
+        unsent.zero? && rejected.zero?
+      end
+
+      # Representation of summary as it used to be when it was built
+      # into the Write class
+      # @return [Hash]
+      #
+      def to_h
+        { sent: sent, rejected: rejected, unsent: unsent }
+      end
+    end
+  end
+end

data/lib/wavefront_sdk.rb

@@ -0,0 +1,9 @@
+# Automatically load all SDK classes.
+#
+require 'pathname'
+
+libdir = Pathname.new(__FILE__).dirname + 'wavefront-sdk'
+
+libdir.children.select { |f| f.extname == '.rb' }.each do |f|
+  require_relative f
+end

data/spec/spec_helper.rb

@@ -26,6 +26,9 @@ DUMMY_RESPONSE = '{"status":{"result":"OK","message":"","code":200},' \
                  '"response":{"items":[{"name":"test data"}],"offset":0,' \
                  '"limit":100,"totalItems":3,"moreItems":false}}'.freeze
 
+RESOURCE_DIR = (Pathname.new(__FILE__).dirname +
+                'wavefront-sdk' + 'resources').freeze
+
 # Common testing code
 class WavefrontTestBase < MiniTest::Test
   attr_reader :wf, :wf_noop, :headers

data/spec/wavefront-sdk/alert_spec.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
+require 'spy/integration'
 
 ALERT = '1481553823153'.freeze
 ALERT_BODY = {
@@ -20,6 +21,11 @@ class WavefrontAlertTest < WavefrontTestBase
     should_work(:list, 10, '?offset=10&limit=100')
   end
 
+  def test_list_all
+    should_work(:list, [0, :all], '?limit=999&offset=0')
+    should_work(:list, [20, :all], '?limit=20&offset=0')
+  end
+
   def test_update_keys
     assert_instance_of(Array, wf.update_keys)
     wf.update_keys.each { |k| assert_instance_of(Symbol, k) }

data/spec/wavefront-sdk/{base_spec.rb → core/api_caller_spec.rb}

@@ -1,70 +1,65 @@
 #!/usr/bin/env ruby
 
-require_relative '../spec_helper'
-require_relative '../../lib/wavefront-sdk/base'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/core/api_caller'
 
+# Wavefront::ApiCaller needs a class which responds to #api_base as
+# its first argument
 #
-# Test SDK base class
+class Dummy
+  def api_base
+    '/base'
+  end
+
+  def api_path
+    ['', 'api', 'v2', api_base].uri_concat
+  end
+end
+
+# Test Wavefront API caller
 #
-class WavefrontBaseTest < MiniTest::Test
+class WavefrontApiCallerTest < MiniTest::Test
   attr_reader :wf, :wf_noop, :uri_base, :headers
 
   def setup
-    @wf = Wavefront::Base.new(CREDS)
-    @wf_noop = Wavefront::Base.new(CREDS, noop: true)
+    @wf = Wavefront::ApiCaller.new(Dummy.new, CREDS)
+    @wf_noop = Wavefront::ApiCaller.new(Dummy.new, CREDS, noop: true)
     @uri_base = "https://#{CREDS[:endpoint]}/api/v2/base"
     @headers = { 'Authorization' => "Bearer #{CREDS[:token]}" }
     @update_keys = []
   end
 
-  def test_time_to_ms
-    now_ms = Time.now.to_i * 1000
-    assert_equal wf.time_to_ms(now_ms), now_ms
-    assert_equal wf.time_to_ms(1_469_711_187), 1_469_711_187_000
-    refute wf.time_to_ms([])
-    refute wf.time_to_ms('1469711187')
-  end
-
-  def test_uri_concat
-    assert_equal %w[a b].uri_concat, 'a/b'
-    assert_equal ['', 'a', 'b'].uri_concat, '/a/b'
-    assert_equal %w[a /b].uri_concat, 'a/b'
-    assert_equal ['', 'a', 'b/'].uri_concat, '/a/b'
-    assert_equal %w[/a /b/ /c].uri_concat, '/a/b/c'
-    assert_equal ['/a', '/b c'].uri_concat, '/a/b c'
-  end
-
-  def test_api_get
+  def test_get
     uri = "#{uri_base}/path?key1=val1"
     stub_request(:get, uri).to_return(body: DUMMY_RESPONSE, status: 200)
-    wf.api_get('/path', key1: 'val1')
+    wf.get('/path', key1: 'val1')
     assert_requested(:get, uri, headers: headers)
   end
 
-  def test_api_post
+  def test_post
     uri = "#{uri_base}/path"
     obj = { key: 'value' }
     stub_request(:post, uri).to_return(body: DUMMY_RESPONSE, status: 200)
-    wf.api_post('/path', 'string')
+    wf.post('/path', 'string')
     assert_requested(:post, uri, body: 'string',
                                  headers: headers.merge(POST_HEADERS))
-    wf.api_post('/path', obj)
+    wf.post('/path', obj)
     assert_requested(:post, uri, body: obj.to_json,
                                  headers: headers.merge(POST_HEADERS))
   end
 
-  def test_api_put
+  def test_put
     uri = "#{uri_base}/path"
     stub_request(:put, uri).to_return(body: DUMMY_RESPONSE, status: 200)
-    wf.api_put('/path', 'body')
+    wf.put('/path', 'body')
     assert_requested(:put, uri, body: 'body'.to_json,
                                 headers: headers.merge(JSON_POST_HEADERS))
   end
 
-  def test_api_delete
+  def test_delete
     uri = "#{uri_base}/path"
     stub_request(:delete, uri).to_return(body: DUMMY_RESPONSE, status: 200)
-    wf.api_delete('/path')
+    wf.delete('/path')
     assert_requested(:delete, uri, headers: headers)
   end
 
@@ -73,16 +68,8 @@ class WavefrontBaseTest < MiniTest::Test
 
     %w[get post put delete].each do |call|
       stub_request(call.to_sym, uri)
-      wf_noop.send("api_#{call}", '/path')
+      wf_noop.send(call, '/path')
       refute_requested(call.to_sym, uri)
     end
   end
-
-  def test_hash_for_update
-    wf.instance_variable_set('@update_keys', %i[k1 k2])
-    body = { k1: 'ov1', k2: 'ov2', k3: 'ov3' }
-    upd = { k2: 'nv1' }
-
-    assert_equal(wf.hash_for_update(body, upd), k1: 'ov1', k2: 'nv1')
-  end
 end