statsd-instrument 1.7.2 → 2.0.0beta

data/test/statsd_test.rb

@@ -1,256 +1,92 @@
 require 'test_helper'
 
-class StatsDTest < Test::Unit::TestCase
+class StatsDTest < Minitest::Test
+  include StatsD::Instrument::Assertions
 
-  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)
+  def test_statsd_passed_collections_to_backend
+    StatsD.backend.expects(:collect_metric).with(instance_of(StatsD::Instrument::Metric))
+    StatsD.increment('test')
   end
 
   def test_statsd_measure_with_explicit_value
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 42, {})
-    StatsD.measure('values.foobar', 42)
+    metric = capture_statsd_call { StatsD.measure('values.foobar', 42) }
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+    assert_equal :ms, metric.type
   end
 
   def test_statsd_measure_with_explicit_value_and_sample_rate
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 42, :sample_rate => 0.1)
-    StatsD.measure('values.foobar', 42, :sample_rate => 0.1)
+    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, :sample_rate => 0.1) }
+    assert_equal 0.1, metric.sample_rate    
   end
 
-  def test_statsd_measure_with_benchmarked_value
+  def test_statsd_measure_with_benchmarked_duration
     Benchmark.stubs(:realtime).returns(1.12)
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 1120.0, {})
-    StatsD.measure('values.foobar') do
-      #noop
+    metric = capture_statsd_call do 
+      StatsD.measure('values.foobar') { 'foo' }
     end
+    assert_equal 1120.0, metric.value
   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
+  def test_statsd_measure_returns_return_value_of_block
+    return_value = StatsD.measure('values.foobar') { 'sarah' }
+    assert_equal 'sarah', return_value
+  end
+
+  def test_statsd_increment
+    metric = capture_statsd_call { StatsD.increment('values.foobar', 3) }
+    assert_equal :c, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 3, metric.value
   end
 
   def test_statsd_increment_with_hash_argument
-    StatsD.expects(:collect).with(:c, 'values.foobar', 1, :tags => ['test'])
-    StatsD.increment('values.foobar', :tags => ['test'])
+    metric = capture_statsd_call { StatsD.increment('values.foobar', :tags => ['test']) }
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+    assert_equal ['test'], metric.tags
+    assert_equal 1, metric.value
   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'])
+    metric = capture_statsd_call { StatsD.increment('values.foobar', 12, nil, ['test']) }
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+    assert_equal ['test'], metric.tags
+    assert_equal 12, metric.value
   end
 
   def test_statsd_gauge
-    StatsD.expects(:collect).with(:g, 'values.foobar', 12, {})
-    StatsD.gauge('values.foobar', 12)
+    metric = capture_statsd_call { StatsD.gauge('values.foobar', 12) }
+    assert_equal :g, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 12, metric.value
   end
 
   def test_statsd_set
-    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(: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)
-    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)
+    metric = capture_statsd_call { StatsD.set('values.foobar', 'unique_identifier') }
+    assert_equal :s, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 'unique_identifier', metric.value
   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)
+  def test_statsd_histogram
+    metric = capture_statsd_call { StatsD.histogram('values.foobar', 42) }
+    assert_equal :h, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
   end
 
-  def test_supports_set_syntax
-    StatsD.expects(:write_packet).with('unique:10.0.0.10|s')
-    StatsD.set('unique', '10.0.0.10')
-
-    StatsD.expects(:write_packet).with('unique:10.0.0.10|s|@0.01')
-    StatsD.set('unique', '10.0.0.10', 0.01)
+  def test_statsd_key_value
+    metric = capture_statsd_call { StatsD.key_value('values.foobar', 42) }
+    assert_equal :kv, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
   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.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'])
-
-    assert_equal ['tag:value'], StatsD.send(:clean_tags, { :tag => 'value' })
-    assert_equal Set['tag:value', 'tag2:value2'], Set.new(StatsD.send(:clean_tags, { :tag => 'value', :tag2 => 'value2' }))
-
-    StatsD.expects(:write_packet).with("fooc:3|c|#topic:foo_foo,bar_")
-    StatsD.increment('fooc', 3, 1.0, ['topic:foo : foo', 'bar '])
-
-    StatsD.expects(:write_packet).with("foot:1|c|#foo:bar")
-    StatsD.increment('foot', :tags => { :foo => 'bar' })
-  end
-
-  def test_supports_key_value_syntax_on_statsite
-    StatsD.stubs(:implementation).returns(:statsite)
-
-    StatsD.expects(:write_packet).with("fooy:42|kv\n")
-    StatsD.key_value('fooy', 42)
-  end
-
-  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.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
-    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)
+  protected
 
-    StatsD.increment('counter')
-    assert_equal "counter:1|c", server.recvfrom(100).first
+  def capture_statsd_call(&block)
+    metrics = capture_statsd_calls(&block)
+    assert_equal 1, metrics.length
+    metrics.first
   end
 end

data/test/test_helper.rb

@@ -1,8 +1,10 @@
-require 'rubygems'
-require 'statsd-instrument'
-require 'test/unit'
+ENV['ENV'] = 'test'
+
+require 'minitest/autorun'
+require 'minitest/pride'
 require 'mocha/setup'
 require 'set'
 require 'logger'
+require 'statsd-instrument'
 
 StatsD.logger = Logger.new('/dev/null')

data/test/udp_backend_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+class UDPBackendTest < Minitest::Test
+  def setup
+    StatsD.stubs(:backend).returns(@backend = StatsD::Instrument::Backends::UDPBackend.new)
+    @backend.stubs(:rand).returns(0.0)
+
+    UDPSocket.stubs(:new).returns(@socket = mock('socket'))
+    @socket.stubs(:connect)
+    @socket.stubs(:send).returns(1)
+
+    StatsD.stubs(:logger).returns(@logger = mock('logger'))
+  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
+
+    @backend.server = "localhost:1234"
+    @backend.socket
+    
+    @backend.port = 2345
+    @backend.socket
+
+    @backend.host = '127.0.0.1'
+    @backend.socket
+  end  
+
+  def test_collect_respects_sampling_rate
+    @socket.expects(:send).once.returns(1)
+    metric = StatsD::Instrument::Metric.new(type: :c, name: 'test', sample_rate: 0.5)
+
+    @backend.stubs(:rand).returns(0.4)
+    @backend.collect_metric(metric)
+
+    @backend.stubs(:rand).returns(0.6)
+    @backend.collect_metric(metric)    
+  end
+
+  def test_support_counter_syntax
+    @backend.expects(:write_packet).with('counter:1|c').once
+    StatsD.increment('counter', sample_rate: 1.0)
+    
+    @backend.expects(:write_packet).with('counter:1|c|@0.5').once
+    StatsD.increment('counter', sample_rate: 0.5)
+  end
+
+  def test_supports_gauge_syntax
+    @backend.expects(:write_packet).with('fooy:1.23|g')
+    StatsD.gauge('fooy', 1.23)
+
+    @backend.expects(:write_packet).with('fooy:42|g|@0.01')
+    StatsD.gauge('fooy', 42, sample_rate: 0.01)
+  end
+
+  def test_supports_set_syntax
+    @backend.expects(:write_packet).with('unique:10.0.0.10|s')
+    StatsD.set('unique', '10.0.0.10')
+
+    @backend.expects(:write_packet).with('unique:10.0.0.10|s|@0.01')
+    StatsD.set('unique', '10.0.0.10', sample_rate: 0.01)
+  end
+
+  def test_support_measure_syntax
+    @backend.expects(:write_packet).with('duration:1.23|ms')
+    StatsD.measure('duration', 1.23)
+
+    @backend.expects(:write_packet).with('duration:0.42|ms|@0.01')
+    StatsD.measure('duration', 0.42, sample_rate: 0.01)
+  end
+
+  def test_histogram_syntax_on_datadog
+    @backend.implementation = :datadog
+    @backend.expects(:write_packet).with('fooh:42.4|h')
+    StatsD.histogram('fooh', 42.4)
+  end
+
+  def test_histogram_warns_if_not_using_datadog
+    @backend.implementation = :other
+    @backend.expects(:write_packet).never
+    @logger.expects(:warn)
+    StatsD.histogram('fooh', 42.4)
+  end
+
+  def test_supports_key_value_syntax_on_statsite
+    @backend.implementation = :statsite
+    @backend.expects(:write_packet).with("fooy:42|kv\n")
+    StatsD.key_value('fooy', 42)
+  end
+
+  def test_supports_key_value_with_timestamp_on_statsite
+    @backend.implementation = :statsite
+    @backend.expects(:write_packet).with("fooy:42|kv|@123456\n")
+    StatsD.key_value('fooy', 42, 123456)
+  end
+
+  def test_warn_when_using_key_value_and_not_on_statsite
+    @backend.implementation = :other
+    @backend.expects(:write_packet).never
+    @logger.expects(:warn)
+    StatsD.key_value('fookv', 3.33)
+  end  
+
+  def test_support_tags_syntax_on_datadog
+    @backend.implementation = :datadog
+    @backend.expects(:write_packet).with("fooc:3|c|#topic:foo,bar")
+    StatsD.increment('fooc', 3, tags: ['topic:foo', 'bar'])
+  end
+
+  def test_warn_when_using_tags_and_not_on_datadog
+    @backend.implementation = :other
+    @backend.expects(:write_packet).with("fooc:1|c")
+    @logger.expects(:warn)
+    StatsD.increment('fooc', tags: ['ignored'])
+  end
+
+  def test_socket_error_should_not_raise_but_log
+    @socket.stubs(:connect).raises(SocketError)    
+    @logger.expects(:error)
+    StatsD.increment('fail')
+  end
+
+  def test_system_call_error_should_not_raise_but_log
+    @socket.stubs(:send).raises(Errno::ETIMEDOUT)
+    @logger.expects(:error)
+    StatsD.increment('fail')
+  end
+
+  def test_io_error_should_not_raise_but_log
+    @socket.stubs(:send).raises(IOError)
+    @logger.expects(:error)
+    StatsD.increment('fail')
+  end
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 1.7.2
-  prerelease: 
+  version: 2.0.0beta
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,38 +9,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-28 00:00:00.000000000 Z
+date: 2014-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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 appspec. Provides metaprogramming methods to
@@ -60,37 +69,59 @@ files:
 - Rakefile
 - lib/statsd-instrument.rb
 - lib/statsd/instrument.rb
+- lib/statsd/instrument/assertions.rb
+- lib/statsd/instrument/backend.rb
+- lib/statsd/instrument/backends/capture_backend.rb
+- lib/statsd/instrument/backends/logger_backend.rb
+- lib/statsd/instrument/backends/null_backend.rb
+- lib/statsd/instrument/backends/udp_backend.rb
+- lib/statsd/instrument/environment.rb
+- lib/statsd/instrument/metric.rb
 - lib/statsd/instrument/version.rb
 - statsd-instrument.gemspec
+- test/assertions_test.rb
+- test/capture_backend_test.rb
+- test/environment_test.rb
+- test/integration_test.rb
+- test/logger_backend_test.rb
+- test/metric_test.rb
 - test/statsd_instrumentation_test.rb
 - test/statsd_test.rb
 - test/test_helper.rb
+- test/udp_backend_test.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'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A StatsD client for Ruby apps
 test_files:
+- test/assertions_test.rb
+- test/capture_backend_test.rb
+- test/environment_test.rb
+- test/integration_test.rb
+- test/logger_backend_test.rb
+- test/metric_test.rb
 - test/statsd_instrumentation_test.rb
 - test/statsd_test.rb
 - test/test_helper.rb
+- test/udp_backend_test.rb
+has_rdoc: