wavefront-client 3.2.0 → 3.3.0

data/lib/wavefront/cli.rb

@@ -25,29 +25,35 @@ module Wavefront
       @options   = options
       @arguments = arguments
 
-      if @options[:help]
-        puts @options
+      if options.include?(:help) && options[:help]
+        puts options
         exit 0
       end
     end
 
     def load_profile
+      #
+      # 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.
+      #
+      return unless options[:config].is_a?(String)
       cf = Pathname.new(options[:config])
-      pf = options[:profile]
+      return unless cf.exist?
 
-      if cf.exist?
-        raw = IniFile.load(cf)
-        profile = raw[pf]
+      pf = options[:profile] || 'default'
+      raw = IniFile.load(cf)
+      profile = raw[pf]
 
-        unless profile.empty?
-          puts "using #{pf} profile from #{cf}" if options[:debug]
-          return profile.inject({}){|x, (k, v)| x[k.to_sym] = v; x }
-        end
+      puts "using #{pf} profile from #{cf}" if options[:debug]
 
-      else
-        puts "no config file at '#{cf}': using options" 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
       end
     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.2.0"
+    VERSION = "3.3.0"
   end
 end

data/lib/wavefront/constants.rb

@@ -30,5 +30,8 @@ module Wavefront
     GRANULARITIES = %w( s m h d )
     EVENT_STATE_DIR = Pathname.new('/var/tmp/wavefront/events')
     EVENT_LEVELS = %w(info smoke warn severe)
+    DEFAULT_PROXY = 'wavefront'
+    DEFAULT_PROXY_PORT = 2878
+    DEFAULT_INFILE_FORMAT = 'tmv'
   end
 end

data/lib/wavefront/events.rb

@@ -24,50 +24,71 @@ module Wavefront
     attr_reader :headers
 
     def initialize(token)
-      @headers = {
-        'X-AUTH-TOKEN': token,
-      }
+      @headers = { :'X-AUTH-TOKEN' => token }
     end
 
     def create(payload = {}, options = {})
+      make_call(create_uri(options), create_qs(payload))
+    end
+
+    def close(payload = {}, options = {})
+      make_call(close_uri(options), hash_to_qs(payload))
+    end
+
+    def create_uri(options = {})
+      #
+      # Build the URI we use to send a 'create' request.
+      #
       options[:host] ||= DEFAULT_HOST
       options[:path] ||= DEFAULT_PATH
 
-      uri = URI::HTTPS.build(
+      URI::HTTPS.build(
         host:  options[:host],
         path:  options[:path],
       )
+    end
 
+    def create_qs(payload = {})
+      #
       # It seems that posting the hash means the 'host' data is
       # lost. Making a query string works though, so let's do that.
       #
-      hosts = payload[:h]
+      if payload[:h].is_a?(Array)
+        hosts = payload[:h]
+      elsif payload[:h].is_a?(String)
+        hosts = [payload[:h]]
+      else
+        hosts = []
+      end
+
       payload.delete(:h)
-      query = mk_qs(payload)
+      query = hash_to_qs(payload)
       hosts.each { |host| query.<< "&h=#{host}" }
-      RestClient.post(uri.to_s, query, headers)
+      query
     end
 
-    def close(payload = {}, options = {})
+    def close_uri(options = {})
+      #
+      # Build the URI we use to send a 'close' request
+      #
       options[:host] ||= DEFAULT_HOST
       options[:path] ||= DEFAULT_PATH
 
-      # This request seems to need the data as a query string. I was
-      # getting a 500 when I posted a hash. A map will do the
-      # needful.
-
-      uri = URI::HTTPS.build(
+      URI::HTTPS.build(
         host:  options[:host],
         path:  options[:path] + 'close',
-
       )
-
-      RestClient.post(uri.to_s, mk_qs(payload), headers)
     end
 
-    private
+    def make_call(uri, query)
+      RestClient.post(uri.to_s, query, headers)
+    end
 
-    def mk_qs(payload)
+    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
 

data/lib/wavefront/exception.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.
@@ -24,5 +24,12 @@ module Wavefront
     class EmptyMetricName < ::Exception; end
     class NotImplemented < ::Exception; end
     class InvalidPrefixLength < ::Exception; end
+    class InvalidMetricName < ::Exception; end
+    class InvalidMetricValue < ::Exception; end
+    class InvalidTimestamp < ::Exception; end
+    class InvalidTag < ::Exception; end
+    class InvalidHostname < ::Exception; end
+    class InvalidEndpoint < ::Exception; end
+    class InvalidSource < ::Exception; end
   end
 end

data/lib/wavefront/mixins.rb

@@ -27,9 +27,15 @@ module Wavefront
     end
 
     def parse_time(t)
-      return Time.at(t.to_i) if t.match(/^\d+$/)
+      #
+      # Return a time as an integer, however it might come in.
+      #
       begin
-        return DateTime.parse("#{t} #{Time.now.getlocal.zone}").to_time.utc
+        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
       rescue
         raise "cannot parse timestamp '#{t}'."
       end
@@ -39,6 +45,7 @@ module Wavefront
       #
       # Return the time as milliseconds since the epoch
       #
+      return false unless t.is_a?(Integer)
       (t.to_f * 1000).round
     end
   end

data/lib/wavefront/writer.rb

@@ -57,8 +57,14 @@ module Wavefront
         append = "host=#{options[:host_name]} #{tags}"
       end
 
-      @socket.puts [metric_name, metric_value, options[:timestamp].to_i,
+      str = [metric_name, metric_value, options[:timestamp].to_i,
                     append].join(' ')
+
+      if options[:noop]
+        puts "metric to send: #{str}"
+      else
+        @socket.puts(str)
+      end
     end
 
     private
@@ -66,6 +72,5 @@ module Wavefront
     def get_socket(host, port)
       TCPSocket.new(host, port)
     end
-
   end
 end

data/spec/spec_helper.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.
@@ -19,6 +19,57 @@ require 'wavefront/client'
 require 'wavefront/writer'
 require 'wavefront/metadata'
 require 'wavefront/alerting'
+require 'wavefront/events'
+require 'wavefront/batch_writer'
+require 'wavefront/cli'
+require 'wavefront/cli/alerts'
+require 'wavefront/cli/events'
+require 'wavefront/cli/batch_write'
+require 'wavefront/cli/write'
 
 TEST_TOKEN = "test"
 TEST_HOST = "metrics.wavefront.com"
+
+# The following RSpec matcher is used to test things which `puts`
+# (or related), which RSpec can't do by default. It works with RSpec
+# 3, and was lifted wholesale from
+# http://stackoverflow.com/questions/6372763/rspec-how-do-i-write-a-test-that-expects-certain-output-but-doesnt-care-about/28258747#28258747
+
+RSpec::Matchers.define :match_stdout do |check|
+
+  @capture = nil
+
+  match do |block|
+
+    begin
+      stdout_saved = $stdout
+      $stdout      = StringIO.new
+      block.call
+    ensure
+      @capture     = $stdout
+      $stdout      = stdout_saved
+    end
+
+    @capture.string.match check
+  end
+
+  failure_message do
+    "expected to #{description}"
+  end
+  failure_message_when_negated do
+    "expected not to #{description}"
+  end
+  description do
+    "match [#{check}] on stdout [#{@capture.string}]"
+  end
+
+  def supports_block_expectations?
+    true
+  end
+end
+
+class Mocket
+  def puts(str)
+    return true
+  end
+end

data/spec/wavefront/batch_writer_spec.rb

@@ -0,0 +1,523 @@
+=begin
+    Copyright 2016 Wavefront Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+   limitations under the License.
+
+=end
+
+require 'spec_helper'
+require 'socket'
+
+opts = {}
+
+describe Wavefront::BatchWriter do
+
+  describe '#initialize' do
+    it 'sets @opts correctly' do
+      k = Wavefront::BatchWriter.new({noop: true, proxy: 'myproxy'})
+      expect(k.instance_variable_get(:@opts)).to eq({
+                                                tags:       false,
+                                                proxy:     'myproxy',
+                                                port:       2878,
+                                                noop:       true,
+                                                novalidate: false,
+                                                verbose:    false,
+                                                debug:      false,
+                                              })
+    end
+
+    it 'allows unset @global_tags' do
+      k = Wavefront::BatchWriter.new
+      expect(k.instance_variable_get(:@global_tags)).to be nil
+    end
+
+    it 'sets @global_tags' do
+      k = Wavefront::BatchWriter.new(tags: { t1: 'v1', t2: 'v2' })
+      expect(k.instance_variable_get(:@global_tags)).to eq({t1: 'v1', t2: 'v2'})
+    end
+
+  end
+
+  describe '#write' do
+
+    # end-to-end test
+
+    context 'without noop set' do
+      it 'should write a single metric to a socket' do
+
+        socket = Mocket.new
+        allow(TCPSocket).to receive(:new).and_return(socket)
+        expect(socket).to receive(:puts).with(
+          'test.metric 1234 1469987572 source=testhost t1="v1" t2="v2"')
+
+        k = Wavefront::BatchWriter.new(opts)
+        k.open_socket
+        expect(k.write(
+          path:   'test.metric',
+          value:  1234,
+          ts:     Time.at(1469987572),
+          source: 'testhost',
+          tags:   { t1: 'v1', t2: 'v2' },
+        )).to be(true)
+        expect(k.summary[:sent]).to eq(1)
+        expect(k.summary[:unsent]).to eq(0)
+        expect(k.summary[:rejected]).to eq(0)
+      end
+
+      it 'should write multiple metrics to a socket' do
+        socket = Mocket.new
+        allow(TCPSocket).to receive(:new).and_return(socket)
+        k = Wavefront::BatchWriter.new
+        k.open_socket
+        expect(socket).to receive(:puts).with(
+          'test.metric_1 1234 1469987572 source=testhost t1="v1" t2="v2"')
+        expect(socket).to receive(:puts).with(
+          'test.metric_2 2468 1469987572 source=testhost')
+        expect(k.write([
+          { path:   'test.metric_1',
+            value:  1234,
+            ts:     Time.at(1469987572),
+            source: 'testhost',
+            tags:   { t1: 'v1', t2: 'v2' },
+          },
+          { path:   'test.metric_2',
+            value:  2468,
+            ts:     Time.at(1469987572),
+            source: 'testhost',
+          }
+        ])).to be(true)
+        expect(k.summary[:sent]).to eq(2)
+        expect(k.summary[:unsent]).to eq(0)
+        expect(k.summary[:rejected]).to eq(0)
+      end
+
+      it 'should let good points through and drop bad points' do
+        socket = Mocket.new
+        allow(TCPSocket).to receive(:new).and_return(socket)
+        k = Wavefront::BatchWriter.new(verbose: true)
+        k.open_socket
+        expect(socket).to receive(:puts).with(
+          'test.metric_1 1234 1469987572 source=testhost t1="v1" t2="v2"')
+        expect(socket).to receive(:puts).with(
+          'test.metric_2 2468 1469987572 source=testhost')
+        expect(k.write([
+          { path:   'test.metric_1',
+            value:  1234,
+            ts:     Time.at(1469987572),
+            source: 'testhost',
+            tags:   { t1: 'v1', t2: 'v2' },
+          },
+          { path:   'bogus_metric',
+          },
+          { path:   'test.metric_2',
+            value:  2468,
+            ts:     Time.at(1469987572),
+            source: 'testhost',
+          }
+        ])).to be(false)
+        expect(k.summary[:sent]).to eq(2)
+        expect(k.summary[:unsent]).to eq(0)
+        expect(k.summary[:rejected]).to eq(1)
+      end
+    end
+
+    context 'with noop set' do
+      it 'should not write a metric to a socket object' do
+        m = 'test.metric 1234 1469987572 source=testhost t1="v1" t2="v2"'
+        socket = Mocket.new
+        allow(TCPSocket).to receive(:new).and_return(socket)
+        expect(socket).not_to receive(:puts).with(m)
+        k = Wavefront::BatchWriter.new(noop: true)
+        k.open_socket
+        k.write(
+          path:   'test.metric',
+          value:  1234,
+          ts:     Time.at(1469987572),
+          source: 'testhost',
+          tags:   { t1: 'v1', t2: 'v2' },
+        )
+        expect(k.summary[:sent]).to eq(0)
+        expect(k.summary[:unsent]).to eq(0)
+        expect(k.summary[:rejected]).to eq(0)
+      end
+    end
+  end
+
+  describe '#setup_options' do
+    defaults = {
+      tags:       false,
+      proxy:      'wavefront',
+      port:       2878,
+      noop:       false,
+      novalidate: false,
+      verbose:    false,
+      debug:      false,
+    }
+
+    it 'falls back to all defaults' do
+      k = Wavefront::BatchWriter.new
+      expect(k.setup_options({}, defaults)).to eq(defaults)
+    end
+
+    it 'allows overriding of defaults' do
+      k = Wavefront::BatchWriter.new
+      expect(k.setup_options({noop: true, proxy: 'myproxy'},
+                             defaults)).to eq({ tags:       false,
+                                                proxy:      'myproxy',
+                                                port:       2878,
+                                                noop:       true,
+                                                novalidate: false,
+                                                verbose:    false,
+                                                debug:      false,
+                                              })
+    end
+  end
+
+  describe '#valid_point?' do
+    context 'novalidate is true' do
+      k = Wavefront::BatchWriter.new({novalidate: true})
+
+      it 'lets through an invalid point' do
+        expect(k.valid_point?({junk: true})).to be(true)
+      end
+    end
+
+    context 'novalidate is false' do
+      opts[:novalidate] = false
+      k = Wavefront::BatchWriter.new(opts)
+
+      it 'lets through a valid point with all members' do
+        expect(k.valid_point?(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.now,
+          source: 'testhost',
+          tags:   { tag1: 'value 1', tag2: 'value 2' },
+        )).to be(true)
+      end
+
+      it 'lets through a valid point with no timestamp' do
+        expect(k.valid_point?(
+          path:   'test.metric',
+          value:  123456,
+          source: 'testhost',
+          tags:   { tag1: 'value 1', tag2: 'value 2' },
+        )).to be(true)
+      end
+
+      it 'lets through a valid point with no tags' do
+        expect(k.valid_point?(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.now,
+          source: 'testhost',
+        )).to be(true)
+      end
+
+      it 'raises InvalidMetricName on invalid metric name' do
+        expect{k.valid_point?(
+          path:   '!n\/@1!d_metric',
+          value:  123456,
+          ts:     Time.now,
+          source: 'testhost',
+          tags:   { tag1: 'value 1', tag2: 'value 2' },
+        )}.to raise_exception(Wavefront::Exception::InvalidMetricName)
+      end
+
+      it 'raises InvalidMetricValue on invalid metric value' do
+        expect{k.valid_point?(
+          path:   'test.metric',
+          value:  'three_point_one_four',
+          ts:     Time.now,
+          source: 'testhost',
+          tags:   { tag1: 'value 1', tag2: 'value 2' },
+        )}.to raise_exception(Wavefront::Exception::InvalidMetricValue)
+      end
+
+      it 'raises InvalidTimestamp on invalid timestamp' do
+        expect{k.valid_point?(
+          path:   'test.metric',
+          value:  123456,
+          ts:     'half_past_eleven',
+          source: 'testhost',
+          tags:   { tag1: 'value 1', tag2: 'value 2' },
+        )}.to raise_exception(Wavefront::Exception::InvalidTimestamp)
+      end
+
+      it 'raises InvalidHostname on invalid source' do
+        expect{k.valid_point?(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.now,
+          source: ['source1', 'source2'],
+          tags:   { tag1: 'value 1', tag2: 'value 2' },
+        )}.to raise_exception(Wavefront::Exception::InvalidSource)
+      end
+
+      it 'raises InvalidTag on invalid tag' do
+        expect{k.valid_point?(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.now,
+          source: 'testhost',
+          tags:   { :tag1 => 'value 1', :'invalid tag' => 'value 2' },
+        )}.to raise_exception(Wavefront::Exception::InvalidTag)
+      end
+    end
+
+  end
+
+  describe '#tag_hash_to_str' do
+    k = Wavefront::BatchWriter.new(opts)
+
+    it 'converts multiple tags to a string' do
+      expect(k.tag_hash_to_str({tag1: 'value 1', tag2: 'value 2' })).
+        to eq('tag1="value 1" tag2="value 2"')
+    end
+
+    it 'converts an empty hash to an empty string' do
+      expect(k.tag_hash_to_str({})).to eq('')
+    end
+  end
+
+  describe '#hash_to_wf' do
+    context 'when global tags are not defined' do
+      k = Wavefront::BatchWriter.new(opts)
+
+      it 'converts a known, full, point hash to a known metric' do
+        expect(k.hash_to_wf(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.at(1469987572),
+          source: 'testhost',
+          tags:   { t1: 'v1', t2: 'v2' },
+        )).to eq(
+          'test.metric 123456 1469987572 source=testhost t1="v1" t2="v2"')
+      end
+
+      it 'converts a tag-less point hash to a known metric' do
+        expect(k.hash_to_wf(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.at(1469987572),
+          source: 'testhost',
+        )).to eq('test.metric 123456 1469987572 source=testhost')
+      end
+
+      it 'converts a timestamp-less point hash to a known metric' do
+        expect(k.hash_to_wf(
+          path:   'test.metric',
+          value:  123456,
+          source: 'testhost',
+          tags:   { t1: 'v1', t2: 'v2' },
+        )).to eq('test.metric 123456 source=testhost t1="v1" t2="v2"')
+      end
+
+      it 'raises ArgumentError if vital components are missing' do
+        expect{k.hash_to_wf({})}.to raise_exception(ArgumentError)
+      end
+    end
+
+    context 'when global tags are defined' do
+      k = Wavefront::BatchWriter.new(tags: { gtag1: 'gval1', gtag2:
+                                             'gval2'})
+
+      it 'converts a known, full, point hash to a known metric' do
+        expect(k.hash_to_wf(
+          path:   'test.metric',
+          value:  123456,
+          ts:     Time.at(1469987572),
+          source: 'testhost',
+          tags:   { t1: 'v1', t2: 'v2' },
+        )).to eq(
+          'test.metric 123456 1469987572 source=testhost t1="v1" ' +
+          't2="v2" gtag1="gval1" gtag2="gval2"')
+      end
+    end
+  end
+
+  describe '#send_point' do
+    context 'without noop set' do
+      it 'should write a metric to a socket object' do
+        m = 'test.metric 1234 1469987572 source=testhost t1="v1" t2="v2"'
+        socket = Mocket.new
+        allow(TCPSocket).to receive(:new).and_return(socket)
+        expect(socket).to receive(:puts).with(m)
+        k = Wavefront::BatchWriter.new(opts)
+        k.open_socket
+        k.send_point(m)
+      end
+    end
+
+    context 'with noop set' do
+      it 'should not write a metric to a socket object' do
+        m = 'test.metric 1234 1469987572 source=testhost t1="v1" t2="v2"'
+        socket = Mocket.new
+        allow(TCPSocket).to receive(:new).and_return(socket)
+        expect(socket).not_to receive(:puts).with(m)
+        k = Wavefront::BatchWriter.new(noop: true)
+        k.open_socket
+        k.send_point(m)
+        expect{k.send_point(m)}.to match_stdout("Would send: #{m}")
+      end
+    end
+  end
+
+  describe '#open_socket' do
+
+    context 'without noop set' do
+      it 'creates a socket object with the default parameters' do
+        allow(TCPSocket).to receive(:new)
+        expect(TCPSocket).to receive(:new).with('wfp', 2878)
+        allow_any_instance_of(Wavefront::BatchWriter).to receive(:new)
+        k = Wavefront::BatchWriter.new
+        k.instance_variable_set(:@opts, proxy: 'wfp', port: 2878)
+        k.open_socket
+      end
+
+      it 'raises an exception on an invalid endpoint' do
+        allow_any_instance_of(Wavefront::BatchWriter).to receive(:new)
+        k = Wavefront::BatchWriter.new
+        k.instance_variable_set(:@opts, proxy: 'wfp', port: 2879)
+        expect{k.open_socket}.to raise_exception(
+          Wavefront::Exception::InvalidEndpoint)
+      end
+    end
+
+    context 'with noop set' do
+      it 'prints a message but does not open a socket' do
+        allow_any_instance_of(Wavefront::BatchWriter).to receive(:new)
+        k = Wavefront::BatchWriter.new
+        k.instance_variable_set(:@opts, proxy: 'wfp', port:
+                                2878, noop: true)
+        expect(k.open_socket).to be(true)
+        expect{k.open_socket}.to match_stdout(
+          'No-op requested. Not opening connection to proxy.')
+      end
+    end
+  end
+
+  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