wavefront-sdk 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a02cb5dea9d85e5aedad5b0e90797ffd903e040599791e52797c65cf76915c23
-  data.tar.gz: 14e6c880b1c010955bf11bb878835d957d7c751c63ba6b64214181dbb17ab39d
+  metadata.gz: ae4a49d72cb51beb4506cf0ea7049cc992e59d7699c37e7e59be1312c7b8d3b0
+  data.tar.gz: 8f0c3227f635bf86bdb1eca4e0091d9fb31abf0a99ada3cfcacd57e20a90655c
 SHA512:
-  metadata.gz: 7fcc872018be55b82240eb3df41eab15c4439894bd657e50d7d11d4be7f8a9b3d663aca4a0007921b269b78c1b1a64cf842bb9a4ef07268012c861cb4a5b1949
-  data.tar.gz: 0ad071bda2318a32541b7d97dc98314c8e47efe0100ba7d1eed868519c66bc3b07b228ee80a5888b9bd29d9dc33debb11367171afd5a5dbead6768789b6905fd
+  metadata.gz: dd4638fdafec9d0bc5afc327451f81a5d1dd8ef36409f4249e868e948ceb836528bed3bfa369f568dc0b959817a44c83aa5340eee20145d4347ac0a61a1d7904
+  data.tar.gz: c1b87ee6385563a046e6d76c9e914ff5f4b635c4cdcf9179f84f44c1db6f87967028df4fdfb40ba25a0dca745f83a1bd43c229e91ae6893e170eba7c66b34dbc

data/HISTORY.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 2.4.0 (28/01/2019)
+* New `Wavefront::MetricHelper` class creates and in-memory buffer
+  to which you can instantaneously add metrics, flushing it to
+  Wavefront when appropriate. All `Writer` types are supported.
+* Add `noauto` option to `Write` class. This lets you manage the
+  connection yourself without having to pass `false` as the second
+  argument to every single `Write#write` call. (Though this still
+  works.)
+* Improve error handling when proxy socket is not available.
+* Raise an exception if an interval is not given when writing a
+  histogram.
+* Improve `README` instructions on writing metrics.
+* Support Ruby 2.6.
+
 ## 2.3.0 (06/01/2019)
 * When sending points via the API, send bundles of up to 100 points
   with each `POST`, rather than a call per point.

data/README.md

@@ -47,6 +47,7 @@ object. Map objects can be interrogated in various ways. For
 instance `map['items']`, `map[:items]` and `map.items` will all get
 you to the same place.
 
+### Standard API Calls
 
 ```ruby
 # Define our API endpoint. (This is not a valid token!)
@@ -120,6 +121,32 @@ last 10 minutes, with one minute bucket granularity. We will
 describe the time as a Ruby object, but could also use an epoch
 timestamp. The SDK happily converts between the two.
 
+### Credentials
+
+The SDK provides a helper class for extracting credentials from a
+configuration file. If you don't supply a file, defaults will be
+used. You can even override things with environment variables.
+
+```ruby
+require 'wavefront-sdk/credentials'
+
+c = Wavefront::Credentials.new
+
+# Now use that to list the alerts in our account
+
+require 'wavefront-sdk/alert'
+
+p Wavefront::Alert.new(c.creds).list
+
+# To get proxy configuration, use the `proxy` method. This is
+# required by the Write class. You can also use c.all, which
+# includes proxy and API configuration.
+
+wf = Wavefront::Write.new(c.proxy)
+wf = Wavefront::Write.new(c.all)
+```
+
+### Queries
 
 ```ruby
 require 'wavefront-sdk/query'
@@ -131,68 +158,194 @@ Wavefront::Query.new(CREDS).query(
 )
 ```
 
-We can write points too. The `Write` class lets you send points to a
-proxy, and the `Report` class sends them directly via the API.
-Unlike all other classes, `Write` requires the proxy address and
-port as its credential hash. `Report` has the same methods and works
-in the same way, but uses the same credentials as all the other
-classes.
+### Sending Metrics
+
+The `Wavefront::Write` and `Wavefront::Distribution` classes lets
+you send points to Wavefront in a number of ways.
+
+#### Sending Points
+
+Use `Wavefront::Write` to send points. Points are described as an
+array of hashes. For example:
+
+```ruby
+wf = Wavefront::Write.new(Wavefront::Credentials.new.proxy)
+wf.write([{ path: 'dev.test.sdk', value: 10 }])
+```
+
+The point hash also accepts optional `source`, `ts`, and `tag` keys.
+`tag` is a hash describing point tags. For example.
+
+```ruby
+wf.write({ path:   'dev.test.sdk',
+           value:  10,
+           ts:     Time.now,
+           source: 'example',
+           tags:   { language: 'ruby',
+                     level: 'beginner'})
+```
+
+As the example shows, if you are sending a single point, you can
+send a naked hash, omitting the array syntax.
+
+By default, `Wavefront::Write#write` will open a connection to
+Wavefront on each call, closing it after use.
+
+If you prefer to manage the connection yourself, supply `noauto:
+true` in the options hash when instantiating the `Write` class.
 
 ```ruby
-require 'wavefront-sdk/write'
+wf = Wavefront::Write.new(Wavefront::Credentials.new.proxy, noauto: true)
+wf.open
+wf.write(path: 'dev.test.sdk', value: 10)
+wf.close
+```
 
-W_CREDS = { proxy: 'wavefront.localnet', port: 2878 }
+Alternatively, pass `false` as the second argument to `Write#write`.
+(This is the legacy method, kept in for backward compatability.)
+
+```ruby
+wf = Wavefront::Write.new(Wavefront::Credentials.new.proxy)
+wf.open
+wf.write([{ path: 'dev.test.sdk', value: 10 }], false)
+wf.close
+```
+
+By default, `Write#write` speaks to a TCP socket on a nearby proxy,
+but other methods are supported via the `writer` option.
+
+```ruby
+# To send points via the API
+wf = Wavefront::Write.new(Wavefront::Credentials.new.creds, writer: :api)
 
-wf = Wavefront::Write.new(W_CREDS, verbose:true)
+# To send points via a local Unix socket
+wf = Wavefront::Write.new(socket: '/tmp/wf_sock', { writer: :unix })
 
-task = wf.write( [{ path: 'dev.test.sdk', value: 10 }])
-# SDK DEBUG: Connecting to wavefront.localnet:2878.
-# SDK INFO: dev.test.sdk 10 source=box
+# To send points over HTTP
+wf = Wavefront::Write.new(Wavefront::Credentials.new.creds, writer: :http)
+
+# Then call wf.write as before.
+```
+
+`Write` can output verbose and debug info, and the response object
+provides a `summary` object.
+
+```ruby
+wf = Wavefront::Write.new(Wavefront::Credentials.new.proxy, verbose: true)
+wf.write([{ path: 'dev.test.sdk', value: 11, tags: { tag1: 'mytag'} }])
+# SDK INFO: dev.test.sdk 11 source=box tag1="mytag"
+
+wf = Wavefront::Write.new(Wavefront::Credentials.new.proxy, debug: true)
+wf.write([{ path: 'dev.test.sdk', value: 11, tags: { tag1: 'mytag'} }])
+# SDK DEBUG: Connecting to wavefront:2878.
+# SDK INFO: dev.test.sdk 11 source=box tag1="mytag"
 # SDK DEBUG: Closing connection to proxy.
-puts task.response
-# {"sent"=>1, "rejected"=>0, "unsent"=>0}
+
+task = wf.write([{ path: 'dev.test.sdk_1', value: 1 },
+                 { path: 'dev.test.sdk_2', value: 2 }])
+p task.response
+# {"sent"=>2, "rejected"=>0, "unsent"=>0}
 puts task.ok?
 # true
 ```
 
-You can send delta metrics either by manually prefixing your metric
-path with a delta symbol, or by using the `write_delta()` method.
-There is even a class to help you write Wavefront distributions.
+You can send delta metrics my prefixing your `path` with a delta
+symbol, or by using the `Write#write_delta()` method. This is called in
+exactly the same way as `Write#write`, and supports all the same
+options.
+
+#### Sending Distributions
 
-You can also send points to a local proxy over HTTP. Just specify
-`:http` as the `writer` option when you create your write object.
+Use the `Wavefront::Distribution` class to send distributions via a
+proxy. This is an extension of `Wavefront::Write`, so usage is
+almost the same. All you have to do differently is specify an
+interval size (`m`, `h`, or `d`), and use a distribution as your
+`value`. We give you methods to help with this.  For instance:
 
 ```ruby
-wf = Wavefront::Write.new(W_CREDS, writer: :http, verbose: true)
+wf = Wavefront::Distribution.new(CREDS.proxy)
 
-task = wf.write( [{ path: 'dev.test.sdk', value: 10 }])
-# SDK INFO: dev.test.sdk 10 source=box
-# SDK INFO: uri: POST http://wavefront.localnet:2878/
-# SDK INFO: body: dev.test.sdk 10 source=box
-p task.response
+dist = wf.mk_distribution([7, 7, 7, 8, 8, 9, 10, 10])
+
+p dist
+
+# [[3, 7.0], [2, 8.0], [1, 9.0], [2, 10.0]]
+
+p wf.write({ path: 'dev.test.dist', value: dist, interval: :m }).response
 # {"sent"=>1, "rejected"=>0, "unsent"=>0}
-puts task.ok?
-# true
 ```
 
-The SDK provides a helper class for extracting credentials from a
-configuration file. If you don't supply a file, defaults will be
-used. You can even override things with environment variables.
+#### Metric Helpers
+
+The `Wavefront::MetricHelper` class gives you simple ways to write
+metrics to in-memory buffers, and flush those buffer whenever you see
+fit. It aims to be a little bit like Dropwizard.
+
+`MetricHelper` gives you less control over the metrics you send. For
+instance, the source and timestamp are automatically sent. You can
+view the buffer at any time with the `buf` `attr_accessor`.
 
 ```ruby
-require 'wavefront-sdk/credentials'
+require 'wavefront-sdk/metric_helper'
 
-c = Wavefront::Credentials.new
+wf = Wavefront::MetricHelper.new(CREDS.proxy, verbose: true)
 
-# Now use that to list the proxies in our account
+wf.gauge('my.gauge', 1)
+wf.gauge('my.gauge', 2, { tag1: 'val1' })
+wf.gauge('my.gauge', 3, { tag1: 'val2' })
+wf.counter('my.counter')
+wf.counter('my.counter', 1, { tag1: 'val1' } )
+wf.counter('my.counter')
 
-require 'wavefront-sdk/proxy'
+pp wf.buf
 
-p Wavefront::Proxy.new(c.creds).list
+# {:gauges=>
+#   [{:path=>"my.gauge", :ts=>1548633249, :value=>1},
+#    {:path=>"my.gauge", :ts=>1548633249, :value=>2, :tags=>{:tag1=>"val1"}},
+#    {:path=>"my.gauge", :ts=>1548633249, :value=>3, :tags=>{:tag1=>"val2"}}],
+#  :counters=>{["my.counter", nil]=>2, ["my.counter", {:tag1=>"val1"}]=>1}}
 
-# It works for proxies too:
+wf.flush
 
-wf = Wavefront::Write.new(c.proxy)
+# SDK INFO: my.gauge 1 1548633515 source=box
+# SDK INFO: my.gauge 2 1548633515 source=box tag1="val1"
+# SDK INFO: my.gauge 3 1548633515 source=box tag1="val2"
+# SDK INFO: ∆my.counter 2 1548633515 source=box
+# SDK INFO: ∆my.counter 1 1548633515 source=box tag1="val1"
+
+pp wf.buf
+
+# {:gauges=>[], :counters=>[]}
+```
+
+Note that gauges are sent individually, timestamped at the time they
+are created. All counters are aggregated as you go along, and when
+flushed, they send their value at that moment as a *single delta
+metric*, the timestamp being the time of the flush.
+
+You can also work with distributions. To do this, you must add
+`dist_port` to your options hash, giving the number of the proxy
+port listening for Wavefront format distributions. Numbers can be added
+to distributions individually, or in an array. You must specify the
+distribution interval.
+
+```ruby
+wf = Wavefront::MetricHelper.new(CREDS.proxy, { verbose: true, dist_port: 40000 })
+
+wf.dist('my.dist', :m, 10)
+wf.dist('my.dist', :m, 10)
+wf.dist('my.dist', :m, [8, 8, 8, 9, 10, 10])
+wf.dist('my.dist', :m, 8)
+
+pp wf.buf
+
+# {:gauges=>[],
+#  :counters=>{},
+#  :dists=>{["my.dist", :m, nil]=>[10, 10, 8, 8, 8, 9, 10, 10, 8]}}
+
+wf.flush
+
+# SDK INFO: !M 1548634226 #4 10.0 #4 8.0 #1 9.0 my.dist source=box
 ```
 
 ## Contributing

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

@@ -43,6 +43,7 @@ module Wavefront
     class InvalidVersion < RuntimeError; end
     class InvalidWebhookId < RuntimeError; end
     class NotImplemented < RuntimeError; end
+    class SocketError < RuntimeError; end
     class UnparseableResponse < RuntimeError; end
     class UnsupportedWriter < RuntimeError; end
     class ValueOutOfRange < RuntimeError; end

data/lib/wavefront-sdk/defs/version.rb

@@ -1 +1 @@
-WF_SDK_VERSION = '2.3.0'.freeze
+WF_SDK_VERSION = '2.4.0'.freeze

data/lib/wavefront-sdk/distribution.rb

@@ -51,8 +51,10 @@ module Wavefront
     # rubocop:disable Metrics/AbcSize
     def hash_to_wf(dist)
       logger.log("writer subclass #{writer}", :debug)
+      raise unless dist.key?(:interval)
+
       format('!%s %i %s %s source=%s %s %s',
-             dist[:interval].to_s.upcase || raise,
+             dist[:interval].to_s.upcase,
              parse_time(dist.fetch(:ts, Time.now)),
              array2dist(dist[:value]),
              dist[:path] || raise,

data/lib/wavefront-sdk/metric_helper.rb

@@ -0,0 +1,181 @@
+require_relative 'write'
+
+module Wavefront
+  #
+  # A helper class for quickly and efficiently sending metrics.
+  # This class creates an in-memory buffer to which you can write
+  # information using a number of methods. When the buffer is
+  # flushed, the points are send to Wavefront using any Writer
+  # class. You can currently write gauges, counters, and
+  # distributions. This list may grow in the future.
+  #
+  class MetricHelper
+    attr_reader :opts, :buf, :writer, :dist_writer
+
+    # See Wavefront::Write#initialize for parameters. Additionally,
+    #   dist_port: proxy port to write distributions to. If this is
+    #              unset, distributions will not be handled.
+    #
+    def initialize(creds, opts = {})
+      @opts        = opts
+      @buf         = { gauges:   empty_gauges,
+                       counters: empty_counters }
+      @writer      = setup_writer(creds, opts)
+      @dist_writer = setup_dist_writer(creds, opts) if opts[:dist_port]
+    end
+
+    # Writes a simple path/metric point, with optional tags,
+    # to the buffer. The timestamp is automatically set to the
+    # current epoch second. For more control, use
+    # Wavefront::Write#write
+    # @param path [String] metric path
+    # @param value [Numeric] metric value
+    # @param tags [Hash] hash of point tags
+    #
+    def gauge(path, value, tags = nil)
+      gauge = { path: path, ts: Time.now.to_i, value: value }
+      gauge[:tags] = tags if tags
+      @buf[:gauges].<< gauge
+    end
+
+    # These counters are internal, and specific to the SDK. When
+    # the buffer is flushed, a single value is sent to Wavefront
+    # for each counter. The value sent is a Wavefront delta metric.
+    #
+    # @param path [String] metric path
+    # @param value [Numeric] value to add to counter
+    # @param tags [Hash] point tags
+    #
+    def counter(path, value = 1, tags = nil)
+      key = [path, tags]
+      @buf[:counters][key] += value
+    end
+
+    # These distributions are stored in memory, and sent to
+    # Wavefront as native distibutions when the buffer is flushed.
+    # @param path [String] metric path
+    # @param value [Array, Numeric] value(s) to add to distribution
+    # @param interval [Symbol, String] distribution interval, :m,
+    #   :h, or :d
+    # @param tags [Hash] point tags
+    #
+    def dist(path, interval, value, tags = nil)
+      key = [path, interval, tags]
+      @buf[:dists][key] += [value].flatten
+    end
+
+    # Flush all stored metrics. Though you can flush by individual
+    # type, this is the preferred method
+    #
+    def flush
+      flush_gauges(buf[:gauges])
+      flush_counters(buf[:counters])
+      flush_dists(buf[:dists]) if opts.key?(:dist_port)
+    end
+
+    # When we are asked to flush the buffers, duplicate the current
+    # one, hand it off to the writer class, and clear. If writer
+    # tells us there was an error, dump the old buffer into the
+    # the new one for the next flush.
+    #
+    def flush_gauges(gauges)
+      return if gauges.empty?
+
+      to_flush = gauges.dup
+      @buf[:gauges] = empty_gauges
+
+      writer.write(gauges_to_wf(gauges)).tap do |resp|
+        @buf[:gauges] += to_flush unless resp.ok?
+      end
+    end
+
+    def flush_counters(counters)
+      return if counters.empty?
+
+      to_flush = counters.dup
+      @buf[:counters] = empty_counters
+
+      writer.write_delta(counters_to_wf(counters)).tap do |resp|
+        replay_counters(to_flush) unless resp.ok?
+      end
+    end
+
+    def flush_dists(dists)
+      return if dists.empty?
+
+      to_flush = dists.dup
+      @buf[:dists] = empty_dists
+
+      dist_writer.write(dists_to_wf(dists)).tap do |resp|
+        replay_dists(to_flush) unless resp.ok?
+      end
+    end
+
+    # Play a failed flush full of counters back into the system
+    #
+    def replay_counters(buffer)
+      buffer.each { |k, v| counter(k[0], v, k[1]) }
+    end
+
+    def replay_dists(buffer)
+      buffer.each { |k, v| dist(k[0], k[1], v, k[2]) }
+    end
+
+    # These are already Wavefront-format points
+    #
+    def gauges_to_wf(gauges)
+      gauges
+    end
+
+    def counters_to_wf(counters)
+      counters.map do |k, v|
+        path, tags = k
+        metric = { path: path, value: v, ts: Time.now.utc.to_i }
+        metric[:tags] = tags unless tags.nil?
+        metric
+      end
+    end
+
+    def dists_to_wf(dists)
+      dists.map do |k, v|
+        path, interval, tags = k
+        dist = { path:     path,
+                 value:    dist_writer.mk_distribution(v),
+                 ts:       Time.now.utc.to_i,
+                 interval: interval }
+        dist[:tags] = tags unless tags.nil?
+        dist
+      end
+    end
+
+    # @return [Hash] options hash, with :port replaced by :dist_port
+    #
+    def dist_creds(creds, opts)
+      creds.dup.tap { |o| o[:port] = opts[:dist_port] }
+    end
+
+    private
+
+    def empty_gauges
+      []
+    end
+
+    def empty_counters
+      Hash.new(0)
+    end
+
+    def empty_dists
+      Hash.new([])
+    end
+
+    def setup_writer(creds, opts)
+      Wavefront::Write.new(creds, opts)
+    end
+
+    def setup_dist_writer(creds, opts)
+      require_relative 'distribution'
+      @buf[:dists] = empty_dists
+      Wavefront::Distribution.new(dist_creds(creds, opts), opts)
+    end
+  end
+end

data/lib/wavefront-sdk/write.rb

@@ -21,11 +21,10 @@ module Wavefront
     # writing points to Wavefront. The actual writing is handled by
     # a Wavefront::Writer:: subclass.
     #
-    # @param creds [Hash] credentials
-    #   signature.
-    # @param options [Hash] can contain the following keys:
+    # @param creds [Hash] credentials: can contain keys:
     #   proxy [String] the address of the Wavefront proxy. ('wavefront')
     #   port [Integer] the port of the Wavefront proxy
+    # @param options [Hash] can contain the following keys:
     #   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
@@ -38,12 +37,16 @@ module Wavefront
     #   debug [Bool]
     #   writer [Symbol, String] the name of the writer class to use.
     #     Defaults to :socket
+    #   noauto [Bool] if this is false, #write will automatically
+    #     open a connection to Wavefront on each invocation. Set
+    #     this to true to manually manage the connection.
     #
     def initialize(creds = {}, opts = {})
       defaults = { tags:       nil,
                    writer:     :socket,
                    noop:       false,
                    novalidate: false,
+                   noauto:     false,
                    verbose:    false,
                    debug:      false }
 
@@ -76,10 +79,20 @@ module Wavefront
     # appropriate class documentation for @return information etc.
     # The signature is always the same.
     #
-    def write(points = [], openclose = true, prefix = nil)
+    def write(points = [], openclose = manage_conn, prefix = nil)
       writer.write(points, openclose, prefix)
     end
 
+    # Wrapper around writer class's #flush method
+    #
+    def flush
+      writer.flush
+    end
+
+    def manage_conn
+      opts[:noauto] ? false : true
+    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
@@ -89,7 +102,7 @@ module Wavefront
     # @param points [Array[Hash]] see #write()
     # @param openclose [Bool] see #write()
     #
-    def write_delta(points, openclose = true)
+    def write_delta(points, openclose = manage_conn)
       write(paths_to_deltas(points), openclose)
     end
 
@@ -129,7 +142,7 @@ module Wavefront
     #   open a socket to the proxy before sending points, and
     #   afterwards, close it.
     #
-    def raw(points, openclose = true)
+    def raw(points, openclose = manage_conn)
       writer.open if openclose && writer.respond_to?(:open)
 
       begin

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

@@ -30,6 +30,7 @@ module Wavefront
         @creds         = calling_class.creds
         @opts          = calling_class.opts
         @logger        = calling_class.logger
+        @manage_conn   = calling_class.manage_conn
         @summary       = Wavefront::Writer::Summary.new
 
         validate_credentials(creds) if respond_to?(:validate_credentials)
@@ -47,11 +48,14 @@ module Wavefront
       # @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)
-
+      def write(points = [], openclose = manage_conn, prefix = nil)
         points = screen_points(points)
         points = prefix_points(points, prefix)
+        do_write(points, openclose, prefix)
+      end
+
+      def do_write(points, openclose, _prefix)
+        open if openclose && respond_to?(:open)
 
         begin
           write_loop(points)
@@ -78,7 +82,7 @@ module Wavefront
         true
       rescue StandardError => e
         summary.unsent += 1
-        logger.log('WARNING: failed to send point.')
+        logger.log('Failed to send point.', :warn)
         logger.log(e.to_s, :debug)
         false
       end

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

@@ -51,9 +51,12 @@ module Wavefront
 
       # @param point [String] point or points in native Wavefront
       # format.
+      # @raise [SocketError] if point cannot be written
       #
       def _send_point(point)
         conn.puts(point)
+      rescue StandardError
+        raise Wavefront::Exception::SocketError
       end
 
       # return [Integer] the port to connect to, if none is supplied

data/spec/spec_helper.rb

@@ -171,3 +171,23 @@ class Hash
     Marshal.load(Marshal.dump(self))
   end
 end
+
+# A mock socket
+#
+class Mocket
+  def puts(socket); end
+
+  def close; end
+
+  def ok?
+    true
+  end
+end
+
+# A mock socket which says things went wrong.
+#
+class BadMocket < Mocket
+  def ok?
+    false
+  end
+end

data/spec/wavefront-sdk/distribution_spec.rb

@@ -61,6 +61,13 @@ class WavefrontDistributionTest < MiniTest::Test
                  '!M 1538865613 #5 11 #15 2.533 #8 -15 #12 1000000.0 ' \
                  "test.distribution source=#{Socket.gethostname} " \
                  'tag1="val1" tag2="val2"')
+
+    bad_dist = DIST.dup
+    bad_dist.delete(:interval)
+
+    assert_raises(Wavefront::Exception::InvalidDistribution) do
+      wf.hash_to_wf(bad_dist)
+    end
   end
 
   def test_array2dist
@@ -68,11 +75,3 @@ class WavefrontDistributionTest < MiniTest::Test
     assert_equal(wf.array2dist([[12, 4.235]]), '#12 4.235')
   end
 end
-
-# A mock socket
-#
-class Mocket
-  def puts(socket); end
-
-  def close; end
-end

data/spec/wavefront-sdk/metric_helper_spec.rb

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'spy'
+require 'spy/integration'
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/metric_helper'
+
+ND_CREDS = { proxy: 'wavefront' }.freeze
+WH_TAGS  = { t1: 'v1', t2: 'v2' }.freeze
+
+# Tests for the MetricHelper class.
+#
+# rubocop:disable Style/NumericLiterals
+class WavefrontMetricHelperTest < MiniTest::Test
+  attr_reader :wf, :wfd
+
+  def setup
+    @wf  = Wavefront::MetricHelper.new(ND_CREDS, {})
+    @wfd = Wavefront::MetricHelper.new(ND_CREDS, dist_port: 40000)
+  end
+
+  def test_gauge_1
+    wf.gauge('test.gauge', 123)
+    b = wf.buf
+    refute_empty(b[:gauges])
+    assert_empty(b[:counters])
+    assert_instance_of(Array, b[:gauges])
+    assert_equal(1, b[:gauges].size)
+    assert_equal(123, b[:gauges][0][:value])
+  end
+
+  def test_gauge_tags
+    wf.gauge('test.gauge', 9.5, WH_TAGS)
+    b = wf.buf
+    refute_empty(b[:gauges])
+    assert_empty(b[:counters])
+    assert_instance_of(Array, b[:gauges])
+    assert_equal(1, b[:gauges].size)
+    assert_equal(9.5, b[:gauges][0][:value])
+    assert_equal(WH_TAGS, b[:gauges][0][:tags])
+  end
+
+  def test_counter
+    wf.counter('test.counter')
+    wf.counter('test.counter')
+    wf.counter('test.counter', 2)
+    b = wf.buf
+    assert_empty(b[:gauges])
+    refute_empty(b[:counters])
+    assert_instance_of(Hash, b[:counters])
+    assert_equal(4, b[:counters][['test.counter', nil]])
+  end
+
+  def test_counter_tags
+    wf.counter('test.counter')
+    wf.counter('test.counter', 1, WH_TAGS)
+    wf.counter('test.counter', 2)
+    wf.counter('test.counter', 3, WH_TAGS)
+    b = wf.buf
+    assert_empty(b[:gauges])
+    refute_empty(b[:counters])
+    assert_instance_of(Hash, b[:counters])
+    assert_equal(3, b[:counters][['test.counter', nil]])
+    assert_equal(4, b[:counters][['test.counter', WH_TAGS]])
+  end
+
+  def test_dist_nodist
+    refute wf.buf.key?(:dists)
+  end
+
+  def test_dist
+    wfd.dist('test.dist', :m, 10)
+    wfd.dist('test.dist', :h, 456)
+    wfd.dist('test.dist', :h, 123, WH_TAGS)
+    wfd.dist('test.dist', :m, [10, 12, 13, 14])
+    b = wfd.buf
+    assert_empty(b[:gauges])
+    assert_empty(b[:counters])
+    refute_empty(b[:dists])
+    assert_equal(3, b[:dists].size)
+    assert_equal([10, 10, 12, 13, 14], b[:dists][['test.dist', :m, nil]])
+    assert_equal([456], b[:dists][['test.dist', :h, nil]])
+    assert_equal([123], b[:dists][['test.dist', :h, WH_TAGS]])
+  end
+
+  def test_gauges_to_wf
+    input = [{ path: 'm1.p', ts: 1548636080, value: 0 },
+             { path: 'm1.p', ts: 1548636081, value: 1 },
+             { path: 'm2.p', ts: 1548636081, value: 9 }]
+
+    assert_equal(input, wf.gauges_to_wf(input))
+  end
+
+  def test_counters_to_wf
+    input = { ['test.counter1', nil]     => 7,
+              ['test.counter1', WH_TAGS] => 8,
+              ['test.counter2', nil]     => 9 }
+
+    out = wf.counters_to_wf(input)
+    assert_instance_of(Array, out)
+    assert_equal(3, out.size)
+    out.each { |o| assert_instance_of(Hash, o) }
+    assert_equal('test.counter1', out.first[:path])
+    assert_equal(9, out.last[:value])
+    refute(out.first[:tags])
+    assert_equal(WH_TAGS, out[1][:tags])
+    assert_kind_of(Numeric, out[2][:ts])
+  end
+
+  def test_dists_to_wf
+    input = { ['test.dist1', :m, nil] => [10, 10, 11, 12],
+              ['test.dist1', :m, WH_TAGS] => [123, 456, 789],
+              ['test.dist1', :h, nil]     => [6, 6, 7, 4, 6, 4, 8] }
+
+    out = wfd.dists_to_wf(input)
+    assert_instance_of(Array, out)
+    assert_equal(3, out.size)
+    assert_equal(1, out.select do |o|
+                      o[:value] == [[2, 10.0], [1, 11.0],
+                                    [1, 12.0]]
+                    end .size)
+    assert_equal(1, out.select { |o| o[:tags] == WH_TAGS }.size)
+    assert_equal(3, out.select { |o| o[:path] == 'test.dist1' }.size)
+  end
+
+  def test_flush_gauges
+    assert_nil(wf.flush_gauges([]))
+
+    input = [{ path: 'm1.p', ts: 1548636080, value: 0 },
+             { path: 'm1.p', ts: 1548636081, value: 1, tags: WH_TAGS },
+             { path: 'm2.p', ts: 1548636081, value: 9 }]
+
+    mocket = Mocket.new
+    spy = Spy.on(wf.writer.writer, :write).and_return(mocket)
+
+    out = wf.flush_gauges(input)
+    args = spy.calls.first.args.first
+    assert_instance_of(Mocket, out)
+    assert spy.has_been_called?
+    assert_equal(input, args)
+    assert(args.any? { |a| a.key?(:tags) && a[:tags] == WH_TAGS })
+    refute(args.all? { |a| a.key?(:tags) })
+    assert_empty(wf.buf[:gauges])
+  end
+
+  def test_flush_gauges_fail
+    input = [{ path: 'm1.p', ts: 1548636080, value: 0 }]
+
+    mocket = BadMocket.new
+    spy = Spy.on(wf.writer.writer, :write).and_return(mocket)
+    out = wf.flush_gauges(input)
+    assert_instance_of(BadMocket, out)
+    wf.gauge('m2.p', 9)
+    wf.gauge('m3.p', 9)
+    assert spy.has_been_called?
+    assert_equal(input, spy.calls.first.args.first)
+    assert_equal(3, wf.buf[:gauges].size)
+    assert_includes(wf.buf[:gauges],
+                    path: 'm1.p', ts: 1548636080, value: 0)
+  end
+
+  def test_flush_counters
+    assert_nil(wf.flush_counters([]))
+
+    input = { ['test.counter1', nil]     => 7,
+              ['test.counter1', WH_TAGS] => 8,
+              ['test.counter2', nil]     => 9 }
+
+    mocket = Mocket.new
+    spy = Spy.on(wf.writer.writer, :write).and_return(mocket)
+
+    out = wf.flush_counters(input)
+    args = spy.calls.first.args.first
+
+    assert_instance_of(Mocket, out)
+    assert spy.has_been_called?
+    assert_equal(3, args.size)
+
+    args.each do |a|
+      assert_instance_of(Hash, a)
+      assert_includes(a.keys, :path)
+      assert_includes(a.keys, :ts)
+      assert_includes(a.keys, :value)
+      assert(a[:path].start_with?(DELTA))
+    end
+
+    assert(args.any? { |a| a.key?(:tags) && a[:tags] == WH_TAGS })
+    refute(args.all? { |a| a.key?(:tags) })
+    assert_empty(wf.buf[:counters])
+  end
+
+  def test_flush_counters_fail
+    input = { ['test.counter1', nil]     => 7,
+              ['test.counter1', WH_TAGS] => 8,
+              ['test.counter2', nil]     => 9 }
+
+    mocket = BadMocket.new
+    spy = Spy.on(wf.writer.writer, :write).and_return(mocket)
+
+    out = wf.flush_counters(input)
+    args = spy.calls.first.args.first
+
+    assert_instance_of(BadMocket, out)
+    assert spy.has_been_called?
+    assert_equal(3, args.size)
+
+    wf.counter('test.counter1', 10)
+    wf.counter('test.counter1', 10)
+    wf.counter('test.counter2', 100)
+
+    assert(args.any? { |a| a.key?(:tags) && a[:tags] == WH_TAGS })
+    refute(args.all? { |a| a.key?(:tags) })
+    buf = wf.buf[:counters]
+    refute_empty(buf)
+    assert_equal(3, buf.size)
+    assert_equal(8, buf[['test.counter1', WH_TAGS]])
+    assert_equal(27, buf[['test.counter1', nil]])
+    assert_equal(109, buf[['test.counter2', nil]])
+  end
+
+  def test_flush_dists
+    assert_nil(wfd.flush_dists([]))
+
+    input = { ['test.dist1', :m, nil] => [10, 10, 11, 12],
+              ['test.dist1', :m, WH_TAGS] => [123, 456, 789],
+              ['test.dist1', :h, nil]     => [6, 6, 7, 4, 6, 4, 8] }
+
+    mocket = Mocket.new
+    spy = Spy.on(wfd.dist_writer.writer, :write).and_return(mocket)
+
+    out = wfd.flush_dists(input)
+    args = spy.calls.first.args.first
+
+    assert_instance_of(Mocket, out)
+    assert spy.has_been_called?
+    assert_equal(3, args.size)
+
+    args.each do |a|
+      assert_instance_of(Hash, a)
+      assert_includes(a.keys, :path)
+      assert_includes(a.keys, :ts)
+      assert_includes(a.keys, :value)
+      assert_instance_of(Array, a[:value])
+      assert_kind_of(Numeric, a[:ts])
+    end
+
+    assert(args.any? { |a| a.key?(:tags) && a[:tags] == WH_TAGS })
+    refute(args.all? { |a| a.key?(:tags) })
+    assert_empty(wfd.buf[:dists])
+  end
+
+  def test_flush_dists_fail
+    input = { ['test.dist1', :m, nil] => [10, 10, 11, 12],
+              ['test.dist1', :m, WH_TAGS] => [123, 456, 789],
+              ['test.dist1', :h, nil]     => [6, 6, 7, 4, 6, 4, 8] }
+
+    mocket = BadMocket.new
+    spy = Spy.on(wfd.dist_writer.writer, :write).and_return(mocket)
+
+    out = wfd.flush_dists(input)
+    args = spy.calls.first.args.first
+
+    assert_instance_of(BadMocket, out)
+    assert spy.has_been_called?
+    assert_equal(3, args.size)
+    refute_empty(wfd.buf[:dists])
+    assert_equal(input, wfd.buf[:dists])
+  end
+
+  def test_dist_creds
+    opts = { verbose: true, dist_port: 40000 }
+    o = wfd.dist_creds(ND_CREDS, opts)
+    assert_equal(40000, o[:port])
+    assert_equal({ verbose: true, dist_port: 40000 }, opts)
+    assert_equal('wavefront', o[:proxy])
+  end
+end
+# rubocop:enable Style/NumericLiterals

data/spec/wavefront-sdk/writers/core_spec.rb

@@ -21,6 +21,10 @@ class TestClassNoTags
   def logger
     Logger.new(STDOUT)
   end
+
+  def manage_conn
+    true
+  end
 end
 
 # Test methods common to 'write' and 'report'

data/spec/wavefront-sdk/writers/socket_spec.rb

@@ -94,11 +94,3 @@ class WavefrontWriterSocketTest < MiniTest::Test
     refute tcp_spy.has_been_called?
   end
 end
-
-# A mock socket
-#
-class Mocket
-  def puts(socket); end
-
-  def close; end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wavefront-sdk
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Robert Fisher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-07 00:00:00.000000000 Z
+date: 2019-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -212,6 +212,7 @@ files:
 - lib/wavefront-sdk/maintenancewindow.rb
 - lib/wavefront-sdk/message.rb
 - lib/wavefront-sdk/metric.rb
+- lib/wavefront-sdk/metric_helper.rb
 - lib/wavefront-sdk/notificant.rb
 - lib/wavefront-sdk/paginator/base.rb
 - lib/wavefront-sdk/paginator/delete.rb
@@ -258,6 +259,7 @@ files:
 - spec/wavefront-sdk/integration_spec.rb
 - spec/wavefront-sdk/maintenancewindow_spec.rb
 - spec/wavefront-sdk/message_spec.rb
+- spec/wavefront-sdk/metric_helper_spec.rb
 - spec/wavefront-sdk/metric_spec.rb
 - spec/wavefront-sdk/notificant_spec.rb
 - spec/wavefront-sdk/paginator/base_spec.rb
@@ -327,6 +329,7 @@ test_files:
 - spec/wavefront-sdk/integration_spec.rb
 - spec/wavefront-sdk/maintenancewindow_spec.rb
 - spec/wavefront-sdk/message_spec.rb
+- spec/wavefront-sdk/metric_helper_spec.rb
 - spec/wavefront-sdk/metric_spec.rb
 - spec/wavefront-sdk/notificant_spec.rb
 - spec/wavefront-sdk/paginator/base_spec.rb