statsd-instrument 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46fc4b2306e65ec55ec96d05f26653460d43ece8
-  data.tar.gz: c4657dafe04761702c5464de9b277f77e1106530
+  metadata.gz: 185cb2c919df0365e7808fdc36f0eece2ffac2aa
+  data.tar.gz: 6f64c341a7d7cd1ef9ae7400b99cca75641388f8
 SHA512:
-  metadata.gz: 2e450334ecc746a8066b86975a208a5bf9d0bec99d6117080aa407106909cc3636321fd49e6663f847bce8d40da7a19e3bfd945087420c8ad04b70032f029c45
-  data.tar.gz: a080a4c6497edd7881a9abd20f955e2796b08c9524c246cfbbd62cc6d7a66e8d03a4978c4c8dcd544110b5e7c07365dbae89b7f8748f5916eaf95d038a08c6da
+  metadata.gz: 95db3eab39e1cecaa4938bab5df81de7f9c4c0b36d8f0640a0a95b6b0d036f65edb91f180a41d3ee64446841430f29d58d42ad9c58bfec1967114236f0d18030
+  data.tar.gz: 7df38af3a361e4ba803994f09292c66c2c78ecaf681e02aa937982cdd7ab9005c0872a1442a96d0d2fdcafc43e36535363a38cb3dadc94cc3bf49761bc49b6cd

data/.travis.yml

@@ -1,10 +1,8 @@
 language: ruby
 rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - jruby-19mode
-  - rbx-2
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
   - ruby-head
 
 matrix:

data/CHANGELOG.md

@@ -5,9 +5,51 @@ please at an entry to the "unreleased changes" section below.
 
 ### Unreleased changes
 
+### Version 2.1.2
+
+- Use `prepend` instead of rewriting classes for metaprogramming methods.
+- RSpec: make matchers more flexible.
+- Bugfix: Only ask Rails for the environment when it's actually loaded.
+
+### Version 2.1.1
+
+- Add `assert_statsd_calls` to from validating cases where one has multiple metrics with the same name and type being recorded, but with different options.
+
+### Version 2.1.0
+
+- Fix rspec-rails compatibility
+- Add `value` keyword argument to all metric types.
+
+### Version 2.0.12
+
+- Make StatsD client thread-safe
+- Assertions: Ensure sample rates have proper values.
+- Assertions: Make tag assertions work more intuitively
+- RSpec: Add backwards compatibility for RSpec 2
+
+### Version 2.0.11
+
+- Don't change method visibility when adding instrumentation to methods using metaprogramming
+- RSpec: add support for Compound expectations
+
+### Version 2.0.10
+
+- Assertions: allow ignoring certain tags when asserting for other tags to be present.
+
+### Version 2.0.9
+
+- Better error message for `assert_no_statsd_calls`
+
+### Version 2.0.8
+
+- More tag handling performance improvements.
+- RSpec matchers documentation improvements
+
+### Version 2.0.7
+
+- Tag handling performance improvements.
+- Test against Ruby 2.2.
 - Drop support for Ruby 1.9.3.
-- Add support for Ruby 2.2.
-- Make library compatible with RSpec 2.
 
 ### Version 2.0.6
 
@@ -15,7 +57,6 @@ please at an entry to the "unreleased changes" section below.
 - Default behavior: in a **staging** environment, the defaults are now the same as in a **production environment**.
 - Documentation overhaul
 
-
 ### Version 2.0.5
 
 - Allow for nested assertions using the `assert_statsd_*` assertion methods.

data/README.md

@@ -280,6 +280,12 @@ RSpec.describe 'Matchers' do
       }.to trigger_statsd_increment('counter', times: 2)
     end
 
+    it 'will pass if it matches argument' do
+      expect {
+        StatsD.measure('counter', 0.3001)
+      }.to trigger_statsd_measure('counter', value: be_between(0.29, 0.31))
+    end
+
     it 'will pass if there is no matching StatsD call on negative expectation' do
       expect { StatsD.increment('other_counter') }.not_to trigger_statsd_increment('counter')
     end

data/lib/statsd/instrument.rb

@@ -40,6 +40,16 @@ module StatsD
   # StatsD metrics. E.g., yopu can create counters on how often a method is called, how often it is
   # successful, the duration of the methods call, etc.
   module Instrument
+    # @private
+    def statsd_instrumentations
+      if defined?(@statsd_instrumentations)
+        @statsd_instrumentations
+      elsif respond_to?(:superclass) && superclass.respond_to?(:statsd_instrumentations)
+        superclass.statsd_instrumentations
+      else
+        @statsd_instrumentations = {}
+      end
+    end
 
     # @private
     def self.generate_metric_name(metric_name, callee, *args)
@@ -70,9 +80,9 @@ module StatsD
     # @param metric_options (see StatsD#measure)
     # @return [void]
     def statsd_measure(method, name, *metric_options)
-      add_to_method(method, name, :measure) do |old_method, new_method, metric_name, *args|
-        define_method(new_method) do |*args, &block|
-          StatsD.measure(StatsD::Instrument.generate_metric_name(metric_name, self, *args), nil, *metric_options) { send(old_method, *args, &block) }
+      add_to_method(method, name, :measure) do
+        define_method(method) do |*args, &block|
+          StatsD.measure(StatsD::Instrument.generate_metric_name(name, self, *args), nil, *metric_options) { super(*args, &block) }
         end
       end
     end
@@ -93,10 +103,10 @@ module StatsD
     # @return [void]
     # @see #statsd_count_if
     def statsd_count_success(method, name, *metric_options)
-      add_to_method(method, name, :count_success) do |old_method, new_method, metric_name|
-        define_method(new_method) do |*args, &block|
+      add_to_method(method, name, :count_success) do
+        define_method(method) do |*args, &block|
           begin
-            truthiness = result = send(old_method, *args, &block)
+            truthiness = result = super(*args, &block)
           rescue
             truthiness = false
             raise
@@ -105,7 +115,7 @@ module StatsD
             result
           ensure
             suffix = truthiness == false ? 'failure' : 'success'
-            StatsD.increment("#{StatsD::Instrument.generate_metric_name(metric_name, self, *args)}.#{suffix}", 1, *metric_options)
+            StatsD.increment("#{StatsD::Instrument.generate_metric_name(name, self, *args)}.#{suffix}", 1, *metric_options)
           end
         end
       end
@@ -125,10 +135,10 @@ module StatsD
     # @return [void]
     # @see #statsd_count_success
     def statsd_count_if(method, name, *metric_options)
-      add_to_method(method, name, :count_if) do |old_method, new_method, metric_name|
-        define_method(new_method) do |*args, &block|
+      add_to_method(method, name, :count_if) do
+        define_method(method) do |*args, &block|
           begin
-            truthiness = result = send(old_method, *args, &block)
+            truthiness = result = super(*args, &block)
           rescue
             truthiness = false
             raise
@@ -136,7 +146,7 @@ module StatsD
             truthiness = (yield(result) rescue false) if block_given?
             result
           ensure
-            StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), *metric_options) if truthiness
+            StatsD.increment(StatsD::Instrument.generate_metric_name(name, self, *args), *metric_options) if truthiness
           end
         end
       end
@@ -152,10 +162,10 @@ module StatsD
     # @param metric_options (see #statsd_measure)
     # @return [void]
     def statsd_count(method, name, *metric_options)
-      add_to_method(method, name, :count) do |old_method, new_method, metric_name|
-        define_method(new_method) do |*args, &block|
-          StatsD.increment(StatsD::Instrument.generate_metric_name(metric_name, self, *args), 1, *metric_options)
-          send(old_method, *args, &block)
+      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)
+          super(*args, &block)
         end
       end
     end
@@ -198,40 +208,33 @@ module StatsD
 
     private
 
-    def add_to_method(method, name, action, &block)
-      metric_name = name
-
-      method_name_without_statsd = :"#{method}_for_#{action}_on_#{self.name}_without_#{name}"
-      # raw_ssl_request_for_measure_on_FedEx_without_ActiveMerchant.Shipping.#{self.class.name}.ssl_request
+    def statsd_instrumentation_for(method, name, action)
+      unless statsd_instrumentations.key?([method, name, action])
+        mod = Module.new do
+          define_singleton_method(:inspect) do
+            "StatsD_Instrument_#{method}_for_#{action}_with_#{name}"
+          end
+        end
+        @statsd_instrumentations = statsd_instrumentations.merge([method, name, action] => mod)
+      end
+      @statsd_instrumentations[[method, name, action]]
+    end
 
-      method_name_with_statsd = :"#{method}_for_#{action}_on_#{self.name}_with_#{name}"
-      # raw_ssl_request_for_measure_on_FedEx_with_ActiveMerchant.Shipping.#{self.class.name}.ssl_request
+    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 method_defined? method_name_without_statsd
+      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)
 
       method_scope = method_visibility(method)
 
-      alias_method method_name_without_statsd, method
-      yield method_name_without_statsd, method_name_with_statsd, metric_name
-      alias_method method, method_name_with_statsd
-
-      private(method_name_without_statsd)
-      send(method_scope, method)
-      private(method_name_with_statsd)
+      instrumentation_module.module_eval(&block)
+      instrumentation_module.send(method_scope, method)
+      prepend(instrumentation_module) unless self < instrumentation_module
     end
 
     def remove_from_method(method, name, action)
-      method_name_without_statsd = :"#{method}_for_#{action}_on_#{self.name}_without_#{name}"
-      method_name_with_statsd = :"#{method}_for_#{action}_on_#{self.name}_with_#{name}"
-
-      method_scope = method_visibility(method)
-
-      send(:remove_method, method_name_with_statsd)
-      alias_method method, method_name_without_statsd
-      send(:remove_method, method_name_without_statsd)
-
-      send(method_scope, method)
+      statsd_instrumentation_for(method, name, action).send(:remove_method, method)
     end
 
     def method_visibility(method)

data/lib/statsd/instrument/environment.rb

@@ -28,7 +28,7 @@ module StatsD::Instrument::Environment
   #
   # @return [String] The detected environment.
   def environment
-    if defined?(Rails)
+    if defined?(Rails) && Rails.respond_to?(:env)
       Rails.env.to_s
     else
       ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['ENV'] || 'development'

data/lib/statsd/instrument/matchers.rb

@@ -55,13 +55,33 @@ module StatsD::Instrument::Matchers
       [:sample_rate, :value, :tags].each do |expectation|
         next unless options[expectation]
 
-        if metrics.all? { |m| m.public_send(expectation) != options[expectation] }
-          raise RSpec::Expectations::ExpectationNotMetError, "Unexpected StatsD #{expectation.to_s.gsub('_', ' ')} for metric #{metric_name}"
+        num_matches = metrics.count do |m|
+          matcher = RSpec::Matchers::BuiltIn::Match.new(options[expectation])
+          matcher.matches?(m.public_send(expectation))
+        end
+
+        found = options[:times] ? num_matches == options[:times] : num_matches > 0
+
+        if !found
+          message = metric_information(metric_name, options, metrics, expectation)
+          raise RSpec::Expectations::ExpectationNotMetError, message
         end
       end
 
       true
     end
+
+    def metric_information(metric_name, options, metrics, expectation)
+      message = "expected StatsD #{expectation.inspect} for metric '#{metric_name}' to be called"
+
+      message += "\n  "
+      message += options[:times] ? "exactly #{options[:times]} times" : "at least once"
+      message += " with: #{options[expectation]}"
+
+      message += "\n  captured metric values: #{metrics.map(&expectation).join(', ')}"
+
+      message
+    end
   end
 
   CUSTOM_MATCHERS.each do |method_name, metric_type|

data/lib/statsd/instrument/version.rb

@@ -1,5 +1,5 @@
 module StatsD
   module Instrument
-    VERSION = "2.1.1"
+    VERSION = "2.1.2"
   end
 end

data/test/environment_test.rb

@@ -1,5 +1,7 @@
 require 'test_helper'
 
+module Rails; end
+
 class EnvironmentTest < Minitest::Test
 
   def setup
@@ -32,4 +34,13 @@ class EnvironmentTest < Minitest::Test
     assert_equal 1234, backend.port
     assert_equal :datadog, backend.implementation
   end
+
+  def test_uses_env_when_rails_does_not_respond_to_env
+    assert_equal ENV['ENV'], StatsD::Instrument::Environment.environment
+  end
+
+  def test_uses_rails_env_when_rails_is_available
+    Rails.stubs(:env).returns('production')
+    assert_equal 'production', StatsD::Instrument::Environment.environment
+  end
 end

data/test/matchers_test.rb

@@ -10,7 +10,7 @@ class MatchersTest < Minitest::Test
     refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {}).matches? lambda { StatsD.increment('not_counter') }
   end
 
-  def test_statsd_increment_compound
+  def test_statsd_increment_compound_matched
     matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
     matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
 
@@ -20,6 +20,16 @@ class MatchersTest < Minitest::Test
     }
   end
 
+  def test_statsd_increment_compound_not_matched
+    matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
+    matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
+
+    refute RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches? lambda {
+      StatsD.increment('counter', tags: ['a'])
+      StatsD.increment('counter', tags: ['a'])
+    }
+  end
+
   def test_statsd_increment_with_times_matched
     assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1).matches? lambda { StatsD.increment('counter') }
   end
@@ -40,6 +50,20 @@ class MatchersTest < Minitest::Test
     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 {
+      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 {
+      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') }
   end
@@ -51,4 +75,28 @@ class MatchersTest < Minitest::Test
   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']) }
   end
+
+  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)
+    }
+  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)
+    }
+  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) }
+  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) }
+  end
 end

data/test/statsd_instrumentation_test.rb

@@ -288,6 +288,22 @@ class StatsDInstrumentationTest < Minitest::Test
     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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-28 00:00:00.000000000 Z
+date: 2016-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake