statsd-instrument 2.4.0 → 2.5.0

data/lib/statsd/instrument/strict.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'statsd-instrument' unless Object.const_defined?(:StatsD)
+
+module StatsD
+  module Instrument
+    UNSPECIFIED = Object.new.freeze
+    private_constant :UNSPECIFIED
+
+    # The Strict monkeypatch can be loaded to see if you're using the StatsD library in
+    # a deprecated way.
+    #
+    # - The metric methods are not retuning a Metric instance.
+    # - Only accept keyword arguments for tags and sample_rate, rather than position arguments.
+    # - Only accept a position argument for value, rather than a keyword argument.
+    # - The provided arguments have the right type.
+    #
+    # You can enable thois monkeypatch by changing your Gemfile as follows:
+    #
+    #     gem 'statsd-instrument', require: 'statsd/instrument/strict'
+    #
+    # By doing this as part of your QA/CI, you can find where you are still using deprecated patterns,
+    # and fix them before the deprecated behavior is removed in the next major version.
+    #
+    # This monkeypatch is not meant to be used in production.
+    module Strict
+      def increment(key, value = 1, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        raise ArgumentError, "StatsD.increment does not accept a block" if block_given?
+        raise ArgumentError, "The value argument should be an integer, got #{value.inspect}" unless value.is_a?(Numeric)
+        check_tags_and_sample_rate(sample_rate, tags)
+
+        super
+      end
+
+      def gauge(key, value, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        raise ArgumentError, "StatsD.increment does not accept a block" if block_given?
+        raise ArgumentError, "The value argument should be an integer, got #{value.inspect}" unless value.is_a?(Numeric)
+        check_tags_and_sample_rate(sample_rate, tags)
+
+        super
+      end
+
+      def histogram(key, value, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        raise ArgumentError, "StatsD.increment does not accept a block" if block_given?
+        raise ArgumentError, "The value argument should be an integer, got #{value.inspect}" unless value.is_a?(Numeric)
+        check_tags_and_sample_rate(sample_rate, tags)
+
+        super
+      end
+
+      def set(key, value, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        raise ArgumentError, "StatsD.set does not accept a block" if block_given?
+        check_tags_and_sample_rate(sample_rate, tags)
+
+        super
+      end
+
+      def measure(key, value = UNSPECIFIED, sample_rate: nil, tags: nil,
+        prefix: StatsD.prefix, no_prefix: false, as_dist: false, &block)
+
+        check_block_or_numeric_value(value, &block)
+        check_tags_and_sample_rate(sample_rate, tags)
+
+        super
+      end
+
+      def distribution(key, value = UNSPECIFIED, sample_rate: nil, tags: nil,
+        prefix: StatsD.prefix, no_prefix: false, &block)
+
+        check_block_or_numeric_value(value, &block)
+        check_tags_and_sample_rate(sample_rate, tags)
+
+        super
+      end
+
+      private
+
+      def check_block_or_numeric_value(value)
+        if block_given?
+          raise ArgumentError, "The value argument should not be set when providing a block" unless value == UNSPECIFIED
+        else
+          raise ArgumentError, "The value argument should be a number, got #{value.inspect}" unless value.is_a?(Numeric)
+        end
+      end
+
+      def check_tags_and_sample_rate(sample_rate, tags)
+        unless sample_rate.nil? || sample_rate.is_a?(Numeric)
+          raise ArgumentError, "The sample_rate argument should be a number, got #{sample_rate}"
+        end
+        unless tags.nil? || tags.is_a?(Hash) || tags.is_a?(Array)
+          raise ArgumentError, "The tags argument should be a hash or an array, got #{tags.inspect}"
+        end
+      end
+
+      def collect_metric(type, name, value, sample_rate:, tags: nil, prefix:, metadata: nil)
+        super
+        nil # We explicitly discard the return value, so people cannot depend on it.
+      end
+    end
+
+    module StrictMetaprogramming
+      def statsd_measure(method, name, sample_rate: nil, tags: nil,
+        prefix: StatsD.prefix, no_prefix: false, as_dist: false)
+
+        check_method_and_metric_name(method, name)
+        super
+      end
+
+      def statsd_distribution(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        check_method_and_metric_name(method, name)
+        super
+      end
+
+      def statsd_count_success(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        check_method_and_metric_name(method, name)
+        super
+      end
+
+      def statsd_count_if(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        check_method_and_metric_name(method, name)
+        super
+      end
+
+      def statsd_count(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+        check_method_and_metric_name(method, name)
+        super
+      end
+
+      private
+
+      def check_method_and_metric_name(method, metric_name)
+        unless method.is_a?(Symbol)
+          raise ArgumentError, "The method name should be provided as symbol, got #{method.inspect}"
+        end
+
+        unless metric_name.is_a?(String) || metric_name.is_a?(Proc)
+          raise ArgumentError, "The metric name should be a proc or string, got #{metric_name.inspect}"
+        end
+      end
+    end
+  end
+end
+
+StatsD.singleton_class.prepend(StatsD::Instrument::Strict)
+StatsD::Instrument.prepend(StatsD::Instrument::StrictMetaprogramming)

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "2.4.0"
+    VERSION = "2.5.0"
   end
 end

data/test/assertions_test.rb

@@ -271,6 +271,7 @@ class AssertionsTest < Minitest::Test
   end
 
   def test_assert_statsd_call_with_wrong_sample_rate_type
+    skip("In Strict mode, the StatsD.increment call will raise") if StatsD::Instrument.strict_mode_enabled?
     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'])
@@ -315,6 +316,42 @@ class AssertionsTest < Minitest::Test
     end
   end
 
+  def test_assertion_with_exceptions
+    assert_no_assertion_triggered do
+      @test_case.assert_raises(RuntimeError) do
+        @test_case.assert_statsd_increment('counter') do
+          StatsD.increment('counter')
+          raise "foo"
+        end
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        @test_case.assert_raises(RuntimeError) do
+          StatsD.increment('counter')
+          raise "foo"
+        end
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        @test_case.assert_raises(RuntimeError) do
+          raise "foo"
+        end
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_raises(RuntimeError) do
+        @test_case.assert_statsd_increment('counter') do
+          raise "foo"
+        end
+      end
+    end
+  end
+
   private
 
   def assert_no_assertion_triggered(&block)

data/test/benchmark/clock_gettime.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+Benchmark.ips do |bench|
+  bench.report("Process.clock_gettime in milliseconds (int)") do
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+  end
+
+  bench.report("Process.clock_gettime in milliseconds (float)") do
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+  end
+
+  bench.report("Process.clock_gettime in seconds (float), multiplied by 1000") do
+    1000 * Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  bench.report("Process.clock_gettime in seconds (float), multiplied by 1000.0") do
+    1000.0 * Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  bench.report("Time.now, multiplied by 1000") do
+    1000 * Time.now.to_f
+  end
+
+  bench.compare!
+end

data/test/benchmark/default_tags.rb

@@ -3,7 +3,7 @@
 require 'statsd-instrument'
 require 'benchmark/ips'
 
-StatsD.logger = Logger.new('/dev/null')
+StatsD.logger = Logger.new(File::NULL)
 
 class Suite
   def warming(*args)

data/test/deprecations_test.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DeprecationsTest < Minitest::Test
+  unless StatsD::Instrument.strict_mode_enabled?
+    # rubocop:disable StatsD/MetaprogrammingPositionalArguments
+    class InstrumentedClass
+      extend StatsD::Instrument
+      def foo; end
+      statsd_count :foo, 'metric', 0.5, ['tag']
+    end
+    # rubocop:enable StatsD/MetaprogrammingPositionalArguments
+  end
+
+  include StatsD::Instrument::Assertions
+
+  def setup
+    skip("Deprecation are not supported in strict mode") if StatsD::Instrument.strict_mode_enabled?
+  end
+
+  # rubocop:disable StatsD/MetricValueKeywordArgument
+  def test__deprecated__statsd_measure_with_explicit_value_as_keyword_argument
+    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42) }
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+    assert_equal :ms, metric.type
+  end
+
+  def test__deprecated__statsd_measure_with_explicit_value_keyword_and_distribution_override
+    metric = capture_statsd_call { StatsD.measure('values.foobar', value: 42, as_dist: true) }
+    assert_equal 42, metric.value
+    assert_equal :d, metric.type
+  end
+
+  def test__deprecated__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__deprecated__statsd_gauge_with_keyword_argument
+    metric = capture_statsd_call { StatsD.gauge('values.foobar', value: 13) }
+    assert_equal :g, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 13, metric.value
+  end
+  # rubocop:enable StatsD/MetricValueKeywordArgument
+
+  # rubocop:disable StatsD/MetricReturnValue
+  def test__deprecated__statsd_increment_retuns_metric_instance
+    metric = StatsD.increment('key')
+    assert_kind_of StatsD::Instrument::Metric, metric
+    assert_equal 'key', metric.name
+    assert_equal :c, metric.type
+    assert_equal 1, metric.value
+  end
+  # rubocop:enable StatsD/MetricReturnValue
+
+  # rubocop:disable StatsD/PositionalArguments
+  def test__deprecated__statsd_increment_with_positional_argument_for_tags
+    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
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+  end
+  # rubocop:enable StatsD/PositionalArguments
+
+  def test__deprecated__metaprogramming_method_with_positional_arguments
+    metric = capture_statsd_call { InstrumentedClass.new.foo }
+    assert_equal :c, metric.type
+    assert_equal 'metric', metric.name
+    assert_equal 1, metric.value
+    assert_equal 0.5, metric.sample_rate
+    assert_equal ["tag"], metric.tags
+  end
+
+  protected
+
+  def capture_statsd_call(&block)
+    metrics = capture_statsd_calls(&block)
+    assert_equal 1, metrics.length
+    metrics.first
+  end
+end

data/test/helpers/rubocop_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RubocopHelper
+  attr_accessor :cop
+
+  private
+
+  def assert_no_offenses(source)
+    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
+    assert_predicate cop.offenses, :empty?, "Did not expect Rubocop to find offenses"
+  end
+
+  def assert_offense(source)
+    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
+    refute_predicate cop.offenses, :empty?, "Expected Rubocop to find offenses"
+  end
+
+  def assert_no_autocorrect(source)
+    corrected = autocorrect_source(source)
+    assert_equal source, corrected
+  end
+
+  def autocorrect_source(source)
+    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+    cop.instance_variable_get(:@options)[:auto_correct] = true
+
+    processed_source = RuboCop::ProcessedSource.new(source, 2.3, nil)
+    investigate(processed_source)
+
+    corrector = RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector.rewrite
+  end
+
+  def investigate(processed_source)
+    forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
+      next unless cop.join_force?(klass)
+      instances << klass.new([cop])
+    end
+
+    commissioner = RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
+    commissioner.investigate(processed_source)
+    commissioner
+  end
+end

data/test/integration_test.rb

@@ -33,8 +33,12 @@ class IntegrationTest < Minitest::Test
     end
 
     Process.kill('TERM', pid)
-    Process.waitpid(pid)
+    _, exit_status = Process.waitpid2(pid)
 
-    assert_equal "exiting:1|c", @server.recvfrom(100).first
+    assert_equal 0, exit_status, "The foked process did not exit cleanly"
+    assert_equal "exiting:1|c", @server.recvfrom_nonblock(100).first
+
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
   end
 end

data/test/matchers_test.rb

@@ -41,7 +41,7 @@ class MatchersTest < Minitest::Test
 
   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) })
+      .matches? lambda { 3.times { StatsD.increment('counter') } }
   end
 
   def test_statsd_increment_with_sample_rate_matched
@@ -61,15 +61,15 @@ class MatchersTest < Minitest::Test
 
   def test_statsd_increment_with_value_matched_when_multiple_metrics
     assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
-      StatsD.increment('counter', value: 2)
-      StatsD.increment('counter', value: 1)
+      StatsD.increment('counter', 2)
+      StatsD.increment('counter', 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 {
-      StatsD.increment('counter', value: 2)
-      StatsD.increment('counter', value: 3)
+      StatsD.increment('counter', 2)
+      StatsD.increment('counter', 3)
     })
   end
 
@@ -90,15 +90,15 @@ class MatchersTest < Minitest::Test
 
   def test_statsd_increment_with_times_and_value_matched
     assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
-      StatsD.increment('counter', value: 1)
-      StatsD.increment('counter', value: 1)
+      StatsD.increment('counter', 1)
+      StatsD.increment('counter', 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 {
-      StatsD.increment('counter', value: 1)
-      StatsD.increment('counter', value: 2)
+      StatsD.increment('counter', 1)
+      StatsD.increment('counter', 2)
     })
   end
 

data/test/metric_test.rb

@@ -16,27 +16,12 @@ class MetricTest < Minitest::Test
     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
-
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', prefix: "foobar")
-    assert_equal 'foobar.counter', m.name
-
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', prefix: "foobar", no_prefix: true)
-    assert_equal 'counter', m.name
-  end
-
   def test_bad_metric_name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my:metric', no_prefix: true)
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'my:metric')
     assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my|metric', no_prefix: true)
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'my|metric')
     assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my@metric', no_prefix: true)
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'my@metric')
     assert_equal 'my_metric', m.name
   end