statsd-instrument 1.5.0 → 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9bc489157242e310ea28c0a1680fb34c608a8e6
+  data.tar.gz: 64ca871cc2a93f2fed3c5690fa6b53a1cd864925
+SHA512:
+  metadata.gz: 7eb191b76130aef5e14cc7e9b74d22936809713339b5accfa25c995507fb8ebf2ba9d879cba31ed64c6773ec97b82c38e1ccbc9a0352597c3f972dc46afdc9c2
+  data.tar.gz: 3390177c19dfa7c9bca20f9d9a26fe36ead251bf8142132d0b866c2a09e435211c74cad4897156a4c914aa6b285d415896153a8ebd5447cda6076ae06a451cb4

data/.travis.yml

@@ -4,3 +4,4 @@ rvm:
   - ree
   - 1.9.2
   - 1.9.3
+  - 2.0.0

data/README.md

@@ -28,6 +28,13 @@ StatsD.default_sample_rate = 0.1 # Sample 10% of events. By default all events a
 
 If you set the mode to anything besides production then the library will print its calls to the logger, rather than sending them over the wire.
 
+There are several implementations of StatsD out there, all with slight protocol variations. You can this library to use the proper protocol by informing it about what implementation you use. By default, it will use the protocol of the original Etsy implementation.
+
+```
+StatsD.implementation = :datadog  # Enable datadog extensions: tags and histograms
+StatsD.implementation = :statsite # Enable keyvalue-style gauges 
+```
+
 ## StatsD keys
 
 StatsD keys look like 'admin.logins.api.success'. Each dot in the key represents a 'folder' in the graphite interface. You can include any data you want in the keys.
@@ -148,20 +155,23 @@ GoogleBase.statsd_count :insert, lamdba{|object, args| object.class.to_s.downcas
 ```
 
 ## 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.
 
 ### Common Workarounds
+
 1. Using an IP avoids the DNS lookup but generally requires an application deploy to change.
 2. Hardcoding the DNS/IP pair in /etc/hosts allows the IP to change without redeploying your application but fails to scale as the number of servers increases.
 3. Installing caching software such as nscd that uses the DNS TTL avoids most DNS lookups but makes the exact moment of change indeterminate.
 
 ## Compatibility
 
-Tested on:
+Tested on several Ruby versions using Travis CI:
 
 * Ruby 1.8.7
 * Ruby Enterprise Edition 1.8.7
 * Ruby 1.9.2
 * Ruby 1.9.3
+* Ruby 2.0.0
 
-Ruby 1.9 compatibility is planned for the long term. Your mileage may vary with other Ruby environments.
+Ruby 2.0 compatibility is planned for the long term. Your mileage may vary with other Ruby environments.

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new('test') do |t|
   t.ruby_opts << '-rubygems'
-  t.libs << 'lib'
+  t.libs << 'lib' << 'test'
   t.test_files = FileList['test/*.rb']
 end
 

data/lib/statsd/instrument.rb

@@ -1,13 +1,7 @@
 require 'socket'
 require 'benchmark'
-require 'timeout'
-
-class << Benchmark
-  def ms
-    1000 * realtime { yield }
-  end
-end
 
+require 'statsd/instrument/version'
 
 module StatsD
   class << self
@@ -18,19 +12,33 @@ module StatsD
   self.default_sample_rate = 1.0
   self.implementation = :statsd
 
-  TimeoutClass = defined?(::SystemTimer) ? ::SystemTimer : ::Timeout
-
   # StatsD.server = 'localhost:1234'
   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)
       add_to_method(method, name, :measure) do |old_method, new_method, metric_name, *args|
         define_method(new_method) do |*args, &block|
-          StatsD.measure(metric_name.respond_to?(:call) ? metric_name.call(self, args) : metric_name, nil, sample_rate) { send(old_method, *args, &block) }
+          StatsD.measure(StatsD::Instrument.generate_metric_name(metric_name, self, *args), nil, sample_rate) { send(old_method, *args, &block) }
         end
       end
     end
@@ -47,10 +55,8 @@ module StatsD
             truthiness = (yield(result) rescue false) if block_given?
             result
           ensure
-            result = truthiness == false ? 'failure' : 'success'
-            key = metric_name.respond_to?(:call) ? metric_name.call(self, args) : metric_name
-
-            StatsD.increment("#{key}.#{result}", sample_rate)
+            suffix = truthiness == false ? 'failure' : 'success'
+            StatsD.increment("#{StatsD::Instrument.generate_metric_name(metric_name, self, *args)}.#{suffix}", 1, sample_rate)
           end
         end
       end
@@ -68,7 +74,7 @@ module StatsD
             truthiness = (yield(result) rescue false) if block_given?
             result
           ensure
-            StatsD.increment(metric_name.respond_to?(:call) ? metric_name.call(self, args) : metric_name, sample_rate) if truthiness
+            StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), sample_rate) if truthiness
           end
         end
       end
@@ -77,13 +83,30 @@ module StatsD
     def statsd_count(method, name, sample_rate = StatsD.default_sample_rate)
       add_to_method(method, name, :count) do |old_method, new_method, metric_name|
         define_method(new_method) do |*args, &block|
-          StatsD.increment(metric_name.respond_to?(:call) ? metric_name.call(self, args) : metric_name, sample_rate)
+          StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), 1, sample_rate)
           send(old_method, *args, &block)
         end
       end
     end
 
+    def statsd_remove_count(method, name)
+      remove_from_method(method, name, :count)
+    end
+
+    def statsd_remove_count_if(method, name)
+      remove_from_method(method, name, :count_if)
+    end
+
+    def statsd_remove_count_success(method, name)
+      remove_from_method(method, name, :count_success)
+    end
+
+    def statsd_remove_measure(method, name)
+      remove_from_method(method, name, :measure)
+    end
+
     private
+
     def add_to_method(method, name, action, &block)
       metric_name = name
 
@@ -100,42 +123,85 @@ module StatsD
       yield method_name_without_statsd, method_name_with_statsd, metric_name
       alias_method method, method_name_with_statsd
     end
+
+    def remove_from_method(method, name, action)
+      method_name_without_statsd = :"#{method}_for_#{action}_on_#{self.name}_without_#{name}"
+      method_name_with_statsd = :"#{method}_for_#{action}_on_#{self.name}_with_#{name}"
+      send(:remove_method, method_name_with_statsd)
+      alias_method method, method_name_without_statsd
+      send(:remove_method, method_name_without_statsd)
+    end
   end
 
   # glork:320|ms
-  def self.measure(key, milli = nil, sample_rate = default_sample_rate)
+  def self.measure(key, milli = nil, sample_rate = default_sample_rate, tags = nil)
     result = nil
-    ms = milli || Benchmark.ms do
+    ms = milli || 1000 * Benchmark.realtime do
       result = yield
     end
 
-    write(key, ms, :ms, sample_rate)
+    collect(key, ms, :ms, sample_rate, tags)
     result
   end
 
   # gorets:1|c
-  def self.increment(key, delta = 1, sample_rate = default_sample_rate)
-    write(key, delta, :incr, sample_rate)
+  def self.increment(key, delta = 1, sample_rate = default_sample_rate, tags = nil)
+    collect(key, delta, :incr, sample_rate, tags)
   end
 
   # gaugor:333|g
   # guagor:1234|kv|@1339864935 (statsite)
-  def self.gauge(key, value, sample_rate_or_epoch = default_sample_rate)
-    write(key, value, :g, sample_rate_or_epoch)
+  def self.gauge(key, value, sample_rate_or_epoch = default_sample_rate, tags = nil)
+    collect(key, value, :g, sample_rate_or_epoch, tags)
   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  
+
   private
 
+  def self.invalidate_socket
+    @socket = nil
+  end
+
   def self.socket
-    @socket ||= UDPSocket.new
+    if @socket.nil?
+      @socket = UDPSocket.new
+      @socket.connect(host, port)
+    end
+    @socket
   end
 
-  def self.write(k,v,op, sample_rate = default_sample_rate)
+  def self.collect(k, v, op, sample_rate = default_sample_rate, tags = nil)
     return unless enabled
     return if sample_rate < 1 && rand > sample_rate
 
-    k =  k.gsub('::', '.')
+    command = generate_packet(k, v, op, sample_rate, tags)
+    write_packet(command)
+  end
+
+  def self.write_packet(command)
+    if mode.to_s == 'production'
+      begin
+        socket.send(command, 0)
+      rescue SocketError, IOError, SystemCallError => e
+        logger.error e
+      end 
+    else
+      logger.info "[StatsD] #{command}"
+    end
+  end
 
+  def self.clean_tags(tags)
+    tags.map do |tag| 
+      components = tag.split(':', 2)
+      components.map { |c| c.gsub(/[^\w\.-]+/, '_') }.join(':')
+    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
@@ -144,22 +210,18 @@ module StatsD
       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'
     end
 
     command << "|@#{sample_rate}" if sample_rate < 1 || (self.implementation == :statsite && sample_rate > 1)
-    command << "\n" if self.implementation == :statsite
-
-    if mode.to_s == 'production'
-      socket_wrapper { socket.send(command, 0, host, port) }
-    else
-      logger.info "[StatsD] #{command}"
+    if tags
+      raise ArgumentError, "Tags are only supported on Datadog" unless self.implementation == :datadog
+      command << "|##{clean_tags(tags).join(',')}"
     end
-  end
 
-  def self.socket_wrapper(options = {})
-    TimeoutClass.timeout(options.fetch(:timeout, 0.1)) { yield }
-  rescue Timeout::Error, SocketError, IOError, SystemCallError => e
-    logger.error e
+    command << "\n" if self.implementation == :statsite
+    return command
   end
 end
-

data/lib/statsd/instrument/version.rb

@@ -0,0 +1,5 @@
+module StatsD
+  module Instrument
+ 	  VERSION = "1.6.0"
+  end
+end

data/statsd-instrument.gemspec

@@ -1,15 +1,23 @@
-Gem::Specification.new do |s|
-  s.name        = "statsd-instrument"
-  s.version     = '1.5.0'
-  s.authors     = ["Jesse Storimer", "Tobias Lutke"]
-  s.email       = ["jesse@shopify.com"]
-  s.homepage    = "http://github.com/shopify/statsd-instrument"
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'statsd/instrument/version'
 
-  s.summary     = %q{A StatsD client for Ruby apps}
-  s.description = %q{A StatsD client for Ruby apps. Provides metaprogramming methods to inject StatsD instrumentation into your code.}
+Gem::Specification.new do |spec|
+  spec.name        = "statsd-instrument"
+  spec.version     = StatsD::Instrument::VERSION
+  spec.authors     = ["Jesse Storimer", "Tobias Lutke"]
+  spec.email       = ["jesse@shopify.com"]
+  spec.homepage    = "https://github.com/Shopify/statsd-instrument"
+  spec.summary     = %q{A StatsD client for Ruby apps}
+  spec.description = %q{A StatsD client for Ruby appspec. Provides metaprogramming methods to inject StatsD instrumentation into your code.}
+  spec.license       = "MIT"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  s.add_development_dependency 'mocha'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'mocha'
 end

data/test/statsd_instrumentation_test.rb

@@ -0,0 +1,189 @@
+require 'test_helper'
+
+module ActiveMerchant; end
+class ActiveMerchant::Base
+  def ssl_post(arg)
+    if arg
+      'OK'
+    else
+      raise 'Not OK'
+    end
+  end
+
+  def post_with_block(&block)
+    yield if block_given?
+  end
+end
+
+class ActiveMerchant::Gateway < ActiveMerchant::Base
+  def purchase(arg)
+    ssl_post(arg)
+    true
+  rescue
+    false
+  end
+
+  def self.sync
+    true
+  end
+
+  def self.singleton_class
+    class << self; self; end
+  end
+end
+
+class ActiveMerchant::UniqueGateway < ActiveMerchant::Base
+  def ssl_post(arg)
+    {:success => arg}
+  end
+
+  def purchase(arg)
+    ssl_post(arg)
+  end
+end
+
+class GatewaySubClass < ActiveMerchant::Gateway
+end
+
+ActiveMerchant::Base.extend StatsD::Instrument
+
+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
+    ActiveMerchant::Gateway.new.purchase(true)
+    ActiveMerchant::Gateway.new.purchase(false)
+
+    ActiveMerchant::Gateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
+  end
+
+  def test_statsd_count_if_with_method_receiving_block
+    ActiveMerchant::Base.statsd_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block' do |result|
+      result == 'true'
+    end
+
+    StatsD.expects(:collect).with('ActiveMerchant.Base.post_with_block', 1, :incr, 1.0, nil).once
+    assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
+    assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
+
+    ActiveMerchant::Base.statsd_remove_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block'
+  end
+
+  def test_statsd_count_if_with_block
+    ActiveMerchant::UniqueGateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.block' do |result|
+      result[:success]
+    end
+
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.block', 1).once
+    ActiveMerchant::UniqueGateway.new.purchase(true)
+    ActiveMerchant::UniqueGateway.new.purchase(false)
+
+    ActiveMerchant::UniqueGateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.block'
+  end
+
+  def test_statsd_count_success
+    ActiveMerchant::Gateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway', 0.5
+
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1, 0.5).once
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1, 0.5).once
+
+    ActiveMerchant::Gateway.new.purchase(true)
+    ActiveMerchant::Gateway.new.purchase(false)
+
+    ActiveMerchant::Gateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
+  end
+
+  def test_statsd_count_success_with_method_receiving_block
+    ActiveMerchant::Base.statsd_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block' do |result|
+      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
+    
+    assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
+    assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+
+    ActiveMerchant::Base.statsd_remove_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block'
+  end
+
+  def test_statsd_count_success_with_block
+    ActiveMerchant::UniqueGateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway' do |result|
+      result[:success]
+    end
+
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1, StatsD.default_sample_rate)
+    ActiveMerchant::UniqueGateway.new.purchase(true)
+
+    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1, StatsD.default_sample_rate)
+    ActiveMerchant::UniqueGateway.new.purchase(false)
+
+    ActiveMerchant::UniqueGateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
+  end
+
+  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)
+    ActiveMerchant::Gateway.new.purchase(true)
+
+    ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+  end
+
+  def test_statsd_count_with_name_as_lambda
+    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)
+    GatewaySubClass.new.purchase(true)
+
+    ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
+  end
+
+  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)
+    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'
+  end
+
+  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)
+    ActiveMerchant::UniqueGateway.new.purchase(true)
+
+    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+  end
+
+  def test_statsd_measure
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 0.3
+
+    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil, 0.3)
+    ActiveMerchant::UniqueGateway.new.purchase(true)
+
+    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+  end
+
+  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)
+    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'
+  end
+
+  def test_instrumenting_class_method
+    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)
+    ActiveMerchant::Gateway.sync
+
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+  end
+end

data/test/statsd_test.rb

@@ -0,0 +1,209 @@
+require 'test_helper'
+
+class StatsDTest < Test::Unit::TestCase
+
+  def setup
+    StatsD.stubs(:rand).returns(0.0)
+
+    UDPSocket.stubs(:new).returns(@socket = mock('socket'))
+    @socket.stubs(:connect)
+    @socket.stubs(:send)
+    StatsD.invalidate_socket
+
+    StatsD.stubs(:logger).returns(@logger = mock('logger'))
+    @logger.stubs(:info)
+    @logger.stubs(:error)
+  end
+
+  def test_statsd_measure_with_explicit_value
+    StatsD.expects(:collect).with('values.foobar', 42, :ms, 1.0, nil)
+    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)
+  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
+      #noop
+    end
+  end
+
+  def test_statsd_gauge
+    StatsD.expects(:collect).with('values.foobar', 12, :g, 1.0, nil)
+    StatsD.gauge('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  
+
+  def test_collect_respects_enabled
+    StatsD.stubs(:enabled).returns(false)
+    StatsD.expects(:write_packet).never
+    StatsD.increment('counter')
+  end
+
+  def test_collect_respects_sampling_rate
+    StatsD.expects(:write_packet).once
+
+    StatsD.stubs(:rand).returns(0.6)
+    StatsD.increment('counter', 1, 0.5)
+
+    StatsD.stubs(:rand).returns(0.4)
+    StatsD.increment('counter', 1, 0.5)    
+  end
+
+  def test_support_counter_syntax
+    StatsD.expects(:write_packet).with('counter:1|c')
+    StatsD.increment('counter')
+
+    StatsD.expects(:write_packet).with('counter:10|c|@0.5')
+    StatsD.increment('counter', 10, 0.5)
+  end
+
+  def test_supports_gauge_syntax
+    StatsD.expects(:write_packet).with('fooy:1.23|g')
+    StatsD.gauge('fooy', 1.23)
+
+    StatsD.expects(:write_packet).with('fooy:42|g|@0.01')
+    StatsD.gauge('fooy', 42, 0.01)
+  end
+
+  def test_support_timing_syntax
+    StatsD.expects(:write_packet).with('duration:1.23|ms')
+    StatsD.measure('duration', 1.23)
+
+    StatsD.expects(:write_packet).with('duration:0.42|ms|@0.01')
+    StatsD.measure('duration', 0.42, 0.01)
+  end
+
+  def test_histogram_syntax_on_datadog
+    StatsD.stubs(:implementation).returns(:datadog)
+
+    StatsD.expects(:write_packet).with('fooh:42.4|h')
+    StatsD.histogram('fooh', 42.4)
+  end
+
+  def test_support_tags_syntax_on_datadog
+    StatsD.stubs(:implementation).returns(:datadog)
+
+    StatsD.expects(:write_packet).with("fooc:3|c|#topic:foo,bar")
+    StatsD.increment('fooc', 3, 1.0, ['topic:foo', 'bar'])
+  end
+
+  def test_raise_when_using_tags_and_not_on_datadog
+    StatsD.stubs(:implementation).returns(:other)
+    assert_raises(ArgumentError) { StatsD.increment('fooc', 3, 1.0, ['nonempty']) }
+  end
+
+  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'])
+
+    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
+    StatsD.stubs(:implementation).returns(:statsite)
+
+    StatsD.expects(:write_packet).with("fooy:42|kv\n")
+    StatsD.gauge('fooy', 42)
+  end
+
+  def test_supports_gauge_timestamp_on_statsite
+    StatsD.stubs(:implementation).returns(:statsite)
+
+    StatsD.expects(:write_packet).with("fooy:42|kv|@123456\n")
+    StatsD.gauge('fooy', 42, 123456)
+  end
+
+  def test_support_key_prefix
+    StatsD.expects(:write_packet).with('prefix.counter:1|c').once
+    StatsD.expects(:write_packet).with('counter:1|c').once
+
+    StatsD.stubs(:prefix).returns('prefix')
+    StatsD.increment('counter')
+    StatsD.stubs(:prefix).returns(nil)
+    StatsD.increment('counter')
+  end
+
+  def test_development_mode_uses_logger
+    StatsD.stubs(:mode).returns(:development)
+
+    @logger.expects(:info).with(regexp_matches(/\A\[StatsD\] /))
+    StatsD.increment('counter')
+  end  
+
+  def test_production_mode_uses_udp_socket
+    StatsD.stubs(:mode).returns(:production)
+    StatsD.server = "localhost:9815"
+
+    @socket.expects(:connect).with('localhost', 9815).once
+    @socket.expects(:send).with(is_a(String), 0).twice
+    StatsD.increment('counter')
+    StatsD.increment('counter')
+  end
+
+  def test_changing_host_or_port_should_create_new_socket
+    @socket.expects(:connect).with('localhost', 1234).once
+    @socket.expects(:connect).with('localhost', 2345).once
+    @socket.expects(:connect).with('127.0.0.1', 2345).once
+
+    StatsD.server = "localhost:1234"
+    StatsD.send(:socket)
+    
+    StatsD.port = 2345
+    StatsD.send(:socket)
+
+    StatsD.host = '127.0.0.1'
+    StatsD.send(:socket)
+  end
+
+  def test_socket_error_should_not_raise_but_log
+    StatsD.stubs(:mode).returns(:production)
+    @socket.stubs(:connect).raises(SocketError)
+    
+    @logger.expects(:error).with(instance_of(SocketError))
+    StatsD.measure('values.foobar', 42)
+  end
+
+  def test_system_call_error_should_not_raise_but_log
+    StatsD.stubs(:mode).returns(:production)
+    @socket.stubs(:send).raises(Errno::ETIMEDOUT)
+    
+    @logger.expects(:error).with(instance_of(Errno::ETIMEDOUT))
+    StatsD.measure('values.foobar', 42)
+  end
+
+  def test_io_error_should_not_raise_but_log
+    StatsD.stubs(:mode).returns(:production)
+    @socket.stubs(:send).raises(IOError)
+
+    @logger.expects(:error).with(instance_of(IOError))
+    StatsD.measure('values.foobar', 42)
+  end
+
+  def test_live_local_udp_socket
+    UDPSocket.unstub(:new)
+
+    StatsD.stubs(:mode).returns(:production)
+    StatsD.server = "localhost:31798"
+
+    server = UDPSocket.new
+    server.bind('localhost', 31798)
+
+    StatsD.increment('counter')
+    assert_equal "counter:1|c", server.recvfrom(100).first
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'statsd-instrument'
+require 'test/unit'
+require 'mocha/setup'
+
+require 'logger'
+StatsD.logger = Logger.new('/dev/null')

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 1.5.0
-  prerelease: 
+  version: 1.6.0
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,26 +9,38 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2014-01-21 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
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A StatsD client for Ruby apps. Provides metaprogramming methods to inject
-  StatsD instrumentation into your code.
+description: A StatsD client for Ruby appspec. Provides metaprogramming methods to
+  inject StatsD instrumentation into your code.
 email:
 - jesse@shopify.com
 executables: []
@@ -44,31 +55,36 @@ files:
 - Rakefile
 - lib/statsd-instrument.rb
 - lib/statsd/instrument.rb
+- lib/statsd/instrument/version.rb
 - statsd-instrument.gemspec
-- test/statsd-instrument_test.rb
-homepage: http://github.com/shopify/statsd-instrument
-licenses: []
+- test/statsd_instrumentation_test.rb
+- test/statsd_test.rb
+- test/test_helper.rb
+homepage: https://github.com/Shopify/statsd-instrument
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A StatsD client for Ruby apps
 test_files:
-- test/statsd-instrument_test.rb
+- test/statsd_instrumentation_test.rb
+- test/statsd_test.rb
+- test/test_helper.rb

data/test/statsd-instrument_test.rb

@@ -1,339 +0,0 @@
-# Allow testing with the SystemTimer gem on 1.8
-if RUBY_VERSION =~ /^1.8/
-  puts "Loading SystemTimer gem"
-  require 'system_timer'
-end
-
-require 'statsd-instrument'
-require 'test/unit'
-require 'mocha'
-require 'logger'
-
-StatsD.logger = Logger.new('/dev/null')
-
-module ActiveMerchant; end
-class ActiveMerchant::Base
-  def ssl_post(arg)
-    if arg
-      'OK'
-    else
-      raise 'Not OK'
-    end
-  end
-
-  def post_with_block(&block)
-    yield if block_given?
-  end
-end
-
-class ActiveMerchant::Gateway < ActiveMerchant::Base
-  def purchase(arg)
-    ssl_post(arg)
-    true
-  rescue
-    false
-  end
-
-  def self.sync
-    true
-  end
-
-  def self.singleton_class
-    class << self; self; end
-  end
-end
-
-class ActiveMerchant::UniqueGateway < ActiveMerchant::Base
-  def ssl_post(arg)
-    {:success => arg}
-  end
-
-  def purchase(arg)
-    ssl_post(arg)
-  end
-end
-
-class GatewaySubClass < ActiveMerchant::Gateway
-end
-
-ActiveMerchant::Base.extend StatsD::Instrument
-
-class StatsDTest < Test::Unit::TestCase
-  def setup
-    StatsD.mode = nil
-    StatsD.stubs(:increment)
-  end
-
-  def test_statsd_count_if
-    ActiveMerchant::Gateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
-
-    StatsD.expects(:increment).with(includes('if'), 1).once
-    ActiveMerchant::Gateway.new.purchase(true)
-    ActiveMerchant::Gateway.new.purchase(false)
-  end
-
-  def test_statsd_count_if_with_method_receiving_block
-    ActiveMerchant::Base.statsd_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block' do |result|
-      result[:success]
-    end
-
-    return_value = ActiveMerchant::Base.new.post_with_block {'block called'}
-
-    assert_equal 'block called', return_value
-  end
-
-  def test_statsd_count_if_with_block
-    ActiveMerchant::UniqueGateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.block' do |result|
-      result[:success]
-    end
-
-    StatsD.expects(:increment).with(includes('block'), 1).once
-    ActiveMerchant::UniqueGateway.new.purchase(true)
-    ActiveMerchant::UniqueGateway.new.purchase(false)
-  end
-
-  def test_statsd_count_success
-    ActiveMerchant::Gateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway', 0.5
-
-    StatsD.expects(:increment).with(includes('success'), 0.5)
-    ActiveMerchant::Gateway.new.purchase(true)
-
-    StatsD.expects(:increment).with(includes('failure'), 0.5)
-    ActiveMerchant::Gateway.new.purchase(false)
-  end
-
-  def test_statsd_count_success_with_method_receiving_block
-    ActiveMerchant::Base.statsd_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block' do |result|
-      result[:success]
-    end
-
-    return_value = ActiveMerchant::Base.new.post_with_block {'block called'}
-
-    assert_equal 'block called', return_value
-  end
-
-  def test_statsd_count_success_with_block
-    ActiveMerchant::UniqueGateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway' do |result|
-      result[:success]
-    end
-
-    StatsD.expects(:increment).with(includes('success'), StatsD.default_sample_rate)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
-
-    StatsD.expects(:increment).with(includes('failure'), StatsD.default_sample_rate)
-    ActiveMerchant::UniqueGateway.new.purchase(false)
-  end
-
-  def test_statsd_count
-    ActiveMerchant::Gateway.statsd_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-
-    StatsD.expects(:increment).with(includes('ssl_post'), 1)
-    ActiveMerchant::Gateway.new.purchase(true)
-  end
-
-  def test_statsd_count_with_name_as_lambda
-    ActiveMerchant::Gateway.statsd_count(:ssl_post, lambda {|object, args| object.class.to_s.downcase + ".insert." + args.first.to_s})
-
-    StatsD.expects(:increment).with('gatewaysubclass.insert.true', 1)
-    GatewaySubClass.new.purchase(true)
-  end
-
-  def test_statsd_count_with_method_receiving_block
-    ActiveMerchant::Base.statsd_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
-
-    return_value = ActiveMerchant::Base.new.post_with_block {'block called'}
-
-    assert_equal 'block called', return_value
-  end
-
-  def test_statsd_measure_with_nested_modules
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
-
-    StatsD.stubs(:mode).returns(:production)
-    UDPSocket.any_instance.expects(:send).with(regexp_matches(/ActiveMerchant\.Gateway\.ssl_post:\d\.\d{2,}\|ms/), 0, 'localhost', 123).at_least(1)
-
-    ActiveMerchant::UniqueGateway.new.purchase(true)
-  end
-
-  def test_statsd_measure
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 0.3
-
-    StatsD.expects(:write).with('ActiveMerchant.Gateway.ssl_post', is_a(Float), :ms, 0.3).returns({:success => true})
-    ActiveMerchant::UniqueGateway.new.purchase(true)
-  end
-
-
-  def test_statsd_measure_with_method_receiving_block
-    ActiveMerchant::Base.statsd_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
-
-    return_value = ActiveMerchant::Base.new.post_with_block {'block called'}
-
-    assert_equal 'block called', return_value
-  end
-
-  def test_instrumenting_class_method
-    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
-
-    StatsD.expects(:increment).with(includes('sync'), 1)
-    ActiveMerchant::Gateway.sync
-  end
-
-  def test_count_with_sampling
-    StatsD.unstub(:increment)
-    StatsD.stubs(:rand).returns(0.6)
-    StatsD.logger.expects(:info).never
-
-    StatsD.increment('sampling.foo.bar', 1, 0.1)
-  end
-
-  def test_count_with_successful_sample
-    StatsD.unstub(:increment)
-    StatsD.stubs(:rand).returns(0.01)
-    StatsD.logger.expects(:info).once.with do |string|
-      string.include?('@0.1')
-    end
-
-    StatsD.increment('sampling.foo.bar', 1, 0.1)
-  end
-
-  def test_production_mode_should_use_udp_socket
-    StatsD.unstub(:increment)
-
-    StatsD.mode = :production
-    StatsD.server = 'localhost:123'
-    UDPSocket.any_instance.expects(:send)
-
-    StatsD.increment('fooz')
-    StatsD.mode = :test
-  end
-
-  def test_write_supports_gauge_syntax
-    StatsD.unstub(:gauge)
-
-    StatsD.mode = :production
-    StatsD.server = 'localhost:123'
-
-    UDPSocket.any_instance.expects(:send).with('fooy:42|g', 0, 'localhost', 123)
-
-    StatsD.gauge('fooy', 42)
-  end
-
-  def test_write_supports_statsite_gauge_syntax
-    StatsD.unstub(:gauge)
-
-    StatsD.mode = :production
-    StatsD.server = 'localhost:123'
-    StatsD.implementation = :statsite
-
-    UDPSocket.any_instance.expects(:send).with("fooy:42|kv\n", 0, 'localhost', 123)
-
-    StatsD.gauge('fooy', 42)
-  end
-
-  def test_write_supports_statsite_gauge_timestamp
-    StatsD.unstub(:gauge)
-
-    StatsD.mode = :production
-    StatsD.server = 'localhost:123'
-    StatsD.implementation = :statsite
-
-    UDPSocket.any_instance.expects(:send).with("fooy:42|kv|@123456\n", 0, 'localhost', 123)
-
-    StatsD.gauge('fooy', 42, 123456)
-  end
-
-  def test_should_not_write_when_disabled
-    StatsD.enabled = false
-    StatsD.expects(:logger).never
-    StatsD.increment('fooz')
-    StatsD.enabled = true
-  end
-
-  def test_statsd_mode
-    StatsD.unstub(:increment)
-    StatsD.logger.expects(:info).once
-    StatsD.expects(:socket_wrapper).twice
-    StatsD.mode = :foo
-    StatsD.increment('foo')
-    StatsD.mode = :production
-    StatsD.increment('foo')
-    StatsD.mode = 'production'
-    StatsD.increment('foo')
-  end
-
-  def test_statsd_prefix
-    StatsD.unstub(:increment)
-    StatsD.prefix = 'my_app'
-    StatsD.logger.expects(:info).once.with do |string|
-      string.include?('my_app.foo')
-    end
-    StatsD.logger.expects(:info).once.with do |string|
-      string.include?('food')
-    end
-    StatsD.increment('foo')
-    StatsD.prefix = nil
-    StatsD.increment('food')
-  end
-
-  def test_statsd_measure_with_explicit_value
-    StatsD.expects(:write).with('values.foobar', 42, :ms, is_a(Numeric))
-
-    StatsD.measure('values.foobar', 42)
-  end
-
-  def test_statsd_measure_with_explicit_value_and_sample_rate
-    StatsD.expects(:write).with('values.foobar', 42, :ms, 0.1)
-
-    StatsD.measure('values.foobar', 42, 0.1)
-  end
-
-  def test_statsd_gauge
-    StatsD.expects(:write).with('values.foobar', 12, :g, 1)
-
-    StatsD.default_sample_rate = 1
-
-    StatsD.gauge('values.foobar', 12)
-  end
-
-  def test_socket_error_should_not_raise
-    StatsD.mode = :production
-    UDPSocket.any_instance.expects(:send).raises(SocketError)
-    StatsD.measure('values.foobar', 42)
-    StatsD.mode = :test
-  end
-
-  def test_timeout_error_should_not_raise
-    StatsD.mode = :production
-    UDPSocket.any_instance.expects(:send).raises(Timeout::Error)
-    StatsD.measure('values.foobar', 42)
-    StatsD.mode = :test
-  end
-
-  def test_system_call_error_should_not_raise
-    StatsD.mode = :production
-    UDPSocket.any_instance.expects(:send).raises(Errno::ETIMEDOUT)
-    StatsD.measure('values.foobar', 42)
-    StatsD.mode = :test
-  end
-
-  def test_io_error_should_not_raise
-    StatsD.mode = :production
-    UDPSocket.any_instance.expects(:send).raises(IOError)
-    StatsD.measure('values.foobar', 42)
-    StatsD.mode = :test
-  end
-
-  def test_long_request_should_timeout
-    StatsD.mode = :production
-    UDPSocket.any_instance.expects(:send).yields do
-      begin
-        Timeout.timeout(0.5) { sleep 1 }
-      rescue Timeout::Error
-        raise "Allowed long running request"
-      end
-    end
-    StatsD.measure('values.foobar', 42)
-    StatsD.mode = :test
-  end
-end