statsd-instrument 2.3.2 → 2.4.0

data/lib/statsd/instrument/railtie.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 # This Railtie runs some initializers that will set the logger to <tt>Rails#logger</tt>,
 # and will initialize the {StatsD#backend} based on the Rails environment.
 #
 # @see StatsD::Instrument::Environment
 class StatsD::Instrument::Railtie < Rails::Railtie
-
   initializer 'statsd-instrument.use_rails_logger' do
     ::StatsD.logger = Rails.logger
   end

data/lib/statsd/instrument/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module StatsD
   module Instrument
-    VERSION = "2.3.2"
+    VERSION = "2.4.0"
   end
 end

data/lib/statsd/instrument.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'socket'
 require 'logger'
 
@@ -28,6 +30,10 @@ require 'logger'
 #   The logger to use in case of any errors. The logger is also used as default logger
 #   for the LoggerBackend (although this can be overwritten).
 #
+# @!attribute default_tags
+#   The tags to apply to all metrics.
+#   @return [Array<String>, Hash<String, String>, nil] The default tags, or <tt>nil</tt> when no default tags is used
+#
 #   @see StatsD::Instrument::Backends::LoggerBackend
 #   @return [Logger]
 #
@@ -58,20 +64,26 @@ module StatsD
 
     if Process.respond_to?(:clock_gettime)
       # @private
-      def self.duration
-        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        yield
-        Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      def self.current_timestamp
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
     else
       # @private
-      def self.duration
-        start = Time.now
-        yield
-        Time.now - start
+      def self.current_timestamp
+        Time.now
       end
     end
 
+    # Even though this method is considered private, and is no longer used internally,
+    # applications in the wild rely on it. As a result, we cannot remove this method
+    # until the next major version.
+    # @private
+    def self.duration
+      start = current_timestamp
+      yield
+      current_timestamp - start
+    end
+
     # Adds execution duration instrumentation to a method as a timing.
     #
     # @param method [Symbol] The name of the method to instrument.
@@ -82,7 +94,8 @@ module StatsD
     def statsd_measure(method, name, *metric_options)
       add_to_method(method, name, :measure) do
         define_method(method) do |*args, &block|
-          StatsD.measure(StatsD::Instrument.generate_metric_name(name, self, *args), *metric_options) { super(*args, &block) }
+          metric_name = StatsD::Instrument.generate_metric_name(name, self, *args)
+          StatsD.measure(metric_name, *metric_options) { super(*args, &block) }
         end
       end
     end
@@ -98,7 +111,8 @@ module StatsD
     def statsd_distribution(method, name, *metric_options)
       add_to_method(method, name, :distribution) do
         define_method(method) do |*args, &block|
-          StatsD.distribution(StatsD::Instrument.generate_metric_name(name, self, *args), *metric_options) { super(*args, &block) }
+          metric_name = StatsD::Instrument.generate_metric_name(name, self, *args)
+          StatsD.distribution(metric_name, *metric_options) { super(*args, &block) }
         end
       end
     end
@@ -127,20 +141,27 @@ module StatsD
             truthiness = false
             raise
           else
-            truthiness = (yield(result) rescue false) if block_given?
+            if block_given?
+              begin
+                truthiness = yield(result)
+              rescue
+                truthiness = false
+              end
+            end
             result
           ensure
             suffix = truthiness == false ? 'failure' : 'success'
-            StatsD.increment("#{StatsD::Instrument.generate_metric_name(name, self, *args)}.#{suffix}", 1, *metric_options)
+            metric_name = "#{StatsD::Instrument.generate_metric_name(name, self, *args)}.#{suffix}"
+            StatsD.increment(metric_name, 1, *metric_options)
           end
         end
       end
     end
 
-    # Adds success and failure counter instrumentation to a method.
+    # Adds success counter instrumentation to a method.
     #
     # A method call will be considered successful if it does not raise an exception, and the result is true-y.
-    # Only for successful calls, the metric will be icnremented
+    # Only for successful calls, the metric will be incremented.
     #
     # @param method (see #statsd_measure)
     # @param name (see #statsd_measure)
@@ -159,10 +180,19 @@ module StatsD
             truthiness = false
             raise
           else
-            truthiness = (yield(result) rescue false) if block_given?
+            if block_given?
+              begin
+                truthiness = yield(result)
+              rescue
+                truthiness = false
+              end
+            end
             result
           ensure
-            StatsD.increment(StatsD::Instrument.generate_metric_name(name, self, *args), *metric_options) if truthiness
+            if truthiness
+              metric_name = StatsD::Instrument.generate_metric_name(name, self, *args)
+              StatsD.increment(metric_name, *metric_options)
+            end
           end
         end
       end
@@ -180,7 +210,8 @@ module StatsD
     def statsd_count(method, name, *metric_options)
       add_to_method(method, name, :count) do
         define_method(method) do |*args, &block|
-          StatsD.increment(StatsD::Instrument.generate_metric_name(name, self, *args), 1, *metric_options)
+          metric_name = StatsD::Instrument.generate_metric_name(name, self, *args)
+          StatsD.increment(metric_name, 1, *metric_options)
           super(*args, &block)
         end
       end
@@ -248,8 +279,13 @@ module StatsD
     def add_to_method(method, name, action, &block)
       instrumentation_module = statsd_instrumentation_for(method, name, action)
 
-      raise ArgumentError, "already instrumented #{method} for #{self.name}" if instrumentation_module.method_defined?(method)
-      raise ArgumentError, "could not find method #{method} for #{self.name}" unless method_defined?(method) || private_method_defined?(method)
+      if instrumentation_module.method_defined?(method)
+        raise ArgumentError, "Already instrumented #{method} for #{self.name}"
+      end
+
+      unless method_defined?(method) || private_method_defined?(method)
+        raise ArgumentError, "could not find method #{method} for #{self.name}"
+      end
 
       method_scope = method_visibility(method)
 
@@ -263,10 +299,9 @@ module StatsD
     end
 
     def method_visibility(method)
-      case
-      when private_method_defined?(method)
+      if private_method_defined?(method)
         :private
-      when protected_method_defined?(method)
+      elsif protected_method_defined?(method)
         :protected
       else
         :public
@@ -276,6 +311,11 @@ module StatsD
 
   attr_accessor :logger, :default_sample_rate, :prefix
   attr_writer :backend
+  attr_reader :default_tags
+
+  def default_tags=(tags)
+    @default_tags = StatsD::Instrument::Metric.normalize_tags(tags)
+  end
 
   def backend
     @backend ||= StatsD::Instrument::Environment.default_backend
@@ -310,11 +350,16 @@ module StatsD
     value, metric_options = parse_options(value, metric_options)
     type = (!metric_options.empty? && metric_options.first[:as_dist] ? :d : :ms)
 
-    result = nil
-    value  = 1000 * StatsD::Instrument.duration { result = block.call } if block_given?
-    metric = collect_metric(type, key, value, metric_options)
-    result = metric unless block_given?
-    result
+    return collect_metric(type, key, value, metric_options) unless block_given?
+
+    start = StatsD::Instrument.current_timestamp
+    begin
+      block.call
+    ensure
+      # Ensure catches both a raised exception and a return in the invoked block
+      value = 1000 * (StatsD::Instrument.current_timestamp - start)
+      collect_metric(type, key, value, metric_options)
+    end
   end
 
   # Emits a counter metric.
@@ -371,13 +416,18 @@ module StatsD
   #      http_response = StatsD.distribution('HTTP.call.duration') do
   #        HTTP.get(url)
   #      end
-  def distribution(key, value=nil, *metric_options, &block)
+  def distribution(key, value = nil, *metric_options, &block)
     value, metric_options = parse_options(value, metric_options)
-    result = nil
-    value  = 1000 * StatsD::Instrument.duration { result = block.call } if block_given?
-    metric = collect_metric(:d, key, value, metric_options)
-    result = metric unless block_given?
-    result
+
+    return collect_metric(:d, key, value, metric_options) unless block_given?
+
+    start = StatsD::Instrument.current_timestamp
+    begin
+      block.call
+    ensure
+      value = 1000 * (StatsD::Instrument.current_timestamp - start)
+      collect_metric(:d, key, value, metric_options)
+    end
   end
 
   # Emits a key/value metric.
@@ -426,7 +476,7 @@ module StatsD
   # @param args [Array] The list of non-required arguments.
   # @return [Hash] The hash of optional arguments.
   def hash_argument(args)
-    return {} if args.length == 0
+    return {} if args.empty?
     return args.first if args.length == 1 && args.first.is_a?(Hash)
 
     order = [:sample_rate, :tags]
@@ -434,8 +484,7 @@ module StatsD
     args.each_with_index do |value, index|
       hash[order[index]] = value
     end
-
-    return hash
+    hash
   end
 
   def parse_options(value, metric_options)

data/lib/statsd-instrument.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'statsd/instrument'

data/statsd-instrument.gemspec

@@ -1,21 +1,23 @@
+# frozen-string-literal: true
 # encoding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'statsd/instrument/version'
 
 Gem::Specification.new do |spec|
-  spec.name        = "statsd-instrument"
-  spec.version     = StatsD::Instrument::VERSION
-  spec.authors     = ["Jesse Storimer", "Tobias Lutke", "Willem van Bergen"]
-  spec.email       = ["jesse@shopify.com"]
-  spec.homepage    = "https://github.com/Shopify/statsd-instrument"
-  spec.summary     = %q{A StatsD client for Ruby apps}
+  spec.name = "statsd-instrument"
+  spec.version = StatsD::Instrument::VERSION
+  spec.authors = ["Jesse Storimer", "Tobias Lutke", "Willem van Bergen"]
+  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 apps. Provides metaprogramming methods to inject StatsD instrumentation into your code.}
-  spec.license     = "MIT"
+  spec.license = "MIT"
 
-  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.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"]
 
   spec.add_development_dependency 'rake'
@@ -23,5 +25,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'mocha'
   spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'benchmark-ips'
 end

data/test/assertions_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class AssertionsTest < Minitest::Test
@@ -163,6 +165,15 @@ class AssertionsTest < Minitest::Test
     end
   end
 
+  def test_tags_friendly_error
+    @test_case.assert_statsd_increment('counter', tags: { class: "AnotherJob" }) do
+      StatsD.increment('counter', tags: { class: "MyJob" })
+    end
+  rescue MiniTest::Assertion => assertion
+    assert_match(/Captured metrics with the same key/, assertion.message)
+    assert_match(/MyJob/, assertion.message)
+  end
+
   def test_multiple_metrics_are_not_order_dependent
     assert_no_assertion_triggered do
       foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:1'])
@@ -262,7 +273,7 @@ class AssertionsTest < Minitest::Test
   def test_assert_statsd_call_with_wrong_sample_rate_type
     assert_assertion_triggered "Unexpected sample rate type for metric counter, must be numeric" do
       @test_case.assert_statsd_increment('counter', tags: ['a', 'b']) do
-        StatsD.increment('counter', sample_rate: 'abc', tags:  ['a', 'b'])
+        StatsD.increment('counter', sample_rate: 'abc', tags: ['a', 'b'])
       end
     end
   end
@@ -309,7 +320,7 @@ class AssertionsTest < Minitest::Test
   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}."
+    flunk("No assertion trigger expected, but one was triggered with message #{assertion.message}.")
   else
     pass
   end
@@ -318,12 +329,12 @@ class AssertionsTest < Minitest::Test
     block.call
   rescue MiniTest::Assertion => assertion
     if message
-      assert_equal message, assertion.message, "Assertion triggered, but message was not what was expected."
+      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."
+    flunk("No assertion was triggered, but one was expected.")
   end
 end

data/test/benchmark/default_tags.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'statsd-instrument'
+require 'benchmark/ips'
+
+StatsD.logger = Logger.new('/dev/null')
+
+class Suite
+  def warming(*args)
+    StatsD.default_tags = if args[0] == "with default tags"
+      { first_tag: 'first_value', second_tag: 'second_value' }
+    end
+    puts "warming with default tags: #{StatsD.default_tags}"
+  end
+
+  def running(*args)
+    StatsD.default_tags = if args[0] == "with default tags"
+      { first_tag: 'first_value', second_tag: 'second_value' }
+    end
+    puts "running with default tags: #{StatsD.default_tags}"
+  end
+
+  def warmup_stats(*)
+  end
+
+  def add_report(*)
+  end
+end
+
+suite = Suite.new
+
+Benchmark.ips do |bench|
+  bench.config(suite: suite)
+  bench.report("without default tags") do
+    StatsD.increment('GoogleBase.insert', tags: {
+      first_tag: 'first_value',
+      second_tag: 'second_value',
+      third_tag: 'third_value',
+    })
+  end
+
+  bench.report("with default tags") do
+    StatsD.increment('GoogleBase.insert', tags: { third_tag: 'third_value' })
+  end
+
+  bench.compare!
+end

data/test/benchmark/metrics.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'statsd-instrument'
 require 'benchmark/ips'
 
-def helperFunction()
-    a = 10
-    a += a
-    a -= a
-    a *= a
+def helper_function
+  a = 10
+  a += a
+  a -= a
+  a * a
 end
 
 Benchmark.ips do |bench|
@@ -14,8 +16,8 @@ Benchmark.ips do |bench|
   end
 
   bench.report("measure metric benchmark") do
-    StatsD.measure('helperFunction') do
-        helperFunction()
+    StatsD.measure('helper_function') do
+      helper_function
     end
   end
 
@@ -34,5 +36,4 @@ Benchmark.ips do |bench|
   bench.report("service check metric benchmark") do
     StatsD.service_check('shipit.redis_connection', 'ok')
   end
-
 end

data/test/benchmark/tags.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'statsd-instrument'
 require 'benchmark/ips'
 
 Benchmark.ips do |bench|
   bench.report("normalized tags with simple hash") do
-    StatsD::Instrument::Metric.normalize_tags(:tag => 'value')
+    StatsD::Instrument::Metric.normalize_tags(tag: 'value')
   end
 
   bench.report("normalized tags with simple array") do
@@ -11,14 +13,14 @@ Benchmark.ips do |bench|
   end
 
   bench.report("normalized tags with large hash") do
-    StatsD::Instrument::Metric.normalize_tags({
+    StatsD::Instrument::Metric.normalize_tags(
       mobile: true,
       pod: "1",
       protocol: "https",
       country: "Langbortistan",
       complete: true,
       shop: "omg shop that has a longer name",
-    })
+    )
   end
 
   bench.report("normalized tags with large array") do

data/test/capture_backend_test.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 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)
+    @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

data/test/environment_test.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Rails; end
 
 class EnvironmentTest < Minitest::Test
-
   def setup
     ENV['STATSD_ADDR'] = nil
     ENV['IMPLEMENTATION'] = nil

data/test/helpers_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class HelpersTest < Minitest::Test
@@ -21,4 +23,3 @@ class HelpersTest < Minitest::Test
     assert_equal 12, metrics[1].value
   end
 end
-

data/test/integration_test.rb

@@ -1,20 +1,40 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class IntegrationTest < Minitest::Test
-
   def setup
-    @old_backend, StatsD.backend = StatsD.backend, StatsD::Instrument::Backends::UDPBackend.new("localhost:31798")
+    @server = UDPSocket.new
+    @server.bind('localhost', 0)
+    port = @server.addr[1]
+
+    @old_backend = StatsD.backend
+    StatsD.backend = StatsD::Instrument::Backends::UDPBackend.new("localhost:#{port}")
   end
-  
+
   def teardown
+    @server.close
     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
+    assert_equal "counter:1|c", @server.recvfrom(100).first
+  end
+
+  def test_synchronize_in_exit_handler_handles_thread_error_and_exits_cleanly
+    pid = fork do
+      Signal.trap('TERM') do
+        StatsD.increment('exiting')
+        Process.exit!(0)
+      end
+
+      sleep 100
+    end
+
+    Process.kill('TERM', pid)
+    Process.waitpid(pid)
+
+    assert_equal "exiting:1|c", @server.recvfrom(100).first
   end
 end

data/test/logger_backend_test.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class LoggerBackendTest < Minitest::Test
   def setup
     logger = Logger.new(@io = StringIO.new)
-    logger.formatter = lambda { |_,_,_, msg| "#{msg}\n" }
+    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)
+    @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"
+    assert_equal <<~LOG, @io.string
+      [StatsD] increment mock.counter:1 #a:b #c:d
+      [StatsD] measure mock.measure:123 @0.3
+    LOG
   end
-end
+end