statsd-instrument 1.7.2 → 2.0.0beta

data/test/assertions_test.rb

@@ -0,0 +1,126 @@
+require 'test_helper'
+
+class AssertionsTest < Minitest::Test
+
+  def setup
+    test_class = Class.new(Minitest::Test)
+    test_class.send(:include, StatsD::Instrument::Assertions)
+    @test_case = test_class.new('fake')
+  end
+
+  def test_capture_metrics_inside_block_only
+    StatsD.increment('counter')
+    metrics = @test_case.capture_statsd_calls do
+      StatsD.increment('counter')
+      StatsD.gauge('gauge', 12)
+    end
+    StatsD.gauge('gauge', 15)
+
+    assert_equal 2, metrics.length
+    assert_equal 'counter', metrics[0].name
+    assert_equal 'gauge', metrics[1].name
+    assert_equal 12, metrics[1].value
+  end
+
+  def test_assert_no_statsd_calls
+    assert_no_assertion_triggered do
+      @test_case.assert_no_statsd_calls('counter') do
+        # noop
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_no_statsd_calls('counter') do
+        StatsD.increment('other')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_no_statsd_calls('counter') do
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_no_statsd_calls do
+        StatsD.increment('other')
+      end
+    end    
+  end
+
+  def test_assert_statsd_call
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('counter')
+        StatsD.increment('other')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('other')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.gauge('counter', 42)
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('counter')
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', times: 2) do
+        StatsD.increment('counter')
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
+        StatsD.increment('counter', sample_rate: 0.5, tags: ['a', 'b'])
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
+        StatsD.increment('counter', sample_rate: 0.2, tags: ['c'])
+      end
+    end
+  end
+
+  private
+
+  def assert_no_assertion_triggered(&block)
+    block.call
+  rescue MiniTest::Assertion => assertion
+    flunk "No assertion trigger expected, but one was triggered with message #{assertion.message}."
+  else
+    pass
+  end
+
+  def assert_assertion_triggered(message = nil, &block)
+    block.call
+  rescue MiniTest::Assertion => assertion
+    if message
+      assert_equal message, assertion.message, "Assertion triggered, but message was not what was expected."
+    else
+      pass
+    end
+    assertion
+  else
+    flunk "No assertion was triggered, but one was expected."
+  end
+end

data/test/capture_backend_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class CaptureBackendTest < Minitest::Test
+  def setup
+    @backend = StatsD::Instrument::Backends::CaptureBackend.new
+    @metric1 = StatsD::Instrument::Metric::new(type: :c, name: 'mock.counter')
+    @metric2 = StatsD::Instrument::Metric::new(type: :ms, name: 'mock.measure', value: 123)
+  end
+
+  def test_collecting_metric
+    assert @backend.collected_metrics.empty?
+    @backend.collect_metric(@metric1)
+    @backend.collect_metric(@metric2)
+    assert_equal [@metric1, @metric2], @backend.collected_metrics
+  end
+
+  def test_reset
+    @backend.collect_metric(@metric1)
+    @backend.reset
+    assert @backend.collected_metrics.empty?
+    @backend.collect_metric(@metric2)
+    assert_equal [@metric2], @backend.collected_metrics
+  end
+end

data/test/environment_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class EnvironmentTest < Minitest::Test
+
+  def setup
+    ENV['STATSD_ADDR'] = nil
+    ENV['IMPLEMENTATION'] = nil
+  end
+
+  def test_uses_logger_in_development_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('development')
+    assert_instance_of StatsD::Instrument::Backends::LoggerBackend, StatsD::Instrument::Environment.default_backend
+  end
+
+  def test_uses_null_backend_in_test_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('test')
+    assert_instance_of StatsD::Instrument::Backends::NullBackend, StatsD::Instrument::Environment.default_backend
+  end
+
+  def test_uses_udp_backend_in_production_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('production')
+    assert_instance_of StatsD::Instrument::Backends::UDPBackend, StatsD::Instrument::Environment.default_backend
+  end
+
+  def test_uses_environment_variables_in_production_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('production')
+    ENV['STATSD_ADDR'] = '127.0.0.1:1234'
+    ENV['STATSD_IMPLEMENTATION'] = 'datadog'
+
+    backend = StatsD::Instrument::Environment.default_backend
+    assert_equal '127.0.0.1', backend.host
+    assert_equal 1234, backend.port
+    assert_equal :datadog, backend.implementation
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class IntegrationTest < Minitest::Test
+
+  def setup
+    @old_backend, StatsD.backend = StatsD.backend, StatsD::Instrument::Backends::UDPBackend.new("localhost:31798")
+  end
+  
+  def teardown
+    StatsD.backend = @old_backend
+  end
+
+  def test_live_local_udp_socket
+    server = UDPSocket.new
+    server.bind('localhost', 31798)
+
+    StatsD.increment('counter')
+    assert_equal "counter:1|c", server.recvfrom(100).first
+  end
+end

data/test/logger_backend_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class LoggerBackendTest < Minitest::Test
+  def setup
+    logger = Logger.new(@io = StringIO.new)
+    logger.formatter = lambda { |_,_,_, msg| "#{msg}\n" }
+    @backend = StatsD::Instrument::Backends::LoggerBackend.new(logger)
+    @metric1 = StatsD::Instrument::Metric::new(type: :c, name: 'mock.counter', tags: { a: 'b', c: 'd'})
+    @metric2 = StatsD::Instrument::Metric::new(type: :ms, name: 'mock.measure', value: 123, sample_rate: 0.3)
+  end
+
+  def test_logs_metrics
+    @backend.collect_metric(@metric1)
+    assert_equal @io.string, "[StatsD] increment mock.counter:1 #a:b #c:d\n"
+    @io.string = ""
+
+    @backend.collect_metric(@metric2)
+    assert_equal @io.string, "[StatsD] measure mock.measure:123 @0.3\n"
+  end
+end

data/test/metric_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class MetricTest < Minitest::Test
+
+  def test_required_arguments
+    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :c) }
+    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(name: 'test') }
+    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :ms, name: 'test') }
+  end
+
+  def test_default_values
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
+    assert_equal 1, m.value
+    assert_equal StatsD.default_sample_rate, m.sample_rate
+    assert m.tags.nil?
+  end
+
+  def test_name_prefix
+    StatsD.stubs(:prefix).returns('prefix')
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
+    assert_equal 'prefix.counter', m.name
+
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', no_prefix: true)
+    assert_equal 'counter', m.name
+  end
+
+  def test_rewrite_shitty_tags
+    assert_equal ['igno_red'], StatsD::Instrument::Metric.normalize_tags(['igno,red'])
+    assert_equal ['igno_red'], StatsD::Instrument::Metric.normalize_tags(['igno  red'])
+    assert_equal ['test:test_test'], StatsD::Instrument::Metric.normalize_tags(['test:test:test'])
+    assert_equal ['topic:foo_foo', 'bar_'], StatsD::Instrument::Metric.normalize_tags(['topic:foo : foo', 'bar '])
+  end
+  
+  def test_rewrite_tags_provided_as_hash
+    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(:tag => 'value')
+    assert_equal ['tag:value', 'tag2:value2'], StatsD::Instrument::Metric.normalize_tags(:tag => 'value', :tag2 => 'value2')
+  end
+end

data/test/statsd_instrumentation_test.rb

@@ -47,13 +47,16 @@ end
 
 ActiveMerchant::Base.extend StatsD::Instrument
 
-class StatsDInstrumentationTest < Test::Unit::TestCase
+class StatsDInstrumentationTest < Minitest::Test
+  include StatsD::Instrument::Assertions
+
   def test_statsd_count_if
     ActiveMerchant::Gateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.if').once
-    ActiveMerchant::Gateway.new.purchase(true)
-    ActiveMerchant::Gateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.if') do
+      ActiveMerchant::Gateway.new.purchase(true)
+      ActiveMerchant::Gateway.new.purchase(false)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
   end
@@ -63,9 +66,10 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result == 'true'
     end
 
-    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' }
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
+      assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
+    end
 
     ActiveMerchant::Base.statsd_remove_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
@@ -75,9 +79,10 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result[:success]
     end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.block').once
-    ActiveMerchant::UniqueGateway.new.purchase(true)
-    ActiveMerchant::UniqueGateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.block', times: 1) do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+      ActiveMerchant::UniqueGateway.new.purchase(false)
+    end
 
     ActiveMerchant::UniqueGateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.block'
   end
@@ -85,11 +90,15 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   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
+    assert_statsd_increment('ActiveMerchant.Gateway.success', sample_rate: 0.5, times: 1) do
+      ActiveMerchant::Gateway.new.purchase(true)
+      ActiveMerchant::Gateway.new.purchase(false)
+    end
 
-    ActiveMerchant::Gateway.new.purchase(true)
-    ActiveMerchant::Gateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.failure', sample_rate: 0.5, times: 1) do
+      ActiveMerchant::Gateway.new.purchase(false)
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
   end
@@ -99,11 +108,15 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result == 'successful'
     end
 
-    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' }
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block.success', times: 1) do
+      assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
+      assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    end
+
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block.failure', times: 1) do
+      assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
+      assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    end    
 
     ActiveMerchant::Base.statsd_remove_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
@@ -113,11 +126,13 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result[:success]
     end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
+    assert_statsd_increment('ActiveMerchant.Gateway.success') do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1)
-    ActiveMerchant::UniqueGateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.failure') do
+      ActiveMerchant::UniqueGateway.new.purchase(false)
+    end
 
     ActiveMerchant::UniqueGateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
   end
@@ -125,8 +140,9 @@ 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)
-    ActiveMerchant::Gateway.new.purchase(true)
+    assert_statsd_increment('ActiveMerchant.Gateway.ssl_post') do
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
@@ -135,8 +151,9 @@ 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)
-    GatewaySubClass.new.purchase(true)
+    assert_statsd_increment('gatewaysubclass.insert.true') do
+      GatewaySubClass.new.purchase(true)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
   end
@@ -144,35 +161,39 @@ 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(:c, 'ActiveMerchant.Base.post_with_block', 1, {})
-    assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    end
 
     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'
+  def test_statsd_measure
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
 
-    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3) do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
 
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+    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
+  def test_statsd_measure_uses_normalized_metric_name
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
 
-    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil, 0.3)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post') do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
 
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    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(:ms, 'ActiveMerchant.Base.post_with_block', is_a(Float), {})
-    assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_measure('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    end
 
     ActiveMerchant::Base.statsd_remove_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
@@ -181,18 +202,20 @@ 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)
-    ActiveMerchant::Gateway.sync
+    assert_statsd_increment('ActiveMerchant.Gateway.sync') do
+      ActiveMerchant::Gateway.sync
+    end
 
     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']
+    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync', tags: { key: 'value' }
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.sync', 1, :tags => ['t'])
-    ActiveMerchant::Gateway.sync
+    assert_statsd_increment('ActiveMerchant.Gateway.sync', tags: ['key:value']) do
+      ActiveMerchant::Gateway.sync
+    end
 
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
   end