statsd-instrument 2.8.0 → 2.9.0

data/lib/statsd/instrument/datagram.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# The Datagram class parses and inspects a StatsD datagrans
+# The Datagram class parses and inspects a StatsD datagrams
 #
 # @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.
@@ -72,7 +72,6 @@ class StatsD::Instrument::Datagram
     \n? # In some implementations, the datagram may include a trailing newline.
     \z
   }x
-  private_constant :PARSER
 
   def parsed_datagram
     @parsed ||= if (match_info = PARSER.match(@source))

data/lib/statsd/instrument/datagram_builder.rb

@@ -18,7 +18,7 @@ class StatsD::Instrument::DatagramBuilder
   def self.unsupported_datagram_types(*types)
     types.each do |type|
       define_method(type) do |_, _, _, _|
-        raise NotImplementedError, "Type #{type} metrics are not suppered by #{self.class.name}."
+        raise NotImplementedError, "Type #{type} metrics are not supported by #{self.class.name}."
       end
     end
   end

data/lib/statsd/instrument/dogstatsd_datagram.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# The Datagram class parses and inspects a StatsD datagrams
+#
+# @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::DogStatsDDatagram < StatsD::Instrument::Datagram
+  def name
+    @name ||= case type
+    when :_e then parsed_datagram[:name].gsub('\n', "\n")
+    else super
+    end
+  end
+
+  def value
+    @value ||= case type
+    when :_sc then Integer(parsed_datagram[:value])
+    when :_e then parsed_datagram[:value].gsub('\n', "\n")
+    else super
+    end
+  end
+
+  def hostname
+    parsed_datagram[:hostname]
+  end
+
+  def timestamp
+    Time.at(Integer(parsed_datagram[:timestamp])).utc
+  end
+
+  def aggregation_key
+    parsed_datagram[:aggregation_key]
+  end
+
+  def source_type_name
+    parsed_datagram[:source_type_name]
+  end
+
+  def priority
+    parsed_datagram[:priority]
+  end
+
+  def alert_type
+    parsed_datagram[:alert_type]
+  end
+
+  def message
+    parsed_datagram[:message]
+  end
+
+  protected
+
+  def parsed_datagram
+    @parsed ||= if (match_info = PARSER.match(@source))
+      match_info
+    else
+      raise ArgumentError, "Invalid DogStatsD datagram: #{@source}"
+    end
+  end
+
+  SERVICE_CHECK_PARSER = %r{
+    \A
+    (?<type>_sc)\|(?<name>[^\|]+)\|(?<value>\d+)
+    (?:\|h:(?<hostname>[^\|]+))?
+    (?:\|d:(?<timestamp>\d+))?
+    (?:\|\#(?<tags>(?:[^\|,]+(?:,[^\|,]+)*)))?
+    (?:\|m:(?<message>[^\|]+))?
+    \n? # In some implementations, the datagram may include a trailing newline.
+    \z
+  }x
+
+  # |k:my-key|p:low|s:source|t:success|
+  EVENT_PARSER = %r{
+    \A
+    (?<type>_e)\{\d+\,\d+\}:(?<name>[^\|]+)\|(?<value>[^\|]+)
+    (?:\|h:(?<hostname>[^\|]+))?
+    (?:\|d:(?<timestamp>\d+))?
+    (?:\|k:(?<aggregation_key>[^\|]+))?
+    (?:\|p:(?<priority>[^\|]+))?
+    (?:\|s:(?<source_type_name>[^\|]+))?
+    (?:\|t:(?<alert_type>[^\|]+))?
+    (?:\|\#(?<tags>(?:[^\|,]+(?:,[^\|,]+)*)))?
+    \n? # In some implementations, the datagram may include a trailing newline.
+    \z
+  }x
+
+  PARSER = Regexp.union(StatsD::Instrument::Datagram::PARSER, SERVICE_CHECK_PARSER, EVENT_PARSER)
+end

data/lib/statsd/instrument/dogstatsd_datagram_builder.rb

@@ -5,6 +5,10 @@
 class StatsD::Instrument::DogStatsDDatagramBuilder < StatsD::Instrument::DatagramBuilder
   unsupported_datagram_types :kv
 
+  def self.datagram_class
+    StatsD::Instrument::DogStatsDDatagram
+  end
+
   def latency_metric_type
     :d
   end

data/lib/statsd/instrument/expectation.rb

@@ -41,7 +41,7 @@ class StatsD::Instrument::Expectation
     @name = client.prefix ? "#{client.prefix}.#{name}" : name unless no_prefix
     @value = normalized_value_for_type(type, value) if value
     @sample_rate = sample_rate
-    @tags = StatsD::Instrument::Metric.normalize_tags(tags)
+    @tags = normalize_tags(tags)
     @times = times
   end
 
@@ -77,6 +77,42 @@ class StatsD::Instrument::Expectation
   def inspect
     "#<StatsD::Instrument::Expectation:\"#{self}\">"
   end
+
+  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.
+  #
+  # - Tags specified as key value pairs will be converted into an array
+  # - Tags are normalized to remove unsupported characters
+  #
+  # @param tags [Array<String>, Hash<String, String>, nil] Tags specified in any form.
+  # @return [Array<String>, nil] the list of tags in canonical form.
+  #
+  # @todo We should delegate this to thje datagram builder of the current client,
+  #   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
 
 # For backwards compatibility

data/lib/statsd/instrument/legacy_client.rb

@@ -120,7 +120,7 @@ class StatsD::Instrument::LegacyClient
   #
   # Emits a set metric, which counts the number of distinct values that have occurred.
   #
-  # @example Couning the number of unique visitors
+  # @example Counting the number of unique visitors
   #   StatsD.set('visitors.unique', Current.user.id)
   #
   # @param key [String] The name of the metric.
@@ -222,7 +222,7 @@ class StatsD::Instrument::LegacyClient
   # @param title [String] Title of the event. A configured prefix may be applied to this title.
   # @param text [String] Body of the event. Can contain newlines.
   # @param [String] hostname The hostname to associate with the event.
-  # @param [Time] timestamp The moment the status of the service was checkes. Defaults to now.
+  # @param [Time] timestamp The moment the status of the service was checked. Defaults to now.
   # @param [String] aggregation_key A key to aggregate similar events into groups.
   # @param [String] priority The event's priority, either `"low"` or `"normal"` (default).
   # @param [String] source_type_name The source type.
@@ -254,7 +254,7 @@ class StatsD::Instrument::LegacyClient
   # @param [String] name Name of the service. A configured prefix may be applied to this title.
   # @param [Symbol] status Current status of the service. Either `:ok`, `:warning`, `:critical`, or `:unknown`.
   # @param [String] hostname The hostname to associate with the event.
-  # @param [Time] timestamp The moment the status of the service was checkes. Defaults to now.
+  # @param [Time] timestamp The moment the status of the service was checked. Defaults to now.
   # @param [String] message A message that describes the current status.
   # @param tags (see #increment)
   # @return [void]
@@ -273,7 +273,7 @@ class StatsD::Instrument::LegacyClient
     })
   end
 
-  private
+  protected
 
   def measure_latency(type, key, sample_rate:, tags:, prefix:)
     start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -296,6 +296,6 @@ class StatsD::Instrument::LegacyClient
     metric = StatsD::Instrument::Metric.new(type: type, name: name, value: value,
       sample_rate: sample_rate, tags: tags, metadata: metadata)
     backend.collect_metric(metric)
-    metric # TODO: return `nil` in the next major version
+    metric
   end
 end

data/lib/statsd/instrument/metric.rb

@@ -54,11 +54,11 @@ class StatsD::Instrument::Metric
   # The default value for this metric, which will be used if it is not set.
   #
   # A default value is only defined for counter metrics (<tt>1</tt>). For all other
-  # metric types, this emthod will raise an <tt>ArgumentError</tt>.
+  # metric types, this method will raise an <tt>ArgumentError</tt>.
   #
   #
   # A default value is only defined for counter metrics (<tt>1</tt>). For all other
-  # metric types, this emthod will raise an <tt>ArgumentError</tt>.
+  # metric types, this method will raise an <tt>ArgumentError</tt>.
   #
   # @return [Numeric, String] The default value for this metric.
   # @raise ArgumentError if the metric type doesn't have a default value

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

@@ -6,7 +6,7 @@ module RuboCop
   module Cop
     module StatsD
       # This Rubocop will check for using the metaprogramming macros for positional
-      # argument usage, which is deprecated. These macros include `statd_count_if`,
+      # argument usage, which is deprecated. These macros include `statsd_count_if`,
       # `statsd_measure`, etc.
       #
       # Use the following Rubocop invocation to check your project's codebase:

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

@@ -42,16 +42,16 @@ module RuboCop
 
         def autocorrect(node)
           -> (corrector) do
-            positial_arguments = if node.arguments.last.type == :block_pass
+            positional_arguments = if node.arguments.last.type == :block_pass
               node.arguments[2...node.arguments.length - 1]
             else
               node.arguments[2...node.arguments.length]
             end
 
-            case positial_arguments[0].type
+            case positional_arguments[0].type
             when *UNKNOWN_ARGUMENT_TYPES
               # We don't know whether the method returns a hash, in which case it would be interpreted
-              # as keyword arguments. In this case, the fix would be to add a keywordf splat:
+              # as keyword arguments. In this case, the fix would be to add a keyword splat:
               #
               # `StatsD.instrument('foo', 1, method_call)`
               # => `StatsD.instrument('foo', 1, **method_call)`
@@ -68,17 +68,17 @@ module RuboCop
             when *POSITIONAL_ARGUMENT_TYPES
               value_argument = node.arguments[1]
               from = value_argument.source_range.end_pos
-              to = positial_arguments.last.source_range.end_pos
+              to = positional_arguments.last.source_range.end_pos
               range = Parser::Source::Range.new(node.source_range.source_buffer, from, to)
               corrector.remove(range)
 
               keyword_arguments = []
-              sample_rate = positial_arguments[0]
+              sample_rate = positional_arguments[0]
               if sample_rate && sample_rate.type != :nil
                 keyword_arguments << "sample_rate: #{sample_rate.source}"
               end
 
-              tags = positial_arguments[1]
+              tags = positional_arguments[1]
               if tags && tags.type != :nil
                 keyword_arguments << if tags.type == :hash && tags.source[0] != '{'
                   "tags: { #{tags.source} }"

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

@@ -5,7 +5,7 @@ require_relative '../rubocop' unless defined?(RuboCop::Cop::StatsD)
 module RuboCop
   module Cop
     module StatsD
-      # This Rubocop will check for calls to StatsD singleton congfiguration methods
+      # This Rubocop will check for calls to StatsD singleton configuration methods
       # (e.g. `StatsD.prefix`). The library is moving away from having just a single
       # singleton client, so these methods are deprecated.
       #

data/lib/statsd/instrument/strict.rb

@@ -15,7 +15,7 @@ module StatsD
     # - 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:
+    # You can enable this monkeypatch by changing your Gemfile as follows:
     #
     #     gem 'statsd-instrument', require: 'statsd/instrument/strict'
     #
@@ -81,6 +81,11 @@ 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)
@@ -99,49 +104,59 @@ module StatsD
           raise ArgumentError, "The tags argument should be a hash or an array, got #{tags.inspect}"
         end
       end
+    end
+
+    module VoidCollectMetric
+      protected
 
       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.
+        StatsD::Instrument::VOID
       end
     end
 
     module StrictMetaprogramming
-      def statsd_measure(method, name, sample_rate: nil, tags: nil, no_prefix: false)
+      def statsd_measure(method, name, sample_rate: nil, tags: nil,
+        no_prefix: false, client: StatsD.singleton_client)
+
         check_method_and_metric_name(method, name)
 
-        # Unfortunately, we have to inline the new method implementation ebcause we have to fix the
+        # 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)
-            StatsD.measure(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
+            client.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, no_prefix: false)
+      def statsd_distribution(method, name, sample_rate: nil, tags: nil,
+        no_prefix: false, client: StatsD.singleton_client)
+
         check_method_and_metric_name(method, name)
 
-        # Unfortunately, we have to inline the new method implementation ebcause we have to fix the
+        # 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)
-            StatsD.distribution(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix) do
+            client.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, no_prefix: false)
+      def statsd_count_success(method, name, sample_rate: nil, tags: nil,
+        no_prefix: false, client: StatsD.singleton_client)
+
         check_method_and_metric_name(method, name)
 
-        # Unfortunately, we have to inline the new method implementation ebcause we have to fix the
+        # 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
@@ -163,16 +178,18 @@ module StatsD
             ensure
               suffix = truthiness == false ? 'failure' : 'success'
               key = "#{StatsD::Instrument.generate_metric_name(nil, name, self, *args)}.#{suffix}"
-              StatsD.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+              client.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, no_prefix: false)
+      def statsd_count_if(method, name, sample_rate: nil, tags: nil,
+        no_prefix: false, client: StatsD.singleton_client)
+
         check_method_and_metric_name(method, name)
 
-        # Unfortunately, we have to inline the new method implementation ebcause we have to fix the
+        # 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
@@ -194,23 +211,25 @@ module StatsD
             ensure
               if truthiness
                 key = StatsD::Instrument.generate_metric_name(nil, name, self, *args)
-                StatsD.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+                client.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, no_prefix: false)
+      def statsd_count(method, name, sample_rate: nil, tags: nil,
+        no_prefix: false, client: StatsD.singleton_client)
+
         check_method_and_metric_name(method, name)
 
-        # Unfortunately, we have to inline the new method implementation ebcause we have to fix the
+        # 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)
-            StatsD.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
+            client.increment(key, sample_rate: sample_rate, tags: tags, no_prefix: no_prefix)
             super(*args, &block)
           end
         end
@@ -232,4 +251,5 @@ module StatsD
 end
 
 StatsD.singleton_class.prepend(StatsD::Instrument::Strict)
+StatsD::Instrument::LegacyClient.prepend(StatsD::Instrument::VoidCollectMetric)
 StatsD::Instrument.prepend(StatsD::Instrument::StrictMetaprogramming)

data/lib/statsd/instrument/version.rb

@@ -2,6 +2,6 @@
 
 module StatsD
   module Instrument
-    VERSION = "2.8.0"
+    VERSION = "2.9.0"
   end
 end