statsd-instrument 3.1.1 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: feb99d0537663296eacb1c2f0c6d090f37430afc04d886b60a9aaf322f86a114
-  data.tar.gz: 0ed9a90c182d52d11a70490b78c369ba2ec9cdc1b4cf90c86d306199061d5dc9
+  metadata.gz: 6790fe7a0ed5dd8f89e8916d331548dce3a2fcfbf049221a074ee17f87742826
+  data.tar.gz: c74dd8549a0210341f624228ee24c7ba61b8a070ef9b476dac452b7ebbe8af27
 SHA512:
-  metadata.gz: bba9e06ddabc9ec50fcc6586f53376d5c5a97ddd1745265d76130544b07ebe603375b964bb1d2ede8e32f03963d098df3bca774873a610cee20fad7df11d537c
-  data.tar.gz: b60faf4b9164f883592109a04e64ffb7aaa60972460c26545526c43ad16d2c3ed4a897d9a537a3b285cae4c6435dae8afd96a3303cf7aa2b818afceca65cf17b
+  metadata.gz: 4c0b2d0f48c8acab57dfe9ea5b05ba689e6c5b6ebe634948060b00ec59070767acc6ed548bfde7a76c75ece200b6ba15ecea5b187b90efb3bb2830a47dd5d566
+  data.tar.gz: 7f2fe38052d38f2bf90a66837cf380ee2c4e8363222920cf80cd5b4aac1170f1ad737a44cb336dd55116ccf74a6e563d65f4ab88abedf5f24dacb345ccc89bc8

data/.github/workflows/benchmark.yml

@@ -5,18 +5,16 @@ on: push
 jobs:
   test:
     name: Send metric over UDP
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v1
 
-    - name: Setup Ruby
-      uses: actions/setup-ruby@v1
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: 2.6
-
-    - name: Install dependencies
-      run: gem install bundler && bundle install --jobs 4 --retry 3
+        bundler-cache: true
 
     - name: Run benchmark on branch
       run: benchmark/send-metrics-to-local-udp-receiver

data/.github/workflows/lint.yml

@@ -5,18 +5,16 @@ on: push
 jobs:
   test:
     name: Rubocop
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v1
 
-    - name: Setup Ruby
-      uses: actions/setup-ruby@v1
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: 2.6
-
-    - name: Install dependencies
-      run: gem install bundler && bundle install --jobs 4 --retry 3
+        bundler-cache: true
 
     - name: Run Rubocop
       run: bin/rubocop

data/.github/workflows/tests.yml

@@ -4,12 +4,12 @@ on: push
 
 jobs:
   test:
-    name: Ruby ${{ matrix.ruby }} on ubuntu-18.04
-    runs-on: ubuntu-18.04
+    name: Ruby ${{ matrix.ruby }} on ubuntu-latest
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0']
+        ruby: ['2.6', '2.7', '3.0', '3.1']
 
         # Windows on macOS builds started failing, so they are disabled for noew
         # platform: [windows-2019, macOS-10.14, ubuntu-18.04]
@@ -19,13 +19,11 @@ jobs:
     steps:
     - uses: actions/checkout@v1
 
-    - name: Setup Ruby
-      uses: actions/setup-ruby@v1
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-
-    - name: Install dependencies
-      run: gem install bundler && bundle install --jobs 4 --retry 3
+        bundler-cache: true
 
     - name: Run test suite
-      run: rake test
+      run: bundle exec rake test

data/.rubocop.yml

@@ -5,8 +5,9 @@ require:
   - ./lib/statsd/instrument/rubocop.rb
 
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
   UseCache: true
+  SuggestExtensions: false
   CacheRootDirectory: tmp/rubocop
   Exclude:
     - statsd-instrument.gemspec

data/CHANGELOG.md

@@ -8,6 +8,18 @@ section below.
 
 _Nothing yet_
 
+## Version 3.2.1
+
+- Fix a bug in UDP batching that could cause the Ruby process to be stuck on exit (#291).
+
+## Version 3.2.0
+
+- Add `tag_error_class` option to `statsd_count_success` which tags the class of a thrown error
+
+## Version 3.1.2
+
+ - Fix bug when passing custom client to expectation.
+
 ## Version 3.1.1
 
  - Improved flushing of buffered datagrams on process exit when using UDP batching.

data/Gemfile

@@ -8,6 +8,6 @@ gem "minitest"
 gem "rspec"
 gem "mocha"
 gem "yard"
-gem "rubocop", ">= 1.0"
+gem "rubocop", [">= 1.0", "< 1.30"] # TODO: Our cops are broken by rubocop 1.30, we need to figure out why
 gem "rubocop-shopify", require: false
 gem "benchmark-ips"

data/README.md

@@ -1,6 +1,6 @@
 # StatsD client for Ruby apps
 
-This is a ruby client for statsd (http://github.com/etsy/statsd). It provides
+This is a ruby client for statsd (https://github.com/statsd/statsd). It provides
 a lightweight way to track and measure metrics in your application.
 
 We call out to statsd by sending data over a UDP socket. UDP sockets are fast,
@@ -10,8 +10,8 @@ because it means your code doesn't get bogged down trying to log statistics.
 We send data to statsd several times per request and haven't noticed a
 performance hit.
 
-For more information about StatsD, see the [README of the Etsy
-project](http://github.com/etsy/statsd).
+For more information about StatsD, see the [README of the StatsD
+project](https://github.com/statsd/statsd).
 
 ## Configuration
 
@@ -27,7 +27,7 @@ The following environment variables are supported:
   explicitly, this will be determined based on other environment variables,
   like `RAILS_ENV` or `ENV`. The library will behave differently:
 
-  - In the **production** and **staging** environment, thre library will
+  - In the **production** and **staging** environment, the library will
     actually send UDP packets.
   - In the **test** environment, it will swallow all calls, but allows you to
     capture them for testing purposes. See below for notes on writing tests.

data/benchmark/send-metrics-to-dev-null-log

@@ -6,8 +6,8 @@ require "tmpdir"
 require "benchmark/ips"
 
 revision = %x(git rev-parse HEAD).rstrip
-master_revision = %x(git rev-parse origin/master).rstrip
-branch = if revision == master_revision
+base_revision = %x(git rev-parse origin/master).rstrip
+branch = if revision == base_revision
   "master"
 else
   %x(git rev-parse --abbrev-ref HEAD).rstrip

data/benchmark/send-metrics-to-local-udp-receiver

@@ -8,8 +8,8 @@ require "socket"
 require "statsd-instrument"
 
 revision = %x(git rev-parse HEAD).rstrip
-master_revision = %x(git rev-parse origin/master).rstrip
-branch = if revision == master_revision
+base_revision = %x(git rev-parse origin/master).rstrip
+branch = if revision == base_revision
   "master"
 else
   %x(git rev-parse --abbrev-ref HEAD).rstrip

data/lib/statsd/instrument/assertions.rb

@@ -57,6 +57,7 @@ module StatsD
       def assert_no_statsd_calls(*metric_names, datagrams: nil, client: nil, &block)
         if datagrams.nil?
           raise LocalJumpError, "assert_no_statsd_calls requires a block" unless block_given?
+
           datagrams = capture_statsd_datagrams_with_exception_handling(client: client, &block)
         end
 
@@ -74,7 +75,7 @@ module StatsD
       # @raise [Minitest::Assertion] If an exception occurs, or if the metric did
       #   not occur as specified during the execution the block.
       def assert_statsd_increment(metric_name, value = nil, datagrams: nil, client: nil, **options, &block)
-        expectation = StatsD::Instrument::Expectation.increment(metric_name, value, **options)
+        expectation = StatsD::Instrument::Expectation.increment(metric_name, value, client: client, **options)
         assert_statsd_expectation(expectation, datagrams: datagrams, client: client, &block)
       end
 
@@ -86,7 +87,7 @@ module StatsD
       # @return [void]
       # @raise (see #assert_statsd_increment)
       def assert_statsd_measure(metric_name, value = nil, datagrams: nil, client: nil, **options, &block)
-        expectation = StatsD::Instrument::Expectation.measure(metric_name, value, **options)
+        expectation = StatsD::Instrument::Expectation.measure(metric_name, value, client: client, **options)
         assert_statsd_expectation(expectation, datagrams: datagrams, client: client, &block)
       end
 
@@ -98,7 +99,7 @@ module StatsD
       # @return [void]
       # @raise (see #assert_statsd_increment)
       def assert_statsd_gauge(metric_name, value = nil, datagrams: nil, client: nil, **options, &block)
-        expectation = StatsD::Instrument::Expectation.gauge(metric_name, value, **options)
+        expectation = StatsD::Instrument::Expectation.gauge(metric_name, value, client: client, **options)
         assert_statsd_expectation(expectation, datagrams: datagrams, client: client, &block)
       end
 
@@ -110,7 +111,7 @@ module StatsD
       # @return [void]
       # @raise (see #assert_statsd_increment)
       def assert_statsd_histogram(metric_name, value = nil, datagrams: nil, client: nil, **options, &block)
-        expectation = StatsD::Instrument::Expectation.histogram(metric_name, value, **options)
+        expectation = StatsD::Instrument::Expectation.histogram(metric_name, value, client: client, **options)
         assert_statsd_expectation(expectation, datagrams: datagrams, client: client, &block)
       end
 
@@ -122,7 +123,7 @@ module StatsD
       # @return [void]
       # @raise (see #assert_statsd_increment)
       def assert_statsd_distribution(metric_name, value = nil, datagrams: nil, client: nil, **options, &block)
-        expectation = StatsD::Instrument::Expectation.distribution(metric_name, value, **options)
+        expectation = StatsD::Instrument::Expectation.distribution(metric_name, value, client: client, **options)
         assert_statsd_expectation(expectation, datagrams: datagrams, client: client, &block)
       end
 
@@ -134,7 +135,7 @@ module StatsD
       # @return [void]
       # @raise (see #assert_statsd_increment)
       def assert_statsd_set(metric_name, value = nil, datagrams: nil, client: nil, **options, &block)
-        expectation = StatsD::Instrument::Expectation.set(metric_name, value, **options)
+        expectation = StatsD::Instrument::Expectation.set(metric_name, value, client: client, **options)
         assert_statsd_expectation(expectation, datagrams: datagrams, client: client, &block)
       end
 
@@ -152,6 +153,7 @@ module StatsD
       def assert_statsd_expectations(expectations, datagrams: nil, client: nil, &block)
         if datagrams.nil?
           raise LocalJumpError, "assert_statsd_expectations requires a block" unless block_given?
+
           datagrams = capture_statsd_datagrams_with_exception_handling(client: client, &block)
         end
 

data/lib/statsd/instrument/batched_udp_sink.rb

@@ -29,7 +29,7 @@ module StatsD
       end
 
       def sample?(sample_rate)
-        sample_rate == 1 || rand < sample_rate
+        sample_rate == 1.0 || rand < sample_rate
       end
 
       def <<(datagram)
@@ -64,9 +64,18 @@ module StatsD
             # If the dispatcher thread is dead, we assume it is because
             # the process was forked. So to avoid ending datagrams twice
             # we clear the buffer.
-            @buffer.clear
-            @dispatcher_thread = Thread.new { dispatch }
+            # However if the main the main thread is dead, we won't be able
+            # to spawn a new thread, so we fallback to sending our datagram directly.
+            if Thread.main.alive?
+              @buffer.clear
+              @dispatcher_thread = Thread.new { dispatch }
+            else
+              @buffer << datagram
+              flush
+              return self
+            end
           end
+
           @buffer << datagram
           self
         end

data/lib/statsd/instrument/client.rb

@@ -200,6 +200,7 @@ module StatsD
       def increment(name, value = 1, sample_rate: nil, tags: nil, no_prefix: false)
         sample_rate ||= @default_sample_rate
         return StatsD::Instrument::VOID unless sample?(sample_rate)
+
         emit(datagram_builder(no_prefix: no_prefix).c(name, value, sample_rate, tags))
       end
 
@@ -217,6 +218,7 @@ module StatsD
 
         sample_rate ||= @default_sample_rate
         return StatsD::Instrument::VOID unless sample?(sample_rate)
+
         emit(datagram_builder(no_prefix: no_prefix).ms(name, value, sample_rate, tags))
       end
 
@@ -236,6 +238,7 @@ module StatsD
       def gauge(name, value, sample_rate: nil, tags: nil, no_prefix: false)
         sample_rate ||= @default_sample_rate
         return StatsD::Instrument::VOID unless sample?(sample_rate)
+
         emit(datagram_builder(no_prefix: no_prefix).g(name, value, sample_rate, tags))
       end
 
@@ -249,6 +252,7 @@ module StatsD
       def set(name, value, sample_rate: nil, tags: nil, no_prefix: false)
         sample_rate ||= @default_sample_rate
         return StatsD::Instrument::VOID unless sample?(sample_rate)
+
         emit(datagram_builder(no_prefix: no_prefix).s(name, value, sample_rate, tags))
       end
 
@@ -271,6 +275,7 @@ module StatsD
 
         sample_rate ||= @default_sample_rate
         return StatsD::Instrument::VOID unless sample?(sample_rate)
+
         emit(datagram_builder(no_prefix: no_prefix).d(name, value, sample_rate, tags))
       end
 
@@ -288,6 +293,7 @@ module StatsD
       def histogram(name, value, sample_rate: nil, tags: nil, no_prefix: false)
         sample_rate ||= @default_sample_rate
         return StatsD::Instrument::VOID unless sample?(sample_rate)
+
         emit(datagram_builder(no_prefix: no_prefix).h(name, value, sample_rate, tags))
       end
 

data/lib/statsd/instrument/datagram_builder.rb

@@ -5,18 +5,6 @@ module StatsD
     # @note This class is part of the new Client implementation that is intended
     #   to become the new default in the next major release of this library.
     class DatagramBuilder
-      unless Regexp.method_defined?(:match?) # for ruby 2.3
-        module RubyBackports
-          refine Regexp do
-            def match?(str)
-              match(str) != nil
-            end
-          end
-        end
-
-        using(RubyBackports)
-      end
-
       def self.unsupported_datagram_types(*types)
         types.each do |type|
           define_method(type) do |_, _, _, _|
@@ -79,10 +67,12 @@ module StatsD
       # @return [Array<String>, nil] the list of tags in canonical form.
       def normalize_tags(tags)
         return [] unless tags
+
         tags = tags.map { |k, v| "#{k}:#{v}" } if tags.is_a?(Hash)
 
         # Fast path when no string replacement is needed
         return tags unless tags.any? { |tag| /[|,]/.match?(tag) }
+
         tags.map { |tag| tag.tr("|,", "") }
       end
 
@@ -90,6 +80,7 @@ module StatsD
       def normalize_name(name)
         # Fast path when no normalization is needed to avoid copying the string
         return name unless /[:|@]/.match?(name)
+
         name.tr(":|@", "_")
       end
 

data/lib/statsd/instrument/expectation.rb

@@ -32,9 +32,10 @@ module StatsD
 
       attr_accessor :times, :type, :name, :value, :sample_rate, :tags
 
-      def initialize(client: StatsD.singleton_client, type:, name:, value: nil,
+      def initialize(client: nil, type:, name:, value: nil,
         sample_rate: nil, tags: nil, no_prefix: false, times: 1)
 
+        client ||= StatsD.singleton_client
         @type = type
         @name = no_prefix || !client.prefix ? name : "#{client.prefix}.#{name}"
         @value = normalized_value_for_type(type, value) if value
@@ -78,19 +79,6 @@ module StatsD
 
       private
 
-      # Needed for normalize_tags
-      unless Regexp.method_defined?(:match?) # for ruby 2.3
-        module RubyBackports
-          refine Regexp do
-            def match?(str)
-              (self =~ str) != nil
-            end
-          end
-        end
-
-        using(RubyBackports)
-      end
-
       # @private
       #
       # Utility function to convert tags to the canonical form.
@@ -105,10 +93,12 @@ module StatsD
       #   to ensure that this logic matches the logic of the active datagram builder.
       def normalize_tags(tags)
         return [] unless tags
+
         tags = tags.map { |k, v| "#{k}:#{v}" } if tags.is_a?(Hash)
 
         # Fast path when no string replacement is needed
         return tags unless tags.any? { |tag| /[|,]/.match?(tag) }
+
         tags.map { |tag| tag.tr("|,", "") }
       end
     end

data/lib/statsd/instrument/helpers.rb

@@ -10,6 +10,22 @@ module StatsD
 
       # For backwards compatibility
       alias_method :capture_statsd_calls, :capture_statsd_datagrams
+
+      def self.add_tag(tags, key, value)
+        tags = tags.dup || {}
+
+        if tags.is_a?(String)
+          tags = tags.empty? ? "#{key}:#{value}" : "#{tags},#{key}:#{value}"
+        elsif tags.is_a?(Array)
+          tags << "#{key}:#{value}"
+        elsif tags.is_a?(Hash)
+          tags[key] = value
+        else
+          raise ArgumentError, "add_tag only supports string, array or hash, #{tags.class} provided"
+        end
+
+        tags
+      end
     end
   end
 end

data/lib/statsd/instrument/matchers.rb

@@ -49,7 +49,7 @@ module StatsD
             raise RSpec::Expectations::ExpectationNotMetError, "No StatsD calls for metric #{metric_name} were made."
           elsif options[:times] && options[:times] != metrics.length
             raise RSpec::Expectations::ExpectationNotMetError, "The numbers of StatsD calls for metric " \
-             "#{metric_name} was unexpected. Expected #{options[:times].inspect}, got #{metrics.length}"
+              "#{metric_name} was unexpected. Expected #{options[:times].inspect}, got #{metrics.length}"
           end
 
           [:sample_rate, :value, :tags].each do |expectation|

data/lib/statsd/instrument/rubocop/metric_return_value.rb

@@ -19,7 +19,7 @@ module RuboCop
 
         MSG = "Do not use the return value of StatsD metric methods"
 
-        INVALID_PARENTS = %i{lvasgn array pair send return yield}
+        INVALID_PARENTS = [:lvasgn, :array, :pair, :send, :return, :yield]
 
         def on_send(node)
           if metric_method?(node) && node.arguments.last&.type != :block_pass

data/lib/statsd/instrument/rubocop/positional_arguments.rb

@@ -41,7 +41,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          -> (corrector) do
+          ->(corrector) do
             positional_arguments = if node.arguments.last.type == :block_pass
               node.arguments[2...node.arguments.length - 1]
             else

data/lib/statsd/instrument/rubocop.rb

@@ -3,34 +3,13 @@
 module RuboCop
   module Cop
     module StatsD
-      METRIC_METHODS = %i{
-        increment
-        gauge
-        measure
-        set
-        histogram
-        distribution
-        key_value
-      }
+      METRIC_METHODS = [:increment, :gauge, :measure, :set, :histogram, :distribution, :key_value]
 
-      METAPROGRAMMING_METHODS = %i{
-        statsd_measure
-        statsd_distribution
-        statsd_count_success
-        statsd_count_if
-        statsd_count
-      }
+      METAPROGRAMMING_METHODS = [:statsd_measure, :statsd_distribution, :statsd_count_success, :statsd_count_if,
+                                 :statsd_count,]
 
-      SINGLETON_CONFIGURATION_METHODS = %i{
-        backend
-        backend=
-        prefix
-        prefix=
-        default_tags
-        default_tags=
-        default_sample_rate
-        default_sample_rate=
-      }
+      SINGLETON_CONFIGURATION_METHODS = [:backend, :"backend=", :prefix, :"prefix=", :default_tags, :"default_tags=",
+                                         :default_sample_rate, :"default_sample_rate=",]
 
       private
 
@@ -60,6 +39,7 @@ module RuboCop
 
       def keyword_arguments(node)
         return nil if node.arguments.empty?
+
         last_argument = if node.arguments.last&.type == :block_pass
           node.arguments[node.arguments.length - 2]
         else

data/lib/statsd/instrument/statsd_datagram_builder.rb

@@ -11,6 +11,7 @@ module StatsD
 
       def normalize_tags(tags)
         raise NotImplementedError, "#{self.class.name} does not support tags" if tags
+
         super
       end
     end

data/lib/statsd/instrument/strict.rb

@@ -27,6 +27,7 @@ module StatsD
       def increment(key, value = 1, sample_rate: nil, tags: nil, 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?(Integer)
+
         check_tags_and_sample_rate(sample_rate, tags)
 
         super
@@ -35,6 +36,7 @@ module StatsD
       def gauge(key, value, sample_rate: nil, tags: nil, 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
@@ -43,6 +45,7 @@ module StatsD
       def histogram(key, value, sample_rate: nil, tags: nil, 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
@@ -50,6 +53,7 @@ module StatsD
 
       def set(key, value, sample_rate: nil, tags: nil, no_prefix: false)
         raise ArgumentError, "StatsD.set does not accept a block" if block_given?
+
         check_tags_and_sample_rate(sample_rate, tags)
 
         super

data/lib/statsd/instrument/udp_sink.rb

@@ -20,19 +20,17 @@ module StatsD
       end
 
       def sample?(sample_rate)
-        sample_rate == 1 || rand < sample_rate
+        sample_rate == 1.0 || rand < sample_rate
       end
 
       def <<(datagram)
         with_socket { |socket| socket.send(datagram, 0) }
         self
-
       rescue ThreadError
         # In cases where a TERM or KILL signal has been sent, and we send stats as
         # part of a signal handler, locks cannot be acquired, so we do our best
         # to try and send the datagram without a lock.
         socket.send(datagram, 0) > 0
-
       rescue SocketError, IOError, SystemCallError => error
         StatsD.logger.debug do
           "[StatsD::Instrument::UDPSink] Resetting connection because of #{error.class}: #{error.message}"

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "3.1.1"
+    VERSION = "3.2.1"
   end
 end

data/lib/statsd/instrument.rb

@@ -104,24 +104,26 @@ module StatsD
     # @param method (see #statsd_measure)
     # @param name (see #statsd_measure)
     # @param metric_options (see #statsd_measure)
+    # @param tag_error_class add a <tt>error_class</tt> tag with the error class when an error is thrown
     # @yield You can pass a block to this method if you want to define yourself what is a successful call
     #   based on the return value of the method.
     # @yieldparam result The return value of the instrumented method.
     # @yieldreturn [Boolean] Return true iff the return value is considered a success, false otherwise.
     # @return [void]
     # @see #statsd_count_if
-    def statsd_count_success(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
+    def statsd_count_success(method, name, sample_rate: nil,
+      tags: nil, no_prefix: false, client: nil, tag_error_class: false)
       add_to_method(method, name, :count_success) do
         define_method(method) do |*args, &block|
           truthiness = result = super(*args, &block)
-        rescue
+        rescue => error
           truthiness = false
           raise
         else
           if block_given?
             begin
               truthiness = yield(result)
-            rescue
+            rescue => error
               truthiness = false
             end
           end
@@ -130,6 +132,9 @@ module StatsD
           client ||= StatsD.singleton_client
           suffix = truthiness == false ? "failure" : "success"
           key = StatsD::Instrument.generate_metric_name(name, self, *args)
+
+          tags = Helpers.add_tag(tags, :error_class, error.class.name) if tag_error_class && error
+
           client.increment("#{key}.#{suffix}", sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
         end
       end

data/test/assertions_test.rb

@@ -440,4 +440,17 @@ class AssertionsTest < Minitest::Test
       StatsD.increment("incr", no_prefix: true)
     end
   end
+
+  def test_client_propagation_to_expectations
+    foo_1_metric = StatsD::Instrument::Expectation.increment("foo")
+    @test_case.assert_statsd_expectations([foo_1_metric]) do
+      StatsD.increment("foo")
+    end
+
+    client = StatsD::Instrument::Client.new(prefix: "prefix")
+    foo_2_metric = StatsD::Instrument::Expectation.increment("foo", client: client)
+    @test_case.assert_statsd_expectations([foo_2_metric]) do
+      StatsD.increment("prefix.foo")
+    end
+  end
 end

data/test/datagram_builder_test.rb

@@ -16,7 +16,7 @@ class DatagramBuilderTest < Minitest::Test
 
   def test_normalize_unsupported_tag_names
     assert_equal(["ign#ored"], @datagram_builder.send(:normalize_tags, ["ign#o|re,d"]))
-    # Note: how this is interpreted by the backend is undefined.
+    # NOTE: how this is interpreted by the backend is undefined.
     # We rely on the user to not do stuff like this if they don't want to be surprised.
     # We do not want to take the performance hit of normalizing this.
     assert_equal(["lol::class:omg::lol"], @datagram_builder.send(:normalize_tags, "lol::class" => "omg::lol"))

data/test/helpers_test.rb

@@ -35,8 +35,47 @@ class HelpersTest < Minitest::Test
     StatsD.gauge("gauge", 15)
 
     assert_equal(2, metrics.length)
-
   ensure
     StatsD.singleton_client = @old_client
   end
+
+  def test_add_tag_works_for_nil
+    assert_equal({ key: 123 }, StatsD::Instrument::Helpers.add_tag(nil, :key, 123))
+  end
+
+  def test_add_tag_works_for_hashes
+    assert_equal({ key: 123 }, StatsD::Instrument::Helpers.add_tag({}, :key, 123))
+
+    existing = { existing: 123 }
+    assert_equal({ existing: 123, new: 456 }, StatsD::Instrument::Helpers.add_tag(existing, :new, 456))
+
+    # ensure we do not modify the existing tags
+    assert_equal({ existing: 123 }, existing)
+  end
+
+  def test_add_tag_works_for_arrays
+    assert_equal(["key:123"], StatsD::Instrument::Helpers.add_tag([], :key, 123))
+
+    existing = ["existing:123"]
+    assert_equal(["existing:123", "new:456"], StatsD::Instrument::Helpers.add_tag(existing, :new, 456))
+
+    # ensure we do not modify the existing tags
+    assert_equal(["existing:123"], existing)
+  end
+
+  def test_add_tag_works_for_strings
+    assert_equal("key:123", StatsD::Instrument::Helpers.add_tag("", :key, 123))
+
+    existing = "existing:123"
+    assert_equal("existing:123,new:456", StatsD::Instrument::Helpers.add_tag(existing, :new, 456))
+
+    # ensure we do not modify the existing tags
+    assert_equal("existing:123", existing)
+  end
+
+  def test_add_tags_raises_for_other
+    assert_raises(ArgumentError, "add_tag only supports string, array or hash, Integer provided") do
+      StatsD::Instrument::Helpers.add_tag(1, :key, 123)
+    end
+  end
 end

data/test/statsd_instrumentation_test.rb

@@ -159,6 +159,38 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::UniqueGateway.statsd_remove_count_success(:ssl_post, "ActiveMerchant.Gateway")
   end
 
+  def test_statsd_count_success_tag_error_class
+    ActiveMerchant::Base.statsd_count_success(:ssl_post, "ActiveMerchant.Base", tag_error_class: true)
+
+    assert_statsd_increment("ActiveMerchant.Base.success", tags: nil) do
+      ActiveMerchant::Base.new.ssl_post(true)
+    end
+
+    assert_statsd_increment("ActiveMerchant.Base.failure", tags: ["error_class:RuntimeError"]) do
+      assert_raises(RuntimeError, "Not OK") do
+        ActiveMerchant::Base.new.ssl_post(false)
+      end
+    end
+  ensure
+    ActiveMerchant::Base.statsd_remove_count_success(:ssl_post, "ActiveMerchant.Base")
+  end
+
+  def test_statsd_count_success_tag_error_class_is_opt_in
+    ActiveMerchant::Base.statsd_count_success(:ssl_post, "ActiveMerchant.Base")
+
+    assert_statsd_increment("ActiveMerchant.Base.success", tags: nil) do
+      ActiveMerchant::Base.new.ssl_post(true)
+    end
+
+    assert_statsd_increment("ActiveMerchant.Base.failure", tags: nil) do
+      assert_raises(RuntimeError, "Not OK") do
+        ActiveMerchant::Base.new.ssl_post(false)
+      end
+    end
+  ensure
+    ActiveMerchant::Base.statsd_remove_count_success(:ssl_post, "ActiveMerchant.Base")
+  end
+
   def test_statsd_count
     ActiveMerchant::Gateway.statsd_count(:ssl_post, "ActiveMerchant.Gateway.ssl_post")
 
@@ -345,7 +377,7 @@ class StatsDInstrumentationTest < Minitest::Test
     client = StatsD::Instrument::Client.new(prefix: "prefix")
 
     ActiveMerchant::Gateway.statsd_count(:ssl_post, "ActiveMerchant.Gateway.ssl_post", client: client)
-    assert_statsd_increment("prefix.ActiveMerchant.Gateway.ssl_post", client: client) do
+    assert_statsd_increment("ActiveMerchant.Gateway.ssl_post", client: client) do
       ActiveMerchant::Gateway.new.purchase(true)
     end
   ensure

data/test/udp_sink_test.rb

@@ -136,7 +136,7 @@ module UDPSinkTests
 
         assert_equal(
           "[#{@sink_class}] Resetting connection because of " \
-          "Errno::EDESTADDRREQ: Destination address required\n",
+            "Errno::EDESTADDRREQ: Destination address required\n",
           logs.string,
         )
       ensure

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.1
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2022-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -87,7 +87,6 @@ files:
 - statsd-instrument.gemspec
 - test/assertions_test.rb
 - test/benchmark/clock_gettime.rb
-- test/benchmark/default_tags.rb
 - test/benchmark/metrics.rb
 - test/benchmark/tags.rb
 - test/capture_sink_test.rb
@@ -135,14 +134,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: A StatsD client for Ruby apps
 test_files:
 - test/assertions_test.rb
 - test/benchmark/clock_gettime.rb
-- test/benchmark/default_tags.rb
 - test/benchmark/metrics.rb
 - test/benchmark/tags.rb
 - test/capture_sink_test.rb

data/test/benchmark/default_tags.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "statsd-instrument"
-require "benchmark/ips"
-
-StatsD.logger = Logger.new(File::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