statsd-instrument 2.3.2 → 2.4.0

data/test/matchers_test.rb

@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'statsd/instrument/matchers'
 
 class MatchersTest < Minitest::Test
   def test_statsd_increment_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {}).matches? lambda { StatsD.increment('counter') }
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
+      .matches?(lambda { StatsD.increment('counter') })
   end
 
   def test_statsd_increment_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {}).matches? lambda { StatsD.increment('not_counter') }
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
+      .matches?(lambda { StatsD.increment('not_counter') })
   end
 
   def test_statsd_increment_compound_matched
@@ -31,72 +35,82 @@ class MatchersTest < Minitest::Test
   end
 
   def test_statsd_increment_with_times_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1).matches? lambda { StatsD.increment('counter') }
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1)
+      .matches?(lambda { StatsD.increment('counter') })
   end
 
   def test_statsd_increment_with_times_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2).matches? lambda { StatsD.increment('counter', times: 3) }
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2)
+      .matches?(lambda { StatsD.increment('counter', times: 3) })
   end
 
   def test_statsd_increment_with_sample_rate_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5).matches? lambda { StatsD.increment('counter', sample_rate: 0.5) }
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) })
   end
 
   def test_statsd_increment_with_sample_rate_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5).matches? lambda { StatsD.increment('counter', sample_rate: 0.7) }
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) })
   end
 
   def test_statsd_increment_with_value_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches? lambda { StatsD.increment('counter') }
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1)
+      .matches?(lambda { StatsD.increment('counter') })
   end
 
   def test_statsd_increment_with_value_matched_when_multiple_metrics
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches? lambda {
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
       StatsD.increment('counter', value: 2)
       StatsD.increment('counter', value: 1)
-    }
+    })
   end
 
   def test_statsd_increment_with_value_not_matched_when_multiple_metrics
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches? lambda {
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
       StatsD.increment('counter', value: 2)
       StatsD.increment('counter', value: 3)
-    }
+    })
   end
 
   def test_statsd_increment_with_value_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3).matches? lambda { StatsD.increment('counter') }
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3)
+      .matches?(lambda { StatsD.increment('counter') })
   end
 
   def test_statsd_increment_with_tags_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b']).matches? lambda { StatsD.increment('counter', tags: ['a', 'b']) }
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
+      .matches?(lambda { StatsD.increment('counter', tags: ['a', 'b']) })
   end
 
   def test_statsd_increment_with_tags_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b']).matches? lambda { StatsD.increment('counter', tags: ['c']) }
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
+      .matches?(lambda { StatsD.increment('counter', tags: ['c']) })
   end
 
   def test_statsd_increment_with_times_and_value_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches? lambda {
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
       StatsD.increment('counter', value: 1)
       StatsD.increment('counter', value: 1)
-    }
+    })
   end
 
   def test_statsd_increment_with_times_and_value_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches? lambda {
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
       StatsD.increment('counter', value: 1)
       StatsD.increment('counter', value: 2)
-    }
+    })
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher).matches? lambda { StatsD.increment('counter', sample_rate: 0.5) }
+    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) })
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_not_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher).matches? lambda { StatsD.increment('counter', sample_rate: 0.7) }
+    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) })
   end
 end

data/test/metric_test.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 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') }
@@ -41,11 +42,21 @@ class MetricTest < Minitest::Test
 
   def test_handle_bad_tags
     assert_equal ['ignored'], StatsD::Instrument::Metric.normalize_tags(['igno|red'])
-    assert_equal ['lol::class:omg::lol'], StatsD::Instrument::Metric.normalize_tags({ :"lol::class" => "omg::lol" })
+    assert_equal ['lol::class:omg::lol'], StatsD::Instrument::Metric.normalize_tags("lol::class" => "omg::lol")
   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')
+    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(tag: 'value')
+    assert_equal ['tag1:v1', 'tag2:v2'], StatsD::Instrument::Metric.normalize_tags(tag1: 'v1', tag2: 'v2')
+  end
+
+  def test_default_tags
+    StatsD.stubs(:default_tags).returns(['default_tag:default_value'])
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', tags: { tag: 'value' })
+    assert_equal ['tag:value', 'default_tag:default_value'], m.tags
+
+    StatsD.stubs(:default_tags).returns(['tag:value'])
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', tags: { tag: 'value' })
+    assert_equal ['tag:value', 'tag:value'], m.tags # we don't care about duplicates
   end
 end

data/test/statsd_instrumentation_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module ActiveMerchant; end
@@ -11,7 +13,7 @@ class ActiveMerchant::Base
   end
 
   def post_with_block(&block)
-    yield if block_given?
+    block.call if block_given?
   end
 end
 
@@ -34,7 +36,7 @@ end
 
 class ActiveMerchant::UniqueGateway < ActiveMerchant::Base
   def ssl_post(arg)
-    {:success => arg}
+    { success: arg }
   end
 
   def purchase(arg)
@@ -87,7 +89,7 @@ class StatsDInstrumentationTest < Minitest::Test
     end
 
     assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
-      assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
+      assert_equal 'true', ActiveMerchant::Base.new.post_with_block { 'true' }
       assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
     end
   ensure
@@ -265,7 +267,6 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
 
-
   def test_statsd_distribution
     ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
 
@@ -412,10 +413,9 @@ class StatsDInstrumentationTest < Minitest::Test
   private
 
   def assert_scope(klass, method, expected_scope)
-    method_scope = case
-    when klass.private_method_defined?(method)
+    method_scope = if klass.private_method_defined?(method)
       :private
-    when klass.protected_method_defined?(method)
+    elsif klass.protected_method_defined?(method)
       :protected
     else
       :public

data/test/statsd_test.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class StatsDTest < Minitest::Test
   include StatsD::Instrument::Assertions
 
+  def teardown
+    StatsD.default_tags = nil
+  end
+
   def test_statsd_passed_collections_to_backend
     StatsD.backend.expects(:collect_metric).with(instance_of(StatsD::Instrument::Metric))
     StatsD.increment('test')
@@ -18,7 +24,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_measure_with_explicit_value_and_distribution_override
-    metric = capture_statsd_call { result = StatsD.measure('values.foobar', 42, as_dist: true) }
+    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, as_dist: true) }
     assert_equal :d, metric.type
   end
 
@@ -32,7 +38,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_measure_with_explicit_value_keyword_and_distribution_override
-    metric = capture_statsd_call { result = StatsD.measure('values.foobar', value: 42, as_dist: true) }
+    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42, as_dist: true) }
     assert_equal :d, metric.type
   end
 
@@ -41,12 +47,12 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_measure_with_explicit_value_and_sample_rate
-    metric = capture_statsd_call { 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_block_duration
-    StatsD::Instrument.stubs(:duration).returns(1.12)
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
       StatsD.measure('values.foobar') { 'foo' }
     end
@@ -65,11 +71,44 @@ class StatsDTest < Minitest::Test
     assert_equal 'sarah', return_value
   end
 
-  def test_statsd_measure_returns_return_value_of_block_even_if_nil
+  def test_statsd_measure_as_distribution_returns_return_value_of_block_even_if_nil
     return_value = StatsD.measure('values.foobar', as_dist: true) { nil }
     assert_nil return_value
   end
 
+  def test_statsd_measure_with_return_in_block_still_captures
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 6.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.measure('values.foobar') { return 'from lambda' }
+      end
+
+      result = lambda.call
+    end
+
+    assert_equal 'from lambda', result
+    assert_equal 1120.0, metric.value
+  end
+
+  def test_statsd_measure_with_exception_in_block_still_captures
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 6.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.measure('values.foobar') { raise 'from lambda' }
+      end
+
+      begin
+        result = lambda.call
+      rescue # rubocop:disable Lint/HandleExceptions:
+      end
+    end
+
+    assert_nil result
+    assert_equal 1120.0, metric.value
+  end
+
   def test_statsd_increment
     result = nil
     metric = capture_statsd_call { result = StatsD.increment('values.foobar', 3) }
@@ -80,14 +119,14 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_increment_with_hash_argument
-    metric = capture_statsd_call { 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_value_as_keyword_argument
-    metric = capture_statsd_call { StatsD.increment('values.foobar', :value => 2) }
+    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
@@ -149,7 +188,7 @@ class StatsDTest < Minitest::Test
   end
 
   def test_statsd_distribution_with_benchmarked_block_duration
-    StatsD::Instrument.stubs(:duration).returns(1.12)
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
       StatsD.distribution('values.foobar') { 'foo' }
     end
@@ -157,10 +196,45 @@ class StatsDTest < Minitest::Test
     assert_equal 1120.0, metric.value
   end
 
+  def test_statsd_distribution_with_return_in_block_still_captures
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 5.0 + 1.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.distribution('values.foobar') { return 'from lambda' }
+      end
+
+      result = lambda.call
+    end
+
+    assert_equal 'from lambda', result
+    assert_equal :d, metric.type
+    assert_equal 1120.0, metric.value
+  end
+
+  def test_statsd_distribution_with_exception_in_block_still_captures
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 5.0 + 1.12)
+    result = nil
+    metric = capture_statsd_call do
+      lambda = -> do
+        StatsD.distribution('values.foobar') { raise 'from lambda' }
+      end
+
+      begin
+        result = lambda.call
+      rescue # rubocop:disable Lint/HandleExceptions
+      end
+    end
+
+    assert_nil result
+    assert_equal :d, metric.type
+    assert_equal 1120.0, metric.value
+  end
+
   def test_statsd_distribution_with_block_and_options
-    StatsD::Instrument.stubs(:duration).returns(1.12)
+    StatsD::Instrument.stubs(:current_timestamp).returns(5.0, 5.0 + 1.12)
     metric = capture_statsd_call do
-      StatsD.distribution('values.foobar', :tags => ['test'], :sample_rate => 0.9) { 'foo' }
+      StatsD.distribution('values.foobar', tags: ['test'], sample_rate: 0.9) { 'foo' }
     end
     assert_equal 1120.0, metric.value
     assert_equal 'values.foobar', metric.name
@@ -187,6 +261,22 @@ class StatsDTest < Minitest::Test
     assert_equal 42, metric.value
   end
 
+  def test_statsd_durarion_returns_time_in_seconds
+    duration = StatsD::Instrument.duration {}
+    assert_kind_of Float, duration
+  end
+
+  def test_statsd_durarion_does_not_swallow_exceptions
+    assert_raises(RuntimeError) do
+      StatsD::Instrument.duration { raise "Foo" }
+    end
+  end
+
+  def test_statsd_default_tags_get_normalized
+    StatsD.default_tags = { first_tag: 'first_value', second_tag: 'second_value' }
+    assert_equal ['first_tag:first_value', 'second_tag:second_value'], StatsD.default_tags
+  end
+
   protected
 
   def capture_statsd_call(&block)

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ENV['ENV'] = 'test'
 
 require 'minitest/autorun'

data/test/udp_backend_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class UDPBackendTest < Minitest::Test
@@ -76,7 +78,7 @@ class UDPBackendTest < Minitest::Test
     StatsD.histogram('fooh', 42.4)
   end
 
-   def test_distribution_syntax_on_datadog
+  def test_distribution_syntax_on_datadog
     @backend.implementation = :datadog
     @backend.expects(:write_packet).with('fooh:42.4|d')
     StatsD.distribution('fooh', 42.4)
@@ -90,8 +92,8 @@ class UDPBackendTest < Minitest::Test
 
   def test_event_on_datadog_escapes_newlines
     @backend.implementation = :datadog
-    @backend.expects(:write_packet).with('_e{8,5}:fooh\\n\\n|baz\\n')
-    StatsD.event('fooh\n\n', 'baz\n')
+    @backend.expects(:write_packet).with("_e{8,5}:fooh\\n\\n|baz\\n")
+    StatsD.event("fooh\n\n", "baz\n")
   end
 
   def test_event_on_datadog_ignores_invalid_metadata
@@ -183,31 +185,6 @@ class UDPBackendTest < Minitest::Test
     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
-
   def test_socket_error_should_invalidate_socket
     seq = sequence('fail_then_succeed')
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-28 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -82,6 +82,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -104,9 +118,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/CODEOWNERS"
 - ".github/probots.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
+- ".rubocop-https---shopify-github-io-ruby-style-guide-rubocop-yml"
+- ".rubocop.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -131,6 +148,7 @@ files:
 - shipit.rubygems.yml
 - statsd-instrument.gemspec
 - test/assertions_test.rb
+- test/benchmark/default_tags.rb
 - test/benchmark/metrics.rb
 - test/benchmark/tags.rb
 - test/capture_backend_test.rb
@@ -163,13 +181,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A StatsD client for Ruby apps
 test_files:
 - test/assertions_test.rb
+- test/benchmark/default_tags.rb
 - test/benchmark/metrics.rb
 - test/benchmark/tags.rb
 - test/capture_backend_test.rb

data/.travis.yml

@@ -1,12 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.10
-  - 2.2.6
-  - 2.3.3
-  - ruby-head
-
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-
-sudo: false