wavefront-sdk 1.6.2 → 2.0.0

data/lib/wavefront-sdk/base_write.rb

@@ -1,185 +0,0 @@
-require 'socket'
-require_relative 'constants'
-require_relative 'base'
-
-HOSTNAME = Socket.gethostname.freeze
-
-module Wavefront
-  #
-  # This class helps you send points to Wavefront. It is extended by
-  # the Write and Report classes, which respectively handle point
-  # ingestion by a proxy and directly to the API.
-  #
-  class BaseWrite < Base
-    attr_reader :sock, :summary
-
-    # Construct an object which allows us to write points to a
-    # Wavefront proxy.
-    #
-    # @param _creds [Hash] dummy parameter for correct method
-    #   signature.
-    # @param options [Hash] can contain the following keys:
-    #   proxy [String] the address of the Wavefront proxy. ('wavefront')
-    #   port [Integer] the port of the Wavefront proxy (2878)
-    #   tags [Hash] point tags which will be applied to every point
-    #   noop [Bool] if true, no proxy connection will be made, and
-    #     instead of sending the points, they will be printed in
-    #     Wavefront wire format.
-    #   novalidate [Bool] if true, points will not be validated.
-    #     This might make things go marginally quicker if you have
-    #     done point validation higher up in the chain.
-    #   verbose [Bool]
-    #   debug [Bool]
-    #
-    def post_initialize(_creds = {}, options = {})
-      defaults = { tags:       nil,
-                   noop:       false,
-                   novalidate: false,
-                   verbose:    false,
-                   debug:      false }
-
-      @summary = { sent: 0, rejected: 0, unsent: 0 }
-      @opts = setup_options(options, defaults)
-
-      wf_point_tags?(opts[:tags]) if opts[:tags]
-    end
-
-    def setup_options(user, defaults)
-      defaults.merge(user)
-    end
-
-    # Send multiple points to Wavefront.
-    #
-    # @param points [Array[Hash]] an array of points. Each 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.
-    # @param openclose [Bool] if this is false, you must have
-    #   already opened a socket 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 true if no points are rejected, otherwise false
-    #
-    def write(points = [], openclose = true, prefix = nil)
-      open if openclose
-
-      begin
-        _write_loop(prepped_points(points, prefix))
-      ensure
-        close if openclose
-      end
-
-      s_str = summary_string(summary)
-
-      resp = { status:   { result: s_str, message: nil, code: nil },
-               response: summary }.to_json
-
-      Wavefront::Response.new(resp, nil, opts)
-    end
-
-    def summary_string(summary)
-      summary[:unsent].zero? && summary[:rejected].zero? ? 'OK' : 'ERROR'
-    end
-
-    # @return [Array] of points
-    #
-    def prepped_points(points, prefix = nil)
-      ret = [points].flatten
-
-      if prefix
-        ret.map! { |pt| pt.tap { |p| p[:path] = prefix + '.' + p[:path] } }
-      end
-
-      ret
-    end
-
-    # A wrapper method around #write() which guarantees all points
-    # will be sent as deltas. You can still manually prefix any
-    # metric with a delta symbol and use #write(), but depending on
-    # your use-case, this method may be safer. It's easy to forget
-    # the delta.
-    #
-    # @param points [Array[Hash]] see #write()
-    # @param openclose [Bool] see #write()
-    #
-    def write_delta(points, openclose = true)
-      write(paths_to_deltas(points), openclose)
-    end
-
-    # Prefix all paths in a points array (as passed to
-    # #write_delta() with a delta symbol
-    #
-    # @param points [Array[Hash]] see #write()
-    # @return [Array[Hash]]
-    #
-    def paths_to_deltas(points)
-      [points].flatten.map { |p| p.tap { p[:path] = DELTA + p[:path] } }
-    end
-
-    def valid_point?(point)
-      return true if opts[:novalidate]
-      wf_point?(point)
-    rescue Wavefront::Exception::InvalidMetricName,
-           Wavefront::Exception::InvalidMetricValue,
-           Wavefront::Exception::InvalidTimestamp,
-           Wavefront::Exception::InvalidSourceId,
-           Wavefront::Exception::InvalidTag => e
-      log('Invalid point, skipping.', :info)
-      log(format('Invalid point: %s (%s)', point, e.to_s), :debug)
-      summary[:rejected] += 1
-      false
-    end
-
-    # Convert a validated point to a string conforming to
-    # https://community.wavefront.com/docs/DOC-1031.  No validation
-    # is done here.
-    #
-    # @param point [Hash] a hash describing a point. See #write() for
-    #   the format.
-    #
-    def hash_to_wf(point)
-      format('%s %s %s source=%s %s %s',
-             *point_array(point)).squeeze(' ').strip
-    rescue StandardError
-      raise Wavefront::Exception::InvalidPoint
-    end
-
-    # Make an array which can be used by #hash_to_wf.
-    # @param point [Hash] a hash describing a point. See #write() for
-    #   the format.
-    # @raise
-    #
-    def point_array(point)
-      [point[:path] || raise,
-       point[:value] || raise,
-       point.fetch(:ts, nil),
-       point.fetch(:source, HOSTNAME),
-       point[:tags] && point[:tags].to_wf_tag,
-       opts[:tags] && opts[:tags].to_wf_tag]
-    end
-
-    # Wrapper for #really_send_point(), which really sends points.
-    #
-    # @param point [String] a point description, probably from
-    #   #hash_to_wf()
-    #
-    def send_point(point)
-      if opts[:noop]
-        log "Would send: #{point}"
-        return
-      end
-
-      log("Sending: #{point}", :debug)
-      really_send_point(point)
-    end
-  end
-end

data/lib/wavefront-sdk/stdlib.rb

@@ -1,5 +0,0 @@
-require 'pathname'
-
-(Pathname.new(__FILE__).dirname + 'stdlib').realpath.children.each do |f|
-  require f if f.extname == '.rb'
-end

data/lib/wavefront-sdk/version.rb

@@ -1 +0,0 @@
-WF_SDK_VERSION = '1.6.2'.freeze

data/spec/wavefront-sdk/base_write_spec.rb

@@ -1,82 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative '../../lib/wavefront-sdk/base_write.rb'
-require_relative '../spec_helper'
-require_relative 'resources/dummy_points'
-
-# rubocop:disable Style/MutableConstant
-WBWT_CREDS = { endpoint: 'stub.wavefront.com', token: 'tkn' }
-# rubocop:enable Style/MutableConstant
-
-class WavefrontBaseWriteTest < MiniTest::Test
-  attr_reader :wf, :wf_tags
-
-  def setup
-    @wf = Wavefront::BaseWrite.new(WBWT_CREDS)
-    # @wf_noop = Wavefront::Write.new(W_CREDS, noop: true)
-    @wf_tags = Wavefront::BaseWrite.new(WBWT_CREDS, tags: TAGS)
-  end
-
-  def test_summary_string
-    assert_equal('OK', wf.summary_string(unsent: 0, rejected: 0))
-    assert_equal('ERROR', wf.summary_string(unsent: 0, rejected: 1))
-    assert_equal('ERROR', wf.summary_string(unsent: 1, rejected: 0))
-  end
-
-  def test_prepped_points
-    assert_equal wf.prepped_points(%w[p1 p2 p3 p4]), %w[p1 p2 p3 p4]
-    assert_equal wf.prepped_points([%w[p1 p2 p3 p4]]), %w[p1 p2 p3 p4]
-    assert_equal wf.prepped_points('p1'), %w[p1]
-    assert_equal wf.prepped_points(
-      [{ path: 'p1' }, { path: 'p2' }, { path: 'p3' }], 'prefix'
-    ),
-                 [{ path: 'prefix.p1' }, { path: 'prefix.p2' },
-                  { path: 'prefix.p3' }]
-
-    assert_equal wf.prepped_points({ path: 'p1' }, 'prefix'),
-                 [{ path: 'prefix.p1' }]
-  end
-
-  def test_paths_to_deltas
-    x = wf.paths_to_deltas(POINTS.dup)
-    assert_equal(x.size, 2)
-
-    x.each do |p|
-      assert_instance_of(Hash, p)
-      assert(p[:path].start_with?(DELTA))
-    end
-  end
-
-  def test_hash_to_wf
-    assert_equal(wf.hash_to_wf(POINT),
-                 'test.metric 123456 1469987572 ' \
-                 'source=testhost t1="v1" t2="v2"')
-    assert_equal(wf_tags.hash_to_wf(POINT),
-                 'test.metric 123456 1469987572 ' \
-                 'source=testhost t1="v1" t2="v2" ' \
-                 'gt1="gv1" gt2="gv2"')
-
-    p1 = POINT.dup
-    p1.delete(:ts)
-    assert_equal(wf.hash_to_wf(p1),
-                 'test.metric 123456 source=testhost t1="v1" t2="v2"')
-
-    p2 = POINT.dup
-    p2.delete(:tags)
-    assert_equal(wf.hash_to_wf(p2),
-                 'test.metric 123456 1469987572 source=testhost')
-
-    %i[value path].each do |k|
-      p3 = POINT.dup
-      p3.delete(k)
-
-      assert_raises(Wavefront::Exception::InvalidPoint) do
-        wf.hash_to_wf(p3)
-      end
-
-      assert_raises(Wavefront::Exception::InvalidPoint) do
-        wf_tags.hash_to_wf(p3)
-      end
-    end
-  end
-end

data/spec/wavefront-sdk/response_spec.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-#
-require_relative '../spec_helper'
-require_relative '../../lib/wavefront-sdk/exception'
-require_relative '../../lib/wavefront-sdk/response'
-
-WF_JSON = '{"status":{"result":"OK","message":"","code":200},' \
-          '"response":{"items":[{"name":"test agent"}],"offset":0,' \
-          '"limit":100,"totalItems":3,"moreItems":false}}'.freeze
-
-# Unit tests for Response class
-#
-class WavefrontResponseTest < MiniTest::Test
-  def test_initialize_good_data
-    wf = Wavefront::Response.new(WF_JSON, 200)
-    assert_instance_of(Wavefront::Response, wf)
-    assert_respond_to(wf, :status)
-    assert_respond_to(wf, :response)
-    assert_respond_to(wf.response, :items)
-    refute_respond_to(wf, :to_a)
-    %i[code message result].each { |m| assert_respond_to(wf.status, m) }
-    assert_equal(wf.status.code, 200)
-    assert_instance_of(Array, wf.response.items)
-  end
-
-  def test_initialize_bad_data; end
-
-  def test_build_response
-    wf = Wavefront::Response.new(WF_JSON, 200)
-    assert_equal(Map.new, wf.build_response({}))
-    assert_equal(Map.new, wf.build_response([]))
-    assert_equal(Map.new, wf.build_response('string'))
-    assert_equal(Map.new(key: 123), wf.build_response(key: 123))
-    assert_equal(123, wf.build_response(response: 123))
-    assert_equal([1, 2], wf.build_response(response: [1, 2]))
-    assert_equal(Map.new(key: 123),
-                 wf.build_response(response: { key: 123 }))
-  end
-end