statsd-instrument 3.0.0.pre1 → 3.1.0

data/lib/statsd/instrument/datagram.rb

@@ -1,83 +1,87 @@
 # 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::Datagram
-  attr_reader :source
+module StatsD
+  module Instrument
+    # 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 Datagram
+      attr_reader :source
 
-  def initialize(source)
-    @source = source
-  end
+      def initialize(source)
+        @source = source
+      end
 
-  # @return [Float] The sample rate at which this datagram was emitted, between 0 and 1.
-  def sample_rate
-    parsed_datagram[:sample_rate] ? Float(parsed_datagram[:sample_rate]) : 1.0
-  end
+      # @return [Float] The sample rate at which this datagram was emitted, between 0 and 1.
+      def sample_rate
+        parsed_datagram[:sample_rate] ? Float(parsed_datagram[:sample_rate]) : 1.0
+      end
 
-  def type
-    @type ||= parsed_datagram[:type].to_sym
-  end
+      def type
+        @type ||= parsed_datagram[:type].to_sym
+      end
 
-  def name
-    parsed_datagram[:name]
-  end
+      def name
+        parsed_datagram[:name]
+      end
 
-  def value
-    @value ||= case type
-    when :c
-      Integer(parsed_datagram[:value])
-    when :g, :h, :d, :kv, :ms
-      Float(parsed_datagram[:value])
-    when :s
-      String(parsed_datagram[:value])
-    else
-      parsed_datagram[:value]
-    end
-  end
+      def value
+        @value ||= case type
+        when :c
+          Integer(parsed_datagram[:value])
+        when :g, :h, :d, :kv, :ms
+          Float(parsed_datagram[:value])
+        when :s
+          String(parsed_datagram[:value])
+        else
+          parsed_datagram[:value]
+        end
+      end
 
-  def tags
-    @tags ||= parsed_datagram[:tags] ? parsed_datagram[:tags].split(',') : nil
-  end
+      def tags
+        @tags ||= parsed_datagram[:tags] ? parsed_datagram[:tags].split(",") : nil
+      end
 
-  def inspect
-    "#<#{self.class.name}:\"#{@source}\">"
-  end
+      def inspect
+        "#<#{self.class.name}:\"#{@source}\">"
+      end
 
-  def hash
-    source.hash
-  end
+      def hash
+        source.hash
+      end
 
-  def eql?(other)
-    case other
-    when StatsD::Instrument::Datagram
-      source == other.source
-    when String
-      source == other
-    else
-      false
-    end
-  end
+      def eql?(other)
+        case other
+        when StatsD::Instrument::Datagram
+          source == other.source
+        when String
+          source == other
+        else
+          false
+        end
+      end
 
-  alias_method :==, :eql?
+      alias_method :==, :eql?
 
-  private
+      private
 
-  PARSER = %r{
-    \A
-    (?<name>[^\:\|\@]+)\:(?<value>[^\:\|\@]+)\|(?<type>c|ms|g|s|h|d)
-    (?:\|\@(?<sample_rate>\d*(?:\.\d*)?))?
-    (?:\|\#(?<tags>(?:[^\|,]+(?:,[^\|,]+)*)))?
-    \n? # In some implementations, the datagram may include a trailing newline.
-    \z
-  }x
+      PARSER = %r{
+        \A
+        (?<name>[^\:\|\@]+)\:(?<value>[^\:\|\@]+)\|(?<type>c|ms|g|s|h|d)
+        (?:\|\@(?<sample_rate>\d*(?:\.\d*)?))?
+        (?:\|\#(?<tags>(?:[^\|,]+(?:,[^\|,]+)*)))?
+        \n? # In some implementations, the datagram may include a trailing newline.
+        \z
+      }x
 
-  def parsed_datagram
-    @parsed ||= if (match_info = PARSER.match(@source))
-      match_info
-    else
-      raise ArgumentError, "Invalid StatsD datagram: #{@source}"
+      def parsed_datagram
+        @parsed ||= if (match_info = PARSER.match(@source))
+          match_info
+        else
+          raise ArgumentError, "Invalid StatsD datagram: #{@source}"
+        end
+      end
     end
   end
 end

data/lib/statsd/instrument/datagram_builder.rb

@@ -1,101 +1,105 @@
 # 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::DatagramBuilder
-  unless Regexp.method_defined?(:match?) # for ruby 2.3
-    module RubyBackports
-      refine Regexp do
-        def match?(str)
-          match(str) != nil
+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 DatagramBuilder
+      unless Regexp.method_defined?(:match?) # for ruby 2.3
+        module RubyBackports
+          refine Regexp do
+            def match?(str)
+              match(str) != nil
+            end
+          end
         end
-      end
-    end
 
-    using RubyBackports
-  end
+        using(RubyBackports)
+      end
 
-  def self.unsupported_datagram_types(*types)
-    types.each do |type|
-      define_method(type) do |_, _, _, _|
-        raise NotImplementedError, "Type #{type} metrics are not supported by #{self.class.name}."
+      def self.unsupported_datagram_types(*types)
+        types.each do |type|
+          define_method(type) do |_, _, _, _|
+            raise NotImplementedError, "Type #{type} metrics are not supported by #{self.class.name}."
+          end
+        end
       end
-    end
-  end
 
-  def self.datagram_class
-    StatsD::Instrument::Datagram
-  end
+      def self.datagram_class
+        StatsD::Instrument::Datagram
+      end
 
-  def initialize(prefix: nil, default_tags: nil)
-    @prefix = prefix.nil? ? "" : "#{normalize_name(prefix)}."
-    @default_tags = normalize_tags(default_tags)
-  end
+      def initialize(prefix: nil, default_tags: nil)
+        @prefix = prefix.nil? ? "" : "#{normalize_name(prefix)}."
+        @default_tags = normalize_tags(default_tags)
+      end
 
-  def c(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 'c', sample_rate, tags)
-  end
+      def c(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "c", sample_rate, tags)
+      end
 
-  def g(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 'g', sample_rate, tags)
-  end
+      def g(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "g", sample_rate, tags)
+      end
 
-  def ms(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 'ms', sample_rate, tags)
-  end
+      def ms(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "ms", sample_rate, tags)
+      end
 
-  def s(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 's', sample_rate, tags)
-  end
+      def s(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "s", sample_rate, tags)
+      end
 
-  def h(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 'h', sample_rate, tags)
-  end
+      def h(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "h", sample_rate, tags)
+      end
 
-  def d(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 'd', sample_rate, tags)
-  end
+      def d(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "d", sample_rate, tags)
+      end
 
-  def kv(name, value, sample_rate, tags)
-    generate_generic_datagram(name, value, 'kv', sample_rate, tags)
-  end
+      def kv(name, value, sample_rate, tags)
+        generate_generic_datagram(name, value, "kv", sample_rate, tags)
+      end
 
-  def latency_metric_type
-    :ms
-  end
+      def latency_metric_type
+        :ms
+      end
 
-  protected
+      protected
 
-  attr_reader :prefix, :default_tags
+      attr_reader :prefix, :default_tags
 
-  # 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.
-  def normalize_tags(tags)
-    return [] unless tags
-    tags = tags.map { |k, v| "#{k}:#{v}" } if tags.is_a?(Hash)
+      # 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.
+      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
+        # Fast path when no string replacement is needed
+        return tags unless tags.any? { |tag| /[|,]/.match?(tag) }
+        tags.map { |tag| tag.tr("|,", "") }
+      end
 
-  # Utility function to remove invalid characters from a StatsD metric name
-  def normalize_name(name)
-    # Fast path when no normalization is needed to avoid copying the string
-    return name unless /[:|@]/.match?(name)
-    name.tr(':|@', '_')
-  end
+      # Utility function to remove invalid characters from a StatsD metric name
+      def normalize_name(name)
+        # Fast path when no normalization is needed to avoid copying the string
+        return name unless /[:|@]/.match?(name)
+        name.tr(":|@", "_")
+      end
 
-  def generate_generic_datagram(name, value, type, sample_rate, tags)
-    tags = normalize_tags(tags) + default_tags
-    datagram = +"#{@prefix}#{normalize_name(name)}:#{value}|#{type}"
-    datagram << "|@#{sample_rate}" if sample_rate && sample_rate < 1
-    datagram << "|##{tags.join(',')}" unless tags.empty?
-    datagram
+      def generate_generic_datagram(name, value, type, sample_rate, tags)
+        tags = normalize_tags(tags) + default_tags
+        datagram = +"#{@prefix}#{normalize_name(name)}:#{value}|#{type}"
+        datagram << "|@#{sample_rate}" if sample_rate && sample_rate < 1
+        datagram << "|##{tags.join(",")}" unless tags.empty?
+        datagram
+      end
+    end
   end
 end

data/lib/statsd/instrument/dogstatsd_datagram.rb

@@ -1,88 +1,92 @@
 # 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
+module StatsD
+  module Instrument
+    # 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 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 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 hostname
+        parsed_datagram[:hostname]
+      end
 
-  def timestamp
-    Time.at(Integer(parsed_datagram[:timestamp])).utc
-  end
+      def timestamp
+        Time.at(Integer(parsed_datagram[:timestamp])).utc
+      end
 
-  def aggregation_key
-    parsed_datagram[:aggregation_key]
-  end
+      def aggregation_key
+        parsed_datagram[:aggregation_key]
+      end
 
-  def source_type_name
-    parsed_datagram[:source_type_name]
-  end
+      def source_type_name
+        parsed_datagram[:source_type_name]
+      end
 
-  def priority
-    parsed_datagram[:priority]
-  end
+      def priority
+        parsed_datagram[:priority]
+      end
 
-  def alert_type
-    parsed_datagram[:alert_type]
-  end
+      def alert_type
+        parsed_datagram[:alert_type]
+      end
 
-  def message
-    parsed_datagram[:message]
-  end
+      def message
+        parsed_datagram[:message]
+      end
 
-  protected
+      protected
 
-  def parsed_datagram
-    @parsed ||= if (match_info = PARSER.match(@source))
-      match_info
-    else
-      raise ArgumentError, "Invalid DogStatsD datagram: #{@source}"
-    end
-  end
+      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
+      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
+      # |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)
+      PARSER = Regexp.union(StatsD::Instrument::Datagram::PARSER, SERVICE_CHECK_PARSER, EVENT_PARSER)
+    end
+  end
 end