wavefront-sdk 5.4.4 → 7.0.0

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

@@ -1,70 +1,58 @@
 # frozen_string_literal: true
 
+require 'socket'
 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.)
+    # Everything specific to writing points to a Unix datagram socket.
     #
     class Socket < Core
-      # Open a socket to a Wavefront proxy, putting the descriptor
-      # in instance variable @conn.
-      # @return [TCPSocket]
+      # Make a connection to a Unix datagram socket, putting the
+      # descriptor in instance variable @conn.
+      # This requires the name of the socket file in creds[:socket]
+      # @return [UnixSocket]
       #
       def open
         if opts[:noop]
-          logger.log('No-op requested. Not opening connection to proxy.')
+          logger.log('No-op requested. Not opening socket connection.')
           return true
         end
 
-        port = creds[:port] || default_port
-        logger.log("Connecting to #{creds[:proxy]}:#{port}.", :debug)
-        open_socket(creds[:proxy], port)
+        logger.log("Connecting to #{creds[:socket]}.", :debug)
+        open_socket(creds[:socket])
       end
 
-      # Close the connection described by the @conn instance variable.
-      #
       def close
         return if opts[:noop]
 
-        logger.log('Closing connection to proxy.', :debug)
+        logger.log('Closing socket connection.', :debug)
         conn.close
       end
 
       def validate_credentials(creds)
-        return if creds.key?(:proxy) && creds[:proxy]
+        return true if creds.key?(:socket) && creds[:socket]
 
         raise(Wavefront::Exception::CredentialError,
-              'credentials must contain proxy address')
+              'credentials must contain socket file path')
       end
 
       private
 
-      def open_socket(proxy, port)
-        @conn = TCPSocket.new(proxy, port)
+      def open_socket(socket)
+        @conn = UNIXSocket.new(socket)
       rescue StandardError => e
         logger.log(e, :error)
         raise Wavefront::Exception::InvalidEndpoint
       end
 
       # @param point [String] point or points in native Wavefront format.
-      # @raise [SocketError] if point cannot be written
       #
       def _send_point(point)
         return if opts[:noop]
 
-        conn.puts(point)
-      rescue StandardError
-        raise Wavefront::Exception::SocketError
-      end
-
-      # return [Integer] the port to connect to, if none is supplied
-      #
-      def default_port
-        2878
+        conn.write(point)
       end
     end
   end

data/lib/wavefront_sdk.rb

@@ -4,7 +4,7 @@
 #
 require 'pathname'
 
-libdir = Pathname.new(__dir__) + 'wavefront-sdk'
+libdir = Pathname.new(__dir__).join('wavefront-sdk')
 
 libdir.children.select { |f| f.extname == '.rb' }.each do |f|
   require_relative f

data/spec/constants.rb

@@ -19,8 +19,8 @@ DUMMY_RESPONSE = '{"status":{"result":"OK","message":"","code":200},' \
                  '"response":{"items":[{"name":"test data"}],"offset":0,' \
                  '"limit":100,"totalItems":3,"moreItems":false}}'
 
-RESOURCE_DIR = (Pathname.new(__FILE__).dirname +
-                'wavefront-sdk' + 'resources').freeze
+RESOURCE_DIR = Pathname.new(__FILE__).dirname.join('wavefront-sdk',
+                                                   'resources').freeze
 
 U_ACL_1 = 'someone@example.com'
 U_ACL_2 = 'other@elsewhere.com'

data/spec/test_mixins/general.rb

@@ -77,7 +77,7 @@ module WavefrontTest
 
     def test_update_keys
       assert_instance_of Array, wf.update_keys
-      assert(wf.update_keys.all? { |k| k.is_a?(Symbol) })
+      assert(wf.update_keys.all?(Symbol))
     end
   end
 

data/spec/wavefront-sdk/core/api_spec.rb

@@ -22,7 +22,7 @@ class WavefrontCoreApiTest < MiniTest::Test
   end
 
   def test_hash_for_update
-    wf.instance_variable_set('@update_keys', %i[k1 k2])
+    wf.instance_variable_set(:@update_keys, %i[k1 k2])
     body = { k1: 'ov1',
              k2: 'ov2',
              k3: 'ov3',

data/spec/wavefront-sdk/core/response_spec.rb

@@ -7,8 +7,8 @@ require_relative '../../../lib/wavefront-sdk/core/exception'
 require_relative '../../../lib/wavefront-sdk/core/response'
 
 GOOD_RESP = '{"status":{"result":"OK","message":"","code":200},' \
-             '"response":{"items":[{"name":"test agent"}],"offset":0,' \
-             '"limit":100,"totalItems":3,"moreItems":false}}'
+            '"response":{"items":[{"name":"test agent"}],"offset":0,' \
+            '"limit":100,"totalItems":3,"moreItems":false}}'
 
 BAD_RESP = "error='not_found'
 message='resource cannot be found'

data/spec/wavefront-sdk/credentials_spec.rb

@@ -5,8 +5,8 @@ require 'pathname'
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/credentials'
 
-CONF1 = RESOURCE_DIR + 'test.conf'
-CONF2 = RESOURCE_DIR + 'test2.conf'
+CONF1 = RESOURCE_DIR.join('test.conf')
+CONF2 = RESOURCE_DIR.join('test2.conf')
 
 # Test SDK base class end-to-end
 #
@@ -60,11 +60,7 @@ end
 # Test individual methods. We must override the constructor to do
 # this.
 #
-# rubocop:disable Lint/MissingSuper
-class Giblets < Wavefront::Credentials
-  def initialize; end
-end
-# rubocop:enable Lint/MissingSuper
+class Giblets < Wavefront::Credentials; end
 
 # And here are the tests
 #
@@ -119,9 +115,9 @@ class GibletsTest < MiniTest::Test
 
   def test_populate
     wf.populate(raw)
-    config = wf.instance_variable_get('@config')
-    creds = wf.instance_variable_get('@creds')
-    proxy = wf.instance_variable_get('@proxy')
+    config = wf.instance_variable_get(:@config)
+    creds = wf.instance_variable_get(:@creds)
+    proxy = wf.instance_variable_get(:@proxy)
 
     assert_instance_of(Map, config)
     assert_equal('raw_proxy', config.proxy)
@@ -143,8 +139,8 @@ class GibletsTest < MiniTest::Test
     assert_equal(3, x.length)
     x.each { |p| assert_instance_of(Pathname, p) }
     assert_includes(x, Pathname.new('/etc/wavefront/credentials'))
-    assert_includes(x, Pathname.new(ENV['HOME']) + '.wavefront')
-    assert_includes(x, Pathname.new(ENV['HOME']) + '.wavefront.conf')
+    assert_includes(x, Pathname.new(Dir.home).join('.wavefront'))
+    assert_includes(x, Pathname.new(Dir.home).join('.wavefront.conf'))
   end
 
   def test_cred_files_opts
@@ -197,7 +193,7 @@ class GibletsTest < MiniTest::Test
     end
 
     assert_raises Wavefront::Exception::InvalidConfigFile do
-      wf.load_profile(RESOURCE_DIR + 'malformed.conf')
+      wf.load_profile(RESOURCE_DIR.join('malformed.conf'))
     end
   end
 end

data/spec/wavefront-sdk/event_spec.rb

@@ -43,12 +43,58 @@ class WavefrontEventTest < WavefrontTestBase
     assert_raises(ArgumentError) { wf.close }
   end
 
+  def test_alert_firing_details
+    assert_gets("/api/v2/event/#{id}/alertFiringDetails") do
+      wf.alert_firing_details(id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidEventId) do
+      wf.alert_firing_details(invalid_id)
+    end
+  end
+
+  def test_alert_queries_slug
+    assert_gets("/api/v2/event/#{id}/alertQueriesSlug") do
+      wf.alert_queries_slug(id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidEventId) do
+      wf.alert_queries_slug(invalid_id)
+    end
+  end
+
+  def test_events
+    assert_gets(
+      "/api/v2/event/#{id}/events?isOverlapped=false&renderingMethod=HOST"
+    ) do
+      wf.events(id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidEventId) do
+      wf.events(invalid_id)
+    end
+  end
+
+  def test_alert_firings
+    assert_gets("/api/v2/event/alertFirings?alertId=#{alert_id}&asc=true") do
+      wf.alert_firings(alert_id, asc: true)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidAlertId) do
+      wf.alert_firings(invalid_id)
+    end
+  end
+
   private
 
   def id
     '1481553823153:testev'
   end
 
+  def alert_id
+    '1481553823153'
+  end
+
   def invalid_id
     'nonsense'
   end

data/spec/wavefront-sdk/metric_helper_spec.rb

@@ -4,6 +4,8 @@
 require 'minitest/autorun'
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/metric_helper'
+require_relative '../support/mocket'
+require_relative '../support/bad_mocket'
 
 ND_CREDS = { proxy: 'wavefront' }.freeze
 WH_TAGS  = { t1: 'v1', t2: 'v2' }.freeze

data/spec/wavefront-sdk/metricspolicy_spec.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+require_relative '../test_mixins/general'
+
+# Unit tests for MetricsPolicy class
+#
+class WavefrontMetricsPolicyTest < WavefrontTestBase
+  def test_describe
+    assert_gets('/api/v2/metricspolicy') { wf.describe }
+
+    assert_gets('/api/v2/metricspolicy/history/5') { wf.describe(5) }
+
+    assert_raises(Wavefront::Exception::InvalidVersion) do
+      wf.describe('v5')
+    end
+  end
+
+  def test_history
+    assert_gets('/api/v2/metricspolicy/history?offset=10&limit=100') do
+      wf.history(10)
+    end
+
+    assert_gets('/api/v2/metricspolicy/history?offset=12&limit=34') do
+      wf.history(12, 34)
+    end
+  end
+
+  def test_revert
+    assert_posts('/api/v2/metricspolicy/revert/5', nil, :json) do
+      wf.revert(5)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidVersion) do
+      wf.revert('v5')
+    end
+  end
+
+  def test_update
+    assert_puts('/api/v2/metricspolicy', payload.to_json) do
+      wf.update(payload)
+    end
+  end
+
+  private
+
+  def api_class
+    'metricspolicy'
+  end
+
+  def id
+    'a7d2e651-cec1-4154-a5e8-1946f57ef5b3'
+  end
+
+  def invalid_id
+    '+-+-+-+'
+  end
+
+  def payload
+    {
+      policyRules: [
+        {
+          name: 'Policy rule1 name',
+          description: 'Policy rule1 description',
+          prefixes: ['revenue.*'],
+          tags: [
+            {
+              key: 'sensitive',
+              value: 'false'
+            },
+            {
+              key: 'source',
+              value: 'app1'
+            }
+          ],
+          tagsAnded: 'true',
+          accessType: 'ALLOW',
+          accounts: %w[accountId1 accountId2],
+          userGroups: ['userGroupId1'],
+          roles: ['roleId']
+        },
+        {
+          name: 'Policy rule2 name',
+          description: 'Policy rule2 description',
+          prefixes: ['revenue.*'],
+          accessType: 'BLOCK',
+          accounts: ['accountId3'],
+          userGroups: ['userGroupId1']
+        }
+      ]
+    }
+  end
+end

data/spec/wavefront-sdk/misc_spec.rb

@@ -11,8 +11,8 @@ class WavefrontMiscTest < MiniTest::Test
   # defines itself as.
   #
   def test_version_vs_history
-    history_file = WF_SDK_LOCATION + 'HISTORY.md'
-    history_vers = IO.read(history_file).match(/^## (\d+\.\d+\.\d+) \(/)
+    history_file = WF_SDK_LOCATION.join('HISTORY.md')
+    history_vers = File.read(history_file).match(/^## (\d+\.\d+\.\d+) \(/)
     assert_equal(WF_SDK_VERSION, history_vers.captures.first)
   end
 end

data/spec/wavefront-sdk/savedsearch_spec.rb

@@ -54,8 +54,8 @@ class WavefrontSavedSearchTest < WavefrontTestBase
 
   def payload
     { query: {
-      foo: '{"searchTerms":[{"type":"freetext","value":"foo"}]}'
-    },
+        foo: '{"searchTerms":[{"type":"freetext","value":"foo"}]}'
+      },
       entityType: 'DASHBOARD' }
   end
 end

data/spec/wavefront-sdk/spy_spec.rb

@@ -38,6 +38,33 @@ class WavefrontSpyTest < MiniTest::Test
     end
   end
 
+  def test_deltas
+    capture_io do
+      assert_gets('/api/spy/deltas?sampling=0.01') { wf.deltas }
+      assert_gets('/api/spy/deltas?sampling=0.05') { wf.deltas(0.05) }
+
+      assert_gets('/api/spy/deltas?sampling=0.05&counter=my_prefix') do
+        wf.deltas(0.05, prefix: 'my_prefix')
+      end
+
+      assert_gets(
+        '/api/spy/deltas?sampling=0.05&counter=my_prefix&host=h1'
+      ) do
+        wf.deltas(0.05, prefix: 'my_prefix', host: 'h1')
+      end
+
+      assert_gets('/api/spy/deltas?sampling=0.02&counter=my_prefix&' \
+                  'counterTagKey=the_tag') do
+        wf.deltas(0.02, prefix: 'my_prefix', tag_key: 'the_tag')
+      end
+
+      assert_gets('/api/spy/deltas?sampling=0.02&counter=my_prefix&' \
+                  'counterTagKey=tag1&counterTagKey=tag2') do
+        wf.deltas(0.02, prefix: 'my_prefix', tag_key: %w[tag1 tag2])
+      end
+    end
+  end
+
   def test_histograms
     capture_io do
       assert_gets('/api/spy/histograms?sampling=0.01') { wf.histograms }

data/spec/wavefront-sdk/user_spec.rb

@@ -127,10 +127,10 @@ class WavefrontUserTest < WavefrontTestBase
   end
 
   def test_response_shim
-    (RESOURCE_DIR + 'user_responses').each_child do |input|
+    RESOURCE_DIR.join('user_responses').each_child do |input|
       # Ugly hack for the 202 in the 'create' file
       status = input.basename.to_s == 'create.json' ? 202 : 200
-      shimmed = wf.response_shim(IO.read(input), status)
+      shimmed = wf.response_shim(File.read(input), status)
       assert_instance_of(String, shimmed)
 
       ret_obj = JSON.parse(shimmed, symbolize_names: true)

data/spec/wavefront-sdk/validators_spec.rb

@@ -417,4 +417,14 @@ class WavefrontValidatorsTest < MiniTest::Test
     bad = %w[h5Z9dkr46jbvLtJ HqOM4mru5svd3uFp3 c!lBx!LC*NxLKdx*]
     good_and_bad('wf_aws_external_id?', 'InvalidAwsExternalId', good, bad)
   end
+
+  def test_wf_metricspolicy_id
+    good = %w[2bfdcac7-1c9c-4c4b-9b56-c41c22c586dc
+              a7d2e651-cec1-4154-a5e8-1946f57ef5b3
+              fca312fb-5ff4-420d-862d-5d6d99ed6bcf
+              3a1957e0-459e-49e5-9209-3888a4e8ac5b]
+
+    bad = %w[fa312fb-5ff4-420d-862d-5d6d99ed6bcf thing 123]
+    good_and_bad('wf_metricspolicy_id?', 'InvalidMetricsPolicyId', good, bad)
+  end
 end

data/spec/wavefront-sdk/write_spec.rb

@@ -27,7 +27,7 @@ class WavefrontWriteTest < MiniTest::Test
     refute(wf.opts[:noop])
     assert(wf_noop.opts[:noop])
     assert_equal(wf_tags.opts[:tags], TAGS)
-    assert_instance_of(Wavefront::Writer::Socket, wf.writer)
+    assert_instance_of(Wavefront::Writer::Proxy, wf.writer)
   end
 
   def test_composite_response

data/spec/wavefront-sdk/writers/{unix_spec.rb → proxy_spec.rb}

@@ -11,36 +11,34 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/write'
 require_relative '../../../spec/support/mocket'
 
-UNIX_SOCK = '/tmp/testsock'
+WS_CREDS = { proxy: 'wavefront-proxy' }.freeze
 
-WU_CREDS = { socket: UNIX_SOCK }.freeze
-
-# Test UNIX Datagram socket writing
+# The Proxy class writes to a proxy TCP socket
 #
-class WavefrontWriterUnixTest < MiniTest::Test
+class WavefrontWriterSocketTest < MiniTest::Test
   attr_reader :wf, :wf_noop
 
   def setup
-    @wf = Wavefront::Write.new(WU_CREDS, writer: :unix)
-    @wf_noop = Wavefront::Write.new(WU_CREDS, writer: :unix, noop: true)
+    @wf = Wavefront::Write.new(WS_CREDS, writer: :proxy)
+    @wf_noop = Wavefront::Write.new(WS_CREDS, writer: :proxy, noop: true)
   end
 
   def test_writer_class
-    assert_instance_of(Wavefront::Writer::Unix, wf.writer)
+    assert_instance_of(Wavefront::Writer::Proxy, wf.writer)
   end
 
   def test_write_openclose
     mocket = Mocket.new
-    Spy.on(UNIXSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :write)
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
     wf.write(POINT)
     assert mocket_spy.has_been_called?
   end
 
   def test_write_noop
     mocket = Mocket.new
-    Spy.on(UNIXSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :write)
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
     wf_noop.open
     wf_noop.write(POINT, false)
     refute mocket_spy.has_been_called?
@@ -48,16 +46,16 @@ class WavefrontWriterUnixTest < MiniTest::Test
 
   def test_write_noop_openclose
     mocket = Mocket.new
-    Spy.on(UNIXSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :write)
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
     wf_noop.write(POINT)
     refute mocket_spy.has_been_called?
   end
 
   def test_write
     mocket = Mocket.new
-    Spy.on(UNIXSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :write)
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
     wf.open
     wf.write(POINT, false)
     assert mocket_spy.has_been_called?
@@ -65,8 +63,8 @@ class WavefrontWriterUnixTest < MiniTest::Test
 
   def test_write_array
     mocket = Mocket.new
-    Spy.on(UNIXSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :write)
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
     wf.open
     wf.write(POINT_A, false)
     assert mocket_spy.has_been_called?
@@ -74,32 +72,32 @@ class WavefrontWriterUnixTest < MiniTest::Test
 
   def test_noop_send_point
     mocket = Mocket.new
-    Spy.on(UNIXSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :write)
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
     wf_noop.open
     wf_noop.send_point(POINT_L)
     refute mocket_spy.has_been_called?
   end
 
   def test_open
-    tcp_spy = Spy.on(UNIXSocket, :new)
+    tcp_spy = Spy.on(TCPSocket, :new)
     wf.open
     assert tcp_spy.has_been_called?
-    assert_equal([UNIX_SOCK], tcp_spy.calls.first.args)
+    assert_equal(['wavefront-proxy', 2878], tcp_spy.calls.first.args)
   end
 
   def test_noop_open
-    tcp_spy = Spy.on(UNIXSocket, :new)
+    tcp_spy = Spy.on(TCPSocket, :new)
     log_spy = Spy.on(wf_noop.logger, :log)
     wf_noop.open
     refute tcp_spy.has_been_called?
-    assert_equal(['No-op requested. Not opening socket connection.'],
+    assert_equal(['No-op requested. Not opening connection to proxy.'],
                  log_spy.calls.last.args)
     assert_equal(1, log_spy.calls.size)
   end
 
   def test_noop_close
-    tcp_spy = Spy.on(UNIXSocket, :new)
+    tcp_spy = Spy.on(TCPSocket, :new)
     log_spy = Spy.on(wf_noop.logger, :log)
     wf_noop.close
     refute tcp_spy.has_been_called?
@@ -107,25 +105,25 @@ class WavefrontWriterUnixTest < MiniTest::Test
   end
 
   def test_validate_credentials
-    assert(Wavefront::Write.new(WU_CREDS, writer: :unix))
+    assert(Wavefront::Write.new(WS_CREDS, writer: :proxy))
 
     assert_instance_of(Wavefront::Write,
-                       Wavefront::Write.new(WU_CREDS, writer: :unix))
+                       Wavefront::Write.new(WS_CREDS, writer: :proxy))
 
     assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({}, writer: :unix)
+      Wavefront::Write.new({}, writer: :proxy)
     end
 
     assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({ endpoint: 'wavefront.com' }, writer: :unix)
+      Wavefront::Write.new({ endpoint: 'wavefront.com' }, writer: :proxy)
     end
 
     assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({ token: 'abcdef' }, writer: :unix)
+      Wavefront::Write.new({ token: 'abcdef' }, writer: :proxy)
     end
 
     assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({ proxy: nil }, writer: :unix)
+      Wavefront::Write.new({ proxy: nil }, writer: :proxy)
     end
   end
 end