qubole-statsd-instrument 2.1.4

data/test/statsd_instrumentation_test.rb

@@ -0,0 +1,328 @@
+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
+
+class InstrumentedClass
+  extend StatsD::Instrument
+
+  def public_and_instrumented
+  end
+  statsd_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
+
+  protected
+
+  def protected_and_instrumented
+  end
+  statsd_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
+
+  private
+
+  def private_and_instrumented
+  end
+  statsd_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
+end
+
+ActiveMerchant::Base.extend StatsD::Instrument
+
+class StatsDInstrumentationTest < Minitest::Test
+  include StatsD::Instrument::Assertions
+
+  def test_statsd_count_if
+    ActiveMerchant::Gateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
+
+    assert_statsd_increment('ActiveMerchant.Gateway.if') do
+      ActiveMerchant::Gateway.new.purchase(true)
+      ActiveMerchant::Gateway.new.purchase(false)
+    end
+  ensure
+    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
+
+    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
+  ensure
+    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
+
+    assert_statsd_increment('ActiveMerchant.Gateway.block', times: 1) do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+      ActiveMerchant::UniqueGateway.new.purchase(false)
+    end
+  ensure
+    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
+
+    assert_statsd_increment('ActiveMerchant.Gateway.success', sample_rate: 0.5, times: 1) do
+      ActiveMerchant::Gateway.new.purchase(true)
+      ActiveMerchant::Gateway.new.purchase(false)
+    end
+
+    assert_statsd_increment('ActiveMerchant.Gateway.failure', sample_rate: 0.5, times: 1) do
+      ActiveMerchant::Gateway.new.purchase(false)
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
+  ensure
+    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
+
+    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
+  ensure
+    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
+
+    assert_statsd_increment('ActiveMerchant.Gateway.success') do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
+
+    assert_statsd_increment('ActiveMerchant.Gateway.failure') do
+      ActiveMerchant::UniqueGateway.new.purchase(false)
+    end
+  ensure
+    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'
+
+    assert_statsd_increment('ActiveMerchant.Gateway.ssl_post') do
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
+  ensure
+    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)
+
+    assert_statsd_increment('gatewaysubclass.insert.true') do
+      GatewaySubClass.new.purchase(true)
+    end
+  ensure
+    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'
+
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    end
+  ensure
+    ActiveMerchant::Base.statsd_remove_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
+  end
+
+  def test_statsd_measure
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
+
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3) do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
+  ensure
+    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+  end
+
+  def test_statsd_measure_uses_normalized_metric_name
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post') do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
+  ensure
+    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+  end
+
+  def test_statsd_measure_yells_without_block
+    err = assert_raises(ArgumentError) do
+      assert_statsd_measure('ActiveMerchant.Gateway.ssl_post')
+    end
+    assert_equal "block must be given", err.to_s
+  end
+
+  def test_statsd_measure_with_method_receiving_block
+    ActiveMerchant::Base.statsd_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
+
+    assert_statsd_measure('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    end
+  ensure
+    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'
+
+    assert_statsd_increment('ActiveMerchant.Gateway.sync') do
+      ActiveMerchant::Gateway.sync
+    end
+  ensure
+    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: { key: 'value' }
+
+    assert_statsd_increment('ActiveMerchant.Gateway.sync', tags: ['key:value']) do
+      ActiveMerchant::Gateway.sync
+    end
+  ensure
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+  end
+
+  def test_statsd_doesnt_change_method_scope_of_public_method
+    assert_scope InstrumentedClass, :public_and_instrumented, :public
+
+    assert_statsd_increment('InstrumentedClass.public_and_instrumented') do
+      InstrumentedClass.new.send(:public_and_instrumented)
+    end
+  end
+
+  def test_statsd_doesnt_change_method_scope_of_protected_method
+    assert_scope InstrumentedClass, :protected_and_instrumented, :protected
+
+    assert_statsd_increment('InstrumentedClass.protected_and_instrumented') do
+      InstrumentedClass.new.send(:protected_and_instrumented)
+    end
+  end
+
+  def test_statsd_doesnt_change_method_scope_of_private_method
+    assert_scope InstrumentedClass, :private_and_instrumented, :private
+
+    assert_statsd_increment('InstrumentedClass.private_and_instrumented') do
+      InstrumentedClass.new.send(:private_and_instrumented)
+    end
+  end
+
+  def test_statsd_doesnt_change_method_scope_on_removal_of_public_method
+    assert_scope InstrumentedClass, :public_and_instrumented, :public
+    InstrumentedClass.statsd_remove_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
+    assert_scope InstrumentedClass, :public_and_instrumented, :public
+
+    InstrumentedClass.statsd_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
+  end
+
+  def test_statsd_doesnt_change_method_scope_on_removal_of_protected_method
+    assert_scope InstrumentedClass, :protected_and_instrumented, :protected
+    InstrumentedClass.statsd_remove_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
+    assert_scope InstrumentedClass, :protected_and_instrumented, :protected
+
+    InstrumentedClass.statsd_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
+  end
+
+  def test_statsd_doesnt_change_method_scope_on_removal_of_private_method
+    assert_scope InstrumentedClass, :private_and_instrumented, :private
+    InstrumentedClass.statsd_remove_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
+    assert_scope InstrumentedClass, :private_and_instrumented, :private
+
+    InstrumentedClass.statsd_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
+  end
+
+  def test_statsd_works_with_prepended_modules
+    mod = Module.new do
+      define_method(:foo) { super() }
+    end
+    klass = Class.new do
+      prepend mod
+      extend StatsD::Instrument
+      define_method(:foo) {}
+      statsd_count :foo, "foo"
+    end
+
+    assert_statsd_increment("foo") do
+      klass.new.foo
+    end
+  end
+
+  private
+
+  def assert_scope(klass, method, expected_scope)
+    method_scope = case
+    when klass.private_method_defined?(method)
+      :private
+    when klass.protected_method_defined?(method)
+      :protected
+    else
+      :public
+    end
+
+    assert_equal method_scope, expected_scope, "Expected method to be #{expected_scope}"
+  end
+end

data/test/statsd_test.rb

@@ -0,0 +1,136 @@
+require 'test_helper'
+
+class StatsDTest < Minitest::Test
+  include StatsD::Instrument::Assertions
+
+  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
+    result = nil
+    metric = capture_statsd_call { result = StatsD.measure('values.foobar', 42) }
+    assert_equal metric, result
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+    assert_equal :ms, metric.type
+  end
+
+  def test_statsd_measure_with_explicit_value_as_keyword_argument
+    result = nil
+    metric = capture_statsd_call { result = StatsD.measure('values.foobar', value: 42) }
+    assert_equal metric, result
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+    assert_equal :ms, metric.type
+  end
+
+  def test_statsd_measure_without_value_or_block
+    assert_raises(ArgumentError) { StatsD.measure('values.foobar', tags: 123) }
+  end
+
+  def test_statsd_measure_with_explicit_value_and_sample_rate
+    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_block_duration
+    StatsD::Instrument.stubs(:duration).returns(1.12)
+    metric = capture_statsd_call do
+      StatsD.measure('values.foobar') { 'foo' }
+    end
+    assert_equal 1120.0, metric.value
+  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
+    result = nil
+    metric = capture_statsd_call { result = StatsD.increment('values.foobar', 3) }
+    assert_equal metric, result
+    assert_equal :c, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 3, metric.value
+  end
+
+  def test_statsd_increment_with_hash_argument
+    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_value_as_keyword_argument
+    metric = capture_statsd_call { StatsD.increment('values.foobar', :value => 2) }
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+    assert_equal 2, metric.value
+  end
+
+  def test_statsd_increment_with_multiple_arguments
+    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
+    result = nil
+    metric = capture_statsd_call { result = StatsD.gauge('values.foobar', 12) }
+    assert_equal metric, result
+    assert_equal :g, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 12, metric.value
+  end
+
+  def test_statsd_gauge_with_keyword_argument
+    result = nil
+    metric = capture_statsd_call { result = StatsD.gauge('values.foobar', value: 13) }
+    assert_equal metric, result
+    assert_equal :g, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 13, metric.value
+  end
+
+  def test_statsd_gauge_without_value
+    assert_raises(ArgumentError) { StatsD.gauge('values.foobar', tags: 123) }
+  end
+
+  def test_statsd_set
+    result = nil
+    metric = capture_statsd_call { result = StatsD.set('values.foobar', 'unique_identifier') }
+    assert_equal metric, result
+    assert_equal :s, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 'unique_identifier', metric.value
+  end
+
+  def test_statsd_histogram
+    result = nil
+    metric = capture_statsd_call { result = StatsD.histogram('values.foobar', 42) }
+    assert_equal metric, result
+    assert_equal :h, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+  end
+
+  def test_statsd_key_value
+    result = nil
+    metric = capture_statsd_call { result = StatsD.key_value('values.foobar', 42) }
+    assert_equal metric, result
+    assert_equal :kv, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+  end
+
+  protected
+
+  def capture_statsd_call(&block)
+    metrics = capture_statsd_calls(&block)
+    assert_equal 1, metrics.length
+    metrics.first
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+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,167 @@
+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_support_tags_syntax_on_collectd
+    @backend.implementation = :collectd
+    @backend.expects(:write_packet).with("[topic=foo,bar]fooc:3|g")
+    StatsD.gauge('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
+
+  def test_synchronize_in_exit_handler_handles_thread_error_and_exits_cleanly
+    pid = fork do
+      Signal.trap('TERM') do
+        $sent_packet = false
+
+        class << @backend.socket
+          def send(command, *args)
+            $sent_packet = true if command == 'exiting:1|c'
+            command.length
+          end
+        end
+
+        StatsD.increment('exiting')
+        Process.exit!($sent_packet)
+      end
+
+      sleep 100
+    end
+
+    Process.kill('TERM', pid)
+    Process.waitpid(pid)
+
+    assert $?.success?, 'socket did not write on exit'
+  end
+
+end