statsd-instrument 2.5.1 → 2.6.0

data/lib/statsd/instrument/strict.rb

@@ -24,15 +24,15 @@ module StatsD
     #
     # 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)
+      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?(Numeric)
+        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
       end
 
-      def gauge(key, value, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      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)
@@ -40,7 +40,7 @@ module StatsD
         super
       end
 
-      def histogram(key, value, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      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)
@@ -48,25 +48,33 @@ module StatsD
         super
       end
 
-      def set(key, value, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      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
       end
 
-      def measure(key, value = UNSPECIFIED, sample_rate: nil, tags: nil,
-        prefix: StatsD.prefix, no_prefix: false, as_dist: false, &block)
+      def service_check(name, status, tags: nil, no_prefix: false,
+        hostname: nil, timestamp: nil, message: nil)
+
+        super
+      end
+
+      def event(title, text, tags: nil, no_prefix: false,
+        hostname: nil, timestamp: nil, aggregation_key: nil, priority: nil, source_type_name: nil, alert_type: nil)
+
+        super
+      end
 
+      def measure(key, value = UNSPECIFIED, sample_rate: nil, tags: nil, no_prefix: 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)
-
+      def distribution(key, value = UNSPECIFIED, sample_rate: nil, tags: nil, no_prefix: false, &block)
         check_block_or_numeric_value(value, &block)
         check_tags_and_sample_rate(sample_rate, tags)
 
@@ -99,31 +107,113 @@ module StatsD
     end
 
     module StrictMetaprogramming
-      def statsd_measure(method, name, sample_rate: nil, tags: nil,
-        prefix: StatsD.prefix, no_prefix: false, as_dist: false)
-
+      def statsd_measure(method, name, sample_rate: nil, tags: nil, no_prefix: false)
         check_method_and_metric_name(method, name)
-        super
+
+        # Unfortunately, we have to inline the new method implementation ebcause 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(name, self, *args)
+            StatsD.measure(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
+              super(*args, &block)
+            end
+          end
+        end
       end
 
-      def statsd_distribution(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      def statsd_distribution(method, name, sample_rate: nil, tags: nil, no_prefix: false)
         check_method_and_metric_name(method, name)
-        super
+
+        # Unfortunately, we have to inline the new method implementation ebcause 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(name, self, *args)
+            StatsD.distribution(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
+              super(*args, &block)
+            end
+          end
+        end
       end
 
-      def statsd_count_success(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      def statsd_count_success(method, name, sample_rate: nil, tags: nil, no_prefix: false)
         check_method_and_metric_name(method, name)
-        super
+
+        # Unfortunately, we have to inline the new method implementation ebcause 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(name, self, *args)}.#{suffix}"
+              StatsD.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+            end
+          end
+        end
       end
 
-      def statsd_count_if(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      def statsd_count_if(method, name, sample_rate: nil, tags: nil, no_prefix: false)
         check_method_and_metric_name(method, name)
-        super
+
+        # Unfortunately, we have to inline the new method implementation ebcause 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(name, self, *args)
+                StatsD.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+              end
+            end
+          end
+        end
       end
 
-      def statsd_count(method, name, sample_rate: nil, tags: nil, prefix: StatsD.prefix, no_prefix: false)
+      def statsd_count(method, name, sample_rate: nil, tags: nil, no_prefix: false)
         check_method_and_metric_name(method, name)
-        super
+
+        # Unfortunately, we have to inline the new method implementation ebcause 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(name, self, *args)
+            StatsD.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+            super(*args, &block)
+          end
+        end
       end
 
       private

data/lib/statsd/instrument/udp_sink.rb

@@ -0,0 +1,62 @@
+# 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::UDPSink
+  def self.for_addr(addr)
+    host, port_as_string = addr.split(':', 2)
+    new(host, Integer(port_as_string))
+  end
+
+  attr_reader :host, :port
+
+  def initialize(host, port)
+    @host = host
+    @port = port
+    @mutex = Mutex.new
+    @socket = nil
+  end
+
+  def sample?(sample_rate)
+    sample_rate == 1 || rand < sample_rate
+  end
+
+  def <<(datagram)
+    with_socket { |socket| socket.send(datagram, 0) > 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
+    # TODO: log?
+    invalidate_socket
+  end
+
+  def addr
+    "#{host}:#{port}"
+  end
+
+  private
+
+  def with_socket
+    @mutex.synchronize { yield(socket) }
+  end
+
+  def socket
+    if @socket.nil?
+      @socket = UDPSocket.new
+      @socket.connect(@host, @port)
+    end
+    @socket
+  end
+
+  def invalidate_socket
+    @mutex.synchronize do
+      @socket = nil
+    end
+  end
+end

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "2.5.1"
+    VERSION = "2.6.0"
   end
 end