statsd-instrument 2.9.2 → 3.0.2

data/lib/statsd/instrument/helpers.rb

@@ -1,40 +1,15 @@
 # frozen_string_literal: true
 
-module StatsD::Instrument::Helpers
-  def capture_statsd_datagrams(client: nil, &block)
-    client ||= StatsD.singleton_client
-    case client
-    when StatsD.legacy_singleton_client
-      capture_statsd_metrics_on_legacy_client(&block)
-    when StatsD::Instrument::Client
-      client.capture(&block)
-    else
-      raise ArgumentError, "Don't know how to capture StatsD datagrams from #{client.inspect}!"
-    end
-  end
-
-  # For backwards compatibility
-  alias_method :capture_statsd_calls, :capture_statsd_datagrams
-
-  def capture_statsd_metrics_on_legacy_client(&block)
-    capture_backend = StatsD::Instrument::Backends::CaptureBackend.new
-    with_capture_backend(capture_backend, &block)
-    capture_backend.collected_metrics
-  end
-
-  private
-
-  def with_capture_backend(backend)
-    if StatsD.legacy_singleton_client.backend.is_a?(StatsD::Instrument::Backends::CaptureBackend)
-      backend.parent = StatsD.legacy_singleton_client.backend
-    end
-
-    old_backend = StatsD.legacy_singleton_client.backend
-    begin
-      StatsD.legacy_singleton_client.backend = backend
-      yield
-    ensure
-      StatsD.legacy_singleton_client.backend = old_backend
+module StatsD
+  module Instrument
+    module Helpers
+      def capture_statsd_datagrams(client: nil, &block)
+        client ||= StatsD.singleton_client
+        client.capture(&block)
+      end
+
+      # For backwards compatibility
+      alias_method :capture_statsd_calls, :capture_statsd_datagrams
     end
   end
 end

data/lib/statsd/instrument/log_sink.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
-# @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 StatsD::Instrument::LogSink
-  attr_reader :logger, :severity
+module StatsD
+  module Instrument
+    # @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 LogSink
+      attr_reader :logger, :severity
 
-  def initialize(logger, severity: Logger::DEBUG)
-    @logger = logger
-    @severity = severity
-  end
+      def initialize(logger, severity: Logger::DEBUG)
+        @logger = logger
+        @severity = severity
+      end
 
-  def sample?(_sample_rate)
-    true
-  end
+      def sample?(_sample_rate)
+        true
+      end
 
-  def <<(datagram)
-    # Some implementations require a newline at the end of datagrams.
-    # When logging, we make sure those newlines are removed using chomp.
+      def <<(datagram)
+        # Some implementations require a newline at the end of datagrams.
+        # When logging, we make sure those newlines are removed using chomp.
 
-    logger.add(severity, "[StatsD] #{datagram.chomp}")
-    self
+        logger.add(severity, "[StatsD] #{datagram.chomp}")
+        self
+      end
+    end
   end
 end

data/lib/statsd/instrument/matchers.rb

@@ -3,98 +3,113 @@
 require 'rspec/expectations'
 require 'rspec/core/version'
 
-module StatsD::Instrument::Matchers
-  CUSTOM_MATCHERS = {
-    increment: :c,
-    measure: :ms,
-    gauge: :g,
-    histogram: :h,
-    distribution: :d,
-    set: :s,
-    key_value: :kv,
-  }
-
-  class Matcher
-    include RSpec::Matchers::Composable if RSpec::Core::Version::STRING.start_with?('3')
-    include StatsD::Instrument::Helpers
-
-    def initialize(metric_type, metric_name, options = {})
-      @metric_type = metric_type
-      @metric_name = metric_name
-      @options = options
-    end
+module StatsD
+  module Instrument
+    module Matchers
+      class Matcher
+        include(RSpec::Matchers::Composable) if RSpec::Core::Version::STRING.start_with?('3')
+        include StatsD::Instrument::Helpers
+
+        def initialize(metric_type, metric_name, options = {})
+          @metric_type = metric_type
+          @metric_name = metric_name
+          @options = options
+        end
 
-    def matches?(block)
-      expect_statsd_call(@metric_type, @metric_name, @options, &block)
-    rescue RSpec::Expectations::ExpectationNotMetError => e
-      @message = e.message
-      false
-    end
+        def matches?(block)
+          expect_statsd_call(@metric_type, @metric_name, @options, &block)
+        rescue RSpec::Expectations::ExpectationNotMetError => e
+          @message = e.message
+          false
+        end
 
-    def failure_message
-      @message
-    end
+        def failure_message
+          @message
+        end
 
-    def failure_message_when_negated
-      "No StatsD calls for metric #{@metric_name} expected."
-    end
+        def failure_message_when_negated
+          "No StatsD calls for metric #{@metric_name} expected."
+        end
 
-    def supports_block_expectations?
-      true
-    end
+        def supports_block_expectations?
+          true
+        end
 
-    private
+        private
 
-    def expect_statsd_call(metric_type, metric_name, options, &block)
-      metrics = capture_statsd_calls(&block)
-      metrics = metrics.select { |m| m.type == metric_type && m.name == metric_name }
+        def expect_statsd_call(metric_type, metric_name, options, &block)
+          metrics = capture_statsd_calls(&block)
+          metrics = metrics.select { |m| m.type == metric_type && m.name == metric_name }
 
-      if metrics.empty?
-        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}"
-      end
+          if metrics.empty?
+            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}"
+          end
+
+          [:sample_rate, :value, :tags].each do |expectation|
+            next unless options[expectation]
+
+            num_matches = metrics.count do |m|
+              matcher = RSpec::Matchers::BuiltIn::Match.new(options[expectation])
+              matcher.matches?(m.public_send(expectation))
+            end
 
-      [:sample_rate, :value, :tags].each do |expectation|
-        next unless options[expectation]
+            found = options[:times] ? num_matches == options[:times] : num_matches > 0
 
-        num_matches = metrics.count do |m|
-          matcher = RSpec::Matchers::BuiltIn::Match.new(options[expectation])
-          matcher.matches?(m.public_send(expectation))
+            unless found
+              message = metric_information(metric_name, options, metrics, expectation)
+              raise RSpec::Expectations::ExpectationNotMetError, message
+            end
+          end
+
+          true
         end
 
-        found = options[:times] ? num_matches == options[:times] : num_matches > 0
+        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]}"
 
-        unless found
-          message = metric_information(metric_name, options, metrics, expectation)
-          raise RSpec::Expectations::ExpectationNotMetError, message
+          message += "\n  captured metric values: #{metrics.map(&expectation).join(', ')}"
+
+          message
         end
       end
 
-      true
-    end
+      Increment = Class.new(Matcher)
+      Measure = Class.new(Matcher)
+      Gauge = Class.new(Matcher)
+      Set = Class.new(Matcher)
+      Histogram = Class.new(Matcher)
+      Distribution = Class.new(Matcher)
 
-    def metric_information(metric_name, options, metrics, expectation)
-      message = "expected StatsD #{expectation.inspect} for metric '#{metric_name}' to be called"
+      def trigger_statsd_increment(metric_name, options = {})
+        Increment.new(:c, metric_name, options)
+      end
 
-      message += "\n  "
-      message += options[:times] ? "exactly #{options[:times]} times" : "at least once"
-      message += " with: #{options[expectation]}"
+      def trigger_statsd_measure(metric_name, options = {})
+        Measure.new(:ms, metric_name, options)
+      end
 
-      message += "\n  captured metric values: #{metrics.map(&expectation).join(', ')}"
+      def trigger_statsd_gauge(metric_name, options = {})
+        Gauge.new(:g, metric_name, options)
+      end
 
-      message
-    end
-  end
+      def trigger_statsd_set(metric_name, options = {})
+        Set.new(:s, metric_name, options)
+      end
 
-  CUSTOM_MATCHERS.each do |method_name, metric_type|
-    klass = Class.new(Matcher)
+      def trigger_statsd_histogram(metric_name, options = {})
+        Histogram.new(:h, metric_name, options)
+      end
 
-    define_method "trigger_statsd_#{method_name}" do |metric_name, options = {}|
-      klass.new(metric_type, metric_name, options)
+      def trigger_statsd_distribution(metric_name, options = {})
+        Distribution.new(:d, metric_name, options)
+      end
     end
-
-    StatsD::Instrument::Matchers.const_set(method_name.capitalize, klass)
   end
 end

data/lib/statsd/instrument/null_sink.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
-# @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 StatsD::Instrument::NullSink
-  def sample?(_sample_rate)
-    true
-  end
+module StatsD
+  module Instrument
+    # @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 NullSink
+      def sample?(_sample_rate)
+        true
+      end
 
-  def <<(_datagram)
-    self # noop
+      def <<(_datagram)
+        self # noop
+      end
+    end
   end
 end

data/lib/statsd/instrument/railtie.rb

@@ -1,15 +1,15 @@
 # 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
-
-  initializer 'statsd-instrument.setup_backend', after: 'statsd-instrument.use_rails_logger' do
-    ::StatsD.backend = ::StatsD::Instrument::Environment.default_backend
+module StatsD
+  module Instrument
+    # 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 Railtie < Rails::Railtie
+      initializer 'statsd-instrument.use_rails_logger' do
+        ::StatsD.logger = Rails.logger
+      end
+    end
   end
 end

data/lib/statsd/instrument/statsd_datagram_builder.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-# @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 StatsD::Instrument::StatsDDatagramBuilder < StatsD::Instrument::DatagramBuilder
-  unsupported_datagram_types :h, :d, :kv
+module StatsD
+  module Instrument
+    # @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 StatsDDatagramBuilder < StatsD::Instrument::DatagramBuilder
+      unsupported_datagram_types :h, :d, :kv
 
-  protected
+      protected
 
-  def normalize_tags(tags)
-    raise NotImplementedError, "#{self.class.name} does not support tags" if tags
-    super
+      def normalize_tags(tags)
+        raise NotImplementedError, "#{self.class.name} does not support tags" if tags
+        super
+      end
+    end
   end
 end

data/lib/statsd/instrument/strict.rb

@@ -55,9 +55,7 @@ module StatsD
         super
       end
 
-      def service_check(name, status, tags: nil, no_prefix: false,
-        hostname: nil, timestamp: nil, message: nil)
-
+      def service_check(name, status, tags: nil, no_prefix: false, hostname: nil, timestamp: nil, message: nil)
         super
       end
 
@@ -81,11 +79,6 @@ module StatsD
         super
       end
 
-      def key_value(*)
-        raise NotImplementedError, "The key_value metric type will be removed " \
-          "from the next major version of statsd-instrument"
-      end
-
       private
 
       def check_block_or_numeric_value(value)
@@ -106,133 +99,30 @@ module StatsD
       end
     end
 
-    module VoidCollectMetric
-      protected
-
-      def collect_metric(type, name, value, sample_rate:, tags: nil, prefix:, metadata: nil)
-        super
-        StatsD::Instrument::VOID
-      end
-    end
-
     module StrictMetaprogramming
-      def statsd_measure(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_measure(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.measure call to not use the `as_dist` and `prefix` arguments.
-        add_to_method(method, name, :measure) do
-          define_method(method) do |*args, &block|
-            key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-            client.measure(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
-              super(*args, &block)
-            end
-          end
-        end
+        super
       end
 
-      def statsd_distribution(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_distribution(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.distribution call to not use the `prefix` argument.
-
-        add_to_method(method, name, :distribution) do
-          define_method(method) do |*args, &block|
-            key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-            client.distribution(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
-              super(*args, &block)
-            end
-          end
-        end
+        super
       end
 
-      def statsd_count_success(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_count_success(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.increment call to not use the `prefix` argument.
-
-        add_to_method(method, name, :count_success) do
-          define_method(method) do |*args, &block|
-            begin
-              truthiness = result = super(*args, &block)
-            rescue
-              truthiness = false
-              raise
-            else
-              if block_given?
-                begin
-                  truthiness = yield(result)
-                rescue
-                  truthiness = false
-                end
-              end
-              result
-            ensure
-              suffix = truthiness == false ? 'failure' : 'success'
-              key = "#{StatsD::Instrument.generate_metric_name(nil, name, self, *args)}.#{suffix}"
-              client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
-            end
-          end
-        end
+        super
       end
 
-      def statsd_count_if(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_count_if(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.increment call to not use the `prefix` argument.
-
-        add_to_method(method, name, :count_if) do
-          define_method(method) do |*args, &block|
-            begin
-              truthiness = result = super(*args, &block)
-            rescue
-              truthiness = false
-              raise
-            else
-              if block_given?
-                begin
-                  truthiness = yield(result)
-                rescue
-                  truthiness = false
-                end
-              end
-              result
-            ensure
-              if truthiness
-                key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-                client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
-              end
-            end
-          end
-        end
+        super
       end
 
-      def statsd_count(method, name, sample_rate: nil, tags: nil,
-        no_prefix: false, client: StatsD.singleton_client)
-
+      def statsd_count(method, name, sample_rate: nil, tags: nil, no_prefix: false, client: nil)
         check_method_and_metric_name(method, name)
-
-        # Unfortunately, we have to inline the new method implementation because we have to fix the
-        # Stats.increment call to not use the `prefix` argument.
-
-        add_to_method(method, name, :count) do
-          define_method(method) do |*args, &block|
-            key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-            client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
-            super(*args, &block)
-          end
-        end
+        super
       end
 
       private
@@ -250,6 +140,5 @@ module StatsD
   end
 end
 
-StatsD.singleton_class.prepend(StatsD::Instrument::Strict)
-StatsD::Instrument::LegacyClient.prepend(StatsD::Instrument::VoidCollectMetric)
+StatsD::Instrument::Client.prepend(StatsD::Instrument::Strict)
 StatsD::Instrument.prepend(StatsD::Instrument::StrictMetaprogramming)