statsd-instrument 1.6.2 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4332f173929c941bac2a915fed3be82bc447dec3
-  data.tar.gz: 52aa66f9144a09740da7767d59e4846ff38d5ffe
+  metadata.gz: a8222e6b4a44fdc424a2f767b69d1871b84f52a6
+  data.tar.gz: 092c03b43435642c4f0ae8e098971bc4c412867f
 SHA512:
-  metadata.gz: 57f6a5a32129aa3b62d76565e42d941bba4c83602454f4e05fb1383b201b826a1fd6aa120d74da5e1cd10340a528ed51ab0bcfb3e7eedc343ad8f3f2571033b9
-  data.tar.gz: 8b76f2cdf7d83ce7dd9054b882129797b5d884cabd16c699fb6e29c7e3692723ecb6d361b6df91dca4b53be6e0b9de755735fd0df356fc6c880522f79a88cd18
+  metadata.gz: eb67acff19291c3a464c99b564e2bfcc29102acaa43e60f4adbafbc04ce67c296b22f32392c1297e3462032e58cb01a7ceecb1ff0de37ff2be6fa8ee63d9d9bb
+  data.tar.gz: 159d8332ccf49f9882caa18e8f0fa7cdc95fec53ab2fe0f946ef3e12cfa6bababd91553bf1fed8ca80a7eb4fd91c5b07f0b3f2a32193b8bcd1cc9589e9daa41f

data/README.md

@@ -81,7 +81,7 @@ StatsD.increment('GoogleBase.insert')
 StatsD.increment('GoogleBase.insert', 10)
 # you can also specify a sample rate, so only 1/10 of events
 # actually get to statsd. Useful for very high volume data
-StatsD.increment('GoogleBase.insert', 1, 0.1)
+StatsD.increment('GoogleBase.insert', 1, sample_rate: 0.1)
 ```
 
 #### StatsD.gauge
@@ -89,7 +89,7 @@ StatsD.increment('GoogleBase.insert', 1, 0.1)
 A gauge is a single numerical value value that tells you the state of the system at a point in time. A good example would be the number of messages in a queue.
 
 ``` ruby
-StatsD.gauge('GoogleBase.queued', 12, 1.0)
+StatsD.gauge('GoogleBase.queued', 12, sample_rate: 1.0)
 ```
 
 Normally, you shouldn't update this value too often, and therefore there is no need to sample this kind metric.
@@ -100,7 +100,7 @@ A set keeps track of the number of unique values that have been seen. This is a
 
 ``` ruby
 # Submit the customer ID to the set. It will only be counted if it hasn't been seen before.
-StatsD.set('GoogleBase.customers', "12345", 1.0)
+StatsD.set('GoogleBase.customers', "12345", sample_rate: 1.0)
 ```
 
 Because you are counting unique values, the results of using a sampling value less than 1.0 can lead to unexpected, hard to interpret results.
@@ -174,7 +174,6 @@ end
 You can instrument class methods, just like instance methods, using the metaprogramming methods. You simply have to configure the instrumentation on the singleton class of the Class you want to instrument.
 
 ```ruby
-AWS::S3::Base.singleton_class.extend StatsD::Instrument
 AWS::S3::Base.singleton_class.statsd_measure :request, 'S3.request'
 ```
 
@@ -189,6 +188,15 @@ passed.
 GoogleBase.statsd_count :insert, lamdba{|object, args| object.class.to_s.downcase + "." + args.first.to_s + ".insert" }
 ```
 
+### Tags
+
+The Datadog implementation support tags, which you can use to slice and dice metrics in their UI. You can specify a list of tags as an option, either standalone tag (e.g. `"mytag"`), or key value based, separated by a colon: `"env:production"`.
+
+``` ruby
+StatsD.increment('my.counter', tags: ['env:production', 'unicorn'])
+GoogleBase.statsd_count :insert, 'GoogleBase.insert', tags: ['env:production']
+```
+
 ## Reliance on DNS
 
 Out of the box StatsD is set up to be unidirectional fire-and-forget over UDP. Configuring the StatsD host to be a non-ip will trigger a DNS lookup (ie synchronous round trip network call) for each metric sent. This can be particularly problematic in clouds that have a shared DNS infrastructure such as AWS.

data/lib/statsd/instrument.rb

@@ -4,42 +4,21 @@ require 'benchmark'
 require 'statsd/instrument/version'
 
 module StatsD
-  class << self
-    attr_accessor :host, :port, :mode, :logger, :enabled, :default_sample_rate,
-                  :prefix, :implementation
-  end
-
-  def self.server=(conn)
-    self.host, port = conn.split(':')
-    self.port = port.to_i
-    invalidate_socket
-  end
-
-  def self.host=(host)
-    @host = host
-    invalidate_socket
-  end
-
-  def self.port=(port)
-    @port = port
-    invalidate_socket
-  end
-
   module Instrument
 
     def self.generate_metric_name(metric_name, callee, *args)
       metric_name.respond_to?(:call) ? metric_name.call(callee, args).gsub('::', '.') : metric_name.gsub('::', '.')
     end
 
-    def statsd_measure(method, name, sample_rate = StatsD.default_sample_rate)
+    def statsd_measure(method, name, *metric_options)
       add_to_method(method, name, :measure) do |old_method, new_method, metric_name, *args|
         define_method(new_method) do |*args, &block|
-          StatsD.measure(StatsD::Instrument.generate_metric_name(metric_name, self, *args), nil, sample_rate) { send(old_method, *args, &block) }
+          StatsD.measure(StatsD::Instrument.generate_metric_name(metric_name, self, *args), nil, *metric_options) { send(old_method, *args, &block) }
         end
       end
     end
 
-    def statsd_count_success(method, name, sample_rate = StatsD.default_sample_rate)
+    def statsd_count_success(method, name, *metric_options)
       add_to_method(method, name, :count_success) do |old_method, new_method, metric_name|
         define_method(new_method) do |*args, &block|
           begin
@@ -52,13 +31,13 @@ module StatsD
             result
           ensure
             suffix = truthiness == false ? 'failure' : 'success'
-            StatsD.increment("#{StatsD::Instrument.generate_metric_name(metric_name, self, *args)}.#{suffix}", 1, sample_rate)
+            StatsD.increment("#{StatsD::Instrument.generate_metric_name(metric_name, self, *args)}.#{suffix}", 1, *metric_options)
           end
         end
       end
     end
 
-    def statsd_count_if(method, name, sample_rate = StatsD.default_sample_rate)
+    def statsd_count_if(method, name, *metric_options)
       add_to_method(method, name, :count_if) do |old_method, new_method, metric_name|
         define_method(new_method) do |*args, &block|
           begin
@@ -70,16 +49,16 @@ module StatsD
             truthiness = (yield(result) rescue false) if block_given?
             result
           ensure
-            StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), sample_rate) if truthiness
+            StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), *metric_options) if truthiness
           end
         end
       end
     end
 
-    def statsd_count(method, name, sample_rate = StatsD.default_sample_rate)
+    def statsd_count(method, name, *metric_options)
       add_to_method(method, name, :count) do |old_method, new_method, metric_name|
         define_method(new_method) do |*args, &block|
-          StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), 1, sample_rate)
+          StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), 1, *metric_options)
           send(old_method, *args, &block)
         end
       end
@@ -129,103 +108,138 @@ module StatsD
     end
   end
 
-  # glork:320|ms
-  def self.measure(key, milli = nil, sample_rate = default_sample_rate, tags = nil)
-    result = nil
-    ms = milli || 1000 * Benchmark.realtime do
-      result = yield
+  class << self
+    attr_accessor :host, :port, :mode, :logger, :enabled, :default_sample_rate, :prefix, :implementation
+
+    def server=(conn)
+      self.host, port = conn.split(':')
+      self.port = port.to_i
+      invalidate_socket
     end
 
-    collect(key, ms, :ms, sample_rate, tags)
-    result
-  end
+    def host=(host)
+      @host = host
+      invalidate_socket
+    end
 
-  # gorets:1|c
-  def self.increment(key, delta = 1, sample_rate = default_sample_rate, tags = nil)
-    collect(key, delta, :incr, sample_rate, tags)
-  end
+    def port=(port)
+      @port = port
+      invalidate_socket
+    end
 
-  # gaugor:333|g
-  # guagor:1234|kv|@1339864935 (statsite)
-  def self.gauge(key, value, sample_rate_or_epoch = default_sample_rate, tags = nil)
-    collect(key, value, :g, sample_rate_or_epoch, tags)
-  end
+    def invalidate_socket
+      @socket = nil
+    end
 
-  # histogram:123.45|h
-  def self.histogram(key, value, sample_rate_or_epoch = default_sample_rate, tags = nil)
-    collect(key, value, :h, sample_rate_or_epoch, tags)
-  end  
+    # glork:320|ms
+    def measure(key, value = nil, *metric_options)
+      if value.is_a?(Hash) && metric_options.empty?
+        metric_options = [value]
+        value = nil
+      end
 
-  # uniques:765|s
-  def self.set(key, value, sample_rate_or_epoch = default_sample_rate, tags = nil)
-    collect(key, value, :s, sample_rate_or_epoch, tags)
-  end
+      result = nil
+      ms = value || 1000 * Benchmark.realtime do
+        result = yield
+      end
 
-  private
+      collect(:ms, key, ms, hash_argument(metric_options))
+      result
+    end
 
-  def self.invalidate_socket
-    @socket = nil
-  end
+    # gorets:1|c
+    def increment(key, value = 1, *metric_options)
+      if value.is_a?(Hash) && metric_options.empty?
+        metric_options = [value]
+        value = 1
+      end
 
-  def self.socket
-    if @socket.nil?
-      @socket = UDPSocket.new
-      @socket.connect(host, port)
+      collect(:c, key, value, hash_argument(metric_options))
     end
-    @socket
-  end
 
-  def self.collect(k, v, op, sample_rate = default_sample_rate, tags = nil)
-    return unless enabled
-    return if sample_rate < 1 && rand > sample_rate
+    # gaugor:333|g
+    # guagor:1234|kv|@1339864935 (statsite)
+    def gauge(key, value, *metric_options)
+      collect(:g, key, value, hash_argument(metric_options))
+    end
 
-    command = generate_packet(k, v, op, sample_rate, tags)
-    write_packet(command)
-  end
+    # histogram:123.45|h
+    def histogram(key, value, *metric_options)
+      raise NotImplementedError, "StatsD.histogram only supported on :datadog implementation." unless self.implementation == :datadog
+      collect(:h, key, value, hash_argument(metric_options))
+    end
+
+    def key_value(key, value, *metric_options)
+      raise NotImplementedError, "StatsD.key_value only supported on :statsite implementation." unless self.implementation == :statsite
+      collect(:kv, key, value, hash_argument(metric_options))
+    end
+
+    # uniques:765|s
+    def set(key, value, *metric_options)
+      collect(:s, key, value, hash_argument(metric_options))
+    end
+
+    private
+
+    def hash_argument(args)
+      return {} if args.length == 0
+      return args.first if args.length == 1 && args.first.is_a?(Hash)
+
+      order = [:sample_rate, :tags]
+      hash = {}
+      args.each_with_index do |value, index|
+        hash[order[index]] = value
+      end    
+      
+      return hash
+    end
+
+    def socket
+      if @socket.nil?
+        @socket = UDPSocket.new
+        @socket.connect(host, port)
+      end
+      @socket
+    end
+
+    def collect(type, k, v, options = {})
+      return unless enabled
+      sample_rate = options[:sample_rate] || StatsD.default_sample_rate
+      return if sample_rate < 1 && rand > sample_rate
 
-  def self.write_packet(command)
-    if mode.to_s == 'production'
-      begin
+      packet = generate_packet(type, k, v, sample_rate, options[:tags])
+      write_packet(packet)
+    end
+
+    def write_packet(command)
+      if mode.to_s == 'production'
         socket.send(command, 0)
-      rescue SocketError, IOError, SystemCallError => e
-        logger.error e
-      end 
-    else
-      logger.info "[StatsD] #{command}"
+      else
+        logger.info "[StatsD] #{command}"
+      end
+    rescue SocketError, IOError, SystemCallError => e
+      logger.error e
     end
-  end
 
-  def self.clean_tags(tags)
-    tags.map do |tag| 
-      components = tag.split(':', 2)
-      components.map { |c| c.gsub(/[^\w\.-]+/, '_') }.join(':')
+    def clean_tags(tags)
+      tags.map do |tag| 
+        components = tag.split(':', 2)
+        components.map { |c| c.gsub(/[^\w\.-]+/, '_') }.join(':')
+      end
     end
-  end
 
-  def self.generate_packet(k, v, op, sample_rate = default_sample_rate, tags = nil)
-    command = "#{self.prefix + '.' if self.prefix}#{k}:#{v}"
-    case op
-    when :incr
-      command << '|c'
-    when :ms
-      command << '|ms'
-    when :g
-      command << (self.implementation == :statsite ? '|kv' : '|g')
-    when :h
-      raise NotImplementedError, "Histograms only supported on DataDog implementation." unless self.implementation == :datadog
-      command << '|h'
-    when :s
-      command << '|s'
-    end
-
-    command << "|@#{sample_rate}" if sample_rate < 1 || (self.implementation == :statsite && sample_rate > 1)
-    if tags
-      raise ArgumentError, "Tags are only supported on Datadog" unless self.implementation == :datadog
-      command << "|##{clean_tags(tags).join(',')}"
-    end
-
-    command << "\n" if self.implementation == :statsite
-    return command
+    def generate_packet(type, k, v, sample_rate = default_sample_rate, tags = nil)
+      command = self.prefix ? self.prefix + '.' : ''
+      command << "#{k}:#{v}|#{type}"
+      command << "|@#{sample_rate}" if sample_rate < 1 || (self.implementation == :statsite && sample_rate > 1)
+      if tags
+        raise ArgumentError, "Tags are only supported on :datadog implementation" unless self.implementation == :datadog
+        command << "|##{clean_tags(tags).join(',')}"
+      end
+
+      command << "\n" if self.implementation == :statsite
+      command
+    end
   end
 end
 

data/lib/statsd/instrument/version.rb

@@ -1,5 +1,5 @@
 module StatsD
   module Instrument
-    VERSION = "1.6.2"
+    VERSION = "1.7.0"
   end
 end

data/test/statsd_instrumentation_test.rb

@@ -51,7 +51,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_count_if
     ActiveMerchant::Gateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.if', 1).once
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.if').once
     ActiveMerchant::Gateway.new.purchase(true)
     ActiveMerchant::Gateway.new.purchase(false)
 
@@ -63,7 +63,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result == 'true'
     end
 
-    StatsD.expects(:collect).with('ActiveMerchant.Base.post_with_block', 1, :incr, 1.0, nil).once
+    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block', 1, {}).once
     assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
     assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
 
@@ -75,7 +75,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result[:success]
     end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.block', 1).once
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.block').once
     ActiveMerchant::UniqueGateway.new.purchase(true)
     ActiveMerchant::UniqueGateway.new.purchase(false)
 
@@ -99,8 +99,8 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result == 'successful'
     end
 
-    StatsD.expects(:collect).with('ActiveMerchant.Base.post_with_block.success', 1, :incr, 1.0, nil).once
-    StatsD.expects(:collect).with('ActiveMerchant.Base.post_with_block.failure', 1, :incr, 1.0, nil).once
+    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block.success', 1, {}).once
+    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block.failure', 1, {}).once
     
     assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
     assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
@@ -113,10 +113,10 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result[:success]
     end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1, StatsD.default_sample_rate)
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1)
     ActiveMerchant::UniqueGateway.new.purchase(true)
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1, StatsD.default_sample_rate)
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1)
     ActiveMerchant::UniqueGateway.new.purchase(false)
 
     ActiveMerchant::UniqueGateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
@@ -125,7 +125,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_count
     ActiveMerchant::Gateway.statsd_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.ssl_post', 1, StatsD.default_sample_rate)
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.ssl_post', 1)
     ActiveMerchant::Gateway.new.purchase(true)
 
     ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
@@ -135,7 +135,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
     metric_namer = lambda { |object, args| object.class.to_s.downcase + ".insert." + args.first.to_s }
     ActiveMerchant::Gateway.statsd_count(:ssl_post, metric_namer)
 
-    StatsD.expects(:increment).with('gatewaysubclass.insert.true', 1, StatsD.default_sample_rate)
+    StatsD.expects(:increment).with('gatewaysubclass.insert.true', 1)
     GatewaySubClass.new.purchase(true)
 
     ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
@@ -144,7 +144,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_count_with_method_receiving_block
     ActiveMerchant::Base.statsd_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
 
-    StatsD.expects(:collect).with('ActiveMerchant.Base.post_with_block', 1, :incr, 1.0, nil)
+    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block', 1, {})
     assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
 
     ActiveMerchant::Base.statsd_remove_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
@@ -153,7 +153,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_measure_with_nested_modules
     ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
 
-    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil, StatsD.default_sample_rate)
+    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil)
     ActiveMerchant::UniqueGateway.new.purchase(true)
 
     ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
@@ -171,7 +171,7 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_measure_with_method_receiving_block
     ActiveMerchant::Base.statsd_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
 
-    StatsD.expects(:collect).with('ActiveMerchant.Base.post_with_block', is_a(Float), :ms, 1.0, nil)
+    StatsD.expects(:collect).with(:ms, 'ActiveMerchant.Base.post_with_block', is_a(Float), {})
     assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
 
     ActiveMerchant::Base.statsd_remove_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
@@ -181,7 +181,17 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
     ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
     ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.sync', 1, StatsD.default_sample_rate)
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.sync', 1)
+    ActiveMerchant::Gateway.sync
+
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+  end
+
+  def test_statsd_count_with_tags
+    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
+    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync', :tags => ['t']
+
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.sync', 1, :tags => ['t'])
     ActiveMerchant::Gateway.sync
 
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'

data/test/statsd_test.rb

@@ -16,38 +16,61 @@ class StatsDTest < Test::Unit::TestCase
   end
 
   def test_statsd_measure_with_explicit_value
-    StatsD.expects(:collect).with('values.foobar', 42, :ms, 1.0, nil)
+    StatsD.expects(:collect).with(:ms, 'values.foobar', 42, {})
     StatsD.measure('values.foobar', 42)
   end
 
   def test_statsd_measure_with_explicit_value_and_sample_rate
-    StatsD.expects(:collect).with('values.foobar', 42, :ms, 0.1, nil)
-    StatsD.measure('values.foobar', 42, 0.1)
+    StatsD.expects(:collect).with(:ms, 'values.foobar', 42, :sample_rate => 0.1)
+    StatsD.measure('values.foobar', 42, :sample_rate => 0.1)
   end
 
   def test_statsd_measure_with_benchmarked_value
     Benchmark.stubs(:realtime).returns(1.12)
-    StatsD.expects(:collect).with('values.foobar', 1120.0, :ms, 1.0, nil)
-    StatsD.measure('values.foobar', nil) do
+    StatsD.expects(:collect).with(:ms, 'values.foobar', 1120.0, {})
+    StatsD.measure('values.foobar') do
       #noop
     end
   end
 
+  def test_statsd_measure_with_benchmarked_value_and_options
+    Benchmark.stubs(:realtime).returns(1.12)
+    StatsD.expects(:collect).with(:ms, 'values.foobar', 1120.0, :sample_rate => 1.0)
+    StatsD.measure('values.foobar', :sample_rate => 1.0) do
+      #noop
+    end
+  end
+
+  def test_statsd_increment_with_hash_argument
+    StatsD.expects(:collect).with(:c, 'values.foobar', 1, :tags => ['test'])
+    StatsD.increment('values.foobar', :tags => ['test'])
+  end
+
+  def test_statsd_increment_with_multiple_arguments
+    StatsD.expects(:collect).with(:c, 'values.foobar', 12, :sample_rate => nil, :tags => ['test'])
+    StatsD.increment('values.foobar', 12, nil, ['test'])
+  end
+
   def test_statsd_gauge
-    StatsD.expects(:collect).with('values.foobar', 12, :g, 1.0, nil)
+    StatsD.expects(:collect).with(:g, 'values.foobar', 12, {})
     StatsD.gauge('values.foobar', 12)
   end
 
   def test_statsd_set
-    StatsD.expects(:collect).with('values.foobar', 12, :s, 1.0, nil)
+    StatsD.expects(:collect).with(:s, 'values.foobar', 12, {})
     StatsD.set('values.foobar', 12)
   end
 
   def test_statsd_histogram_on_datadog
     StatsD.stubs(:implementation).returns(:datadog)
-    StatsD.expects(:collect).with('values.hg', 12.33, :h, 0.2, ['tag_123', 'key-name:value123'])
-    StatsD.histogram('values.hg', 12.33, 0.2, ['tag_123', 'key-name:value123'])
-  end  
+    StatsD.expects(:collect).with(:h, 'values.hg', 12.33, :sample_rate => 0.2, :tags => ['tag_123', 'key-name:value123'])
+    StatsD.histogram('values.hg', 12.33, :sample_rate => 0.2, :tags => ['tag_123', 'key-name:value123'])
+  end
+
+  def test_raise_when_using_histograms_and_not_on_datadog
+    StatsD.stubs(:implementation).returns(:other)
+    assert_raises(NotImplementedError) { StatsD.histogram('foohg', 3.33) }
+  end
 
   def test_collect_respects_enabled
     StatsD.stubs(:enabled).returns(false)
@@ -119,26 +142,31 @@ class StatsDTest < Test::Unit::TestCase
   def test_rewrite_shitty_tags
     StatsD.stubs(:implementation).returns(:datadog)
 
-    assert_equal ['igno_red'], StatsD.clean_tags(['igno,red'])
-    assert_equal ['igno_red'], StatsD.clean_tags(['igno  red'])
-    assert_equal ['test:test_test'], StatsD.clean_tags(['test:test:test'])
+    assert_equal ['igno_red'], StatsD.send(:clean_tags, ['igno,red'])
+    assert_equal ['igno_red'], StatsD.send(:clean_tags, ['igno  red'])
+    assert_equal ['test:test_test'], StatsD.send(:clean_tags, ['test:test:test'])
 
     StatsD.expects(:write_packet).with("fooc:3|c|#topic:foo_foo,bar_")
     StatsD.increment('fooc', 3, 1.0, ['topic:foo : foo', 'bar '])
   end
 
-  def test_supports_gauge_syntax_on_statsite
+  def test_supports_key_value_syntax_on_statsite
     StatsD.stubs(:implementation).returns(:statsite)
 
     StatsD.expects(:write_packet).with("fooy:42|kv\n")
-    StatsD.gauge('fooy', 42)
+    StatsD.key_value('fooy', 42)
   end
 
-  def test_supports_gauge_timestamp_on_statsite
+  def test_supports_key_value_with_timestamp_on_statsite
     StatsD.stubs(:implementation).returns(:statsite)
 
     StatsD.expects(:write_packet).with("fooy:42|kv|@123456\n")
-    StatsD.gauge('fooy', 42, 123456)
+    StatsD.key_value('fooy', 42, 123456)
+  end
+
+  def test_raise_when_using_key_value_and_not_on_statsite
+    StatsD.stubs(:implementation).returns(:other)
+    assert_raises(NotImplementedError) { StatsD.key_value('fookv', 3.33) }
   end
 
   def test_support_key_prefix

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.7.0
 platform: ruby
 authors:
 - Jesse Storimer
@@ -9,34 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2014-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A StatsD client for Ruby appspec. Provides metaprogramming methods to
@@ -47,8 +47,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -70,17 +70,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A StatsD client for Ruby apps