statsd-instrument 2.3.2 → 2.4.0

data/.rubocop.yml

@@ -0,0 +1,21 @@
+inherit_from:
+  - https://shopify.github.io/ruby-style-guide/rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.3
+  UseCache: true
+  CacheRootDirectory: tmp/rubocop
+  Exclude:
+    - statsd-instrument.gemspec
+
+Naming/FileName:
+  Enabled: true
+  Exclude:
+    - lib/statsd-instrument.rb
+
+Style/ClassAndModuleChildren:
+  Enabled: false # TODO: enable later
+
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: false # TODO: enable later

data/CHANGELOG.md

@@ -5,6 +5,47 @@ please at an entry to the "unreleased changes" section below.
 
 ### Unreleased changes
 
+## Version 2.4.0
+
+- Add `StatsD.default_tags` to specify tags that should be included in all metrics. (#159)
+- Improve assertion message when assertying metrics whose tags do not match. (#100)
+- Enforce the Shopify Ruby style guide. (#164)
+- Migrate CI to Github actions. (#158)
+- Make the library frozen string literal-compatible. (#161, #163)
+- Fix all Ruby warnings. (#162)
+
+## Version 2.3.5
+
+- Re-add `StatsD::Instrument.duration`, which was accidentally removed since verison 2.5.3 (#157)
+
+## Version 2.3.4
+
+- Improve performance of `Metric#to_s` (#152)
+- Fix bug in escaping newlines for events with Datadog Backend (#153)
+
+## Version 2.3.3
+
+- Capture measure and distribution metrics on exception and early return (#134)
+
+NOTE: Now that exceptions are measured statistics may behave differently. An exception example:
+```
+StatsD.measure('myhttpcall') do
+  my_http_object.invoke
+end
+```
+Version 2.3.2 and below did not track metrics whenever a HTTP Timeout exception was raised.
+2.3.3 and above will include those metrics which may increase the values included.
+
+A return example:
+```
+StatsD.measure('myexpensivecalculation') do
+  return if expensive_calculation_disabled?
+  expensive_calculation
+end
+```
+If `expensive_calculation_disabled?` is true 50% of the time version 2.3.2 will drop the
+average metric considerably.
+
 ## Version 2.3.2
 
 - Add option to override global prefix for metrics (#148)

data/CONTRIBUTING.md

@@ -11,27 +11,47 @@ This project is MIT licensed.
 
 Report issues using the [Github issues tracker](https://github.com/Shopify/statsd-instrument/issues/new).
 
-When reporting issues, please incldue the following information:
+When reporting issues, please include the following information:
 
 - Your Ruby interpreter version.
 - The statsd-instrument version. **Note:** only the latest version is supported.
 - The StatsD backend you are using.
 
-## Pull request
+## Opening pull requests
 
 1. Fork the repository, and create a branch.
 2. Implement the feature or bugfix, and add tests that cover the changed functionality.
-3. Create a pull request. Make sure that you get Travis CI passes.
+3. Create a pull request. Make sure that you get a green CI status on your commit.
 
 Some notes:
 
-- Make sure to follow to coding style.
+- Make sure to follow to coding style. This is enforced by Rubocop
 - Make sure your changes are properly documented using [yardoc syntax](http://www.rubydoc.info/gems/yard/file/docs/GettingStarted.md).
 - Add an entry to the "unreleased changes" section of [CHANGELOG.md](./CHANGELOG.md).
 - **Do not** update `StatsD::Instrument::VERSION`. This will be done during the release prodecure.
 
-> **Important:** if you change anything in the hot code path (sending a StatsD metric), please
-> include benchmarks to show the performance impact of your changes.
+### On perfomance & benchmarking
+
+This gem is used in production at Shopify, and is used to instrument some of
+our hottest code paths. This means that we are very careful about not
+introducing performance regressions in this library.
+
+**Important:** Whenever you make changes to the metric emission code path in this library,
+you **must** include benchmark results to show the impact of your changes.
+
+The `test/benchmark/` folder contains some example benchmark script that you
+can use, or can serve as a starting point. Please run your benchmark on your
+pull request revision, as well as the latest revision on `master`.
+
+### On backwards compatibility
+
+Shopify's codebases are heavily instrumented using this library. As a result, we cannot
+accept changes that are backwards incompatible:
+
+- Changes that will require us to update our codebases.
+- Changes that will cause metrics emitted by this library to change in form or shape.
+
+This means that we may not be able to accept fixes for what you consider a bug.
 
 ## Release procedure
 

data/Gemfile

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 gemspec

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
@@ -7,4 +9,4 @@ Rake::TestTask.new('test') do |t|
   t.test_files = FileList['test/*.rb']
 end
 
-task :default => :test
+task default: :test

data/lib/statsd/instrument/assertions.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module StatsD::Instrument::Assertions
   include StatsD::Instrument::Helpers
 
   def assert_no_statsd_calls(metric_name = nil, &block)
     metrics = capture_statsd_calls(&block)
     metrics.select! { |m| m.name == metric_name } if metric_name
-    assert metrics.empty?, "No StatsD calls for metric #{metrics.map(&:name).join(', ')} expected."
+    assert(metrics.empty?, "No StatsD calls for metric #{metrics.map(&:name).join(', ')} expected.")
   end
 
   def assert_statsd_increment(metric_name, options = {}, &block)
@@ -48,32 +50,36 @@ module StatsD::Instrument::Assertions
       expected_metric_times = expected_metric.times
       expected_metric_times_remaining = expected_metric.times
       filtered_metrics = metrics.select { |m| m.type == expected_metric.type && m.name == expected_metric.name }
-      assert filtered_metrics.length > 0,
-        "No StatsD calls for metric #{expected_metric.name} of type #{expected_metric.type} were made."
+      refute(filtered_metrics.empty?,
+        "No StatsD calls for metric #{expected_metric.name} of type #{expected_metric.type} were made.")
 
       filtered_metrics.each do |metric|
+        next unless expected_metric.matches(metric)
+
         assert within_numeric_range?(metric.sample_rate),
           "Unexpected sample rate type for metric #{metric.name}, must be numeric"
-        if expected_metric.matches(metric)
-          assert expected_metric_times_remaining > 0,
-            "Unexpected StatsD call; number of times this metric was expected exceeded: #{expected_metric.inspect}"
-          expected_metric_times_remaining -= 1
-          metrics.delete(metric)
-          if expected_metric_times_remaining == 0
-            matched_expected_metrics << expected_metric
-          end
+
+        assert(expected_metric_times_remaining > 0,
+          "Unexpected StatsD call; number of times this metric was expected exceeded: #{expected_metric.inspect}")
+
+        expected_metric_times_remaining -= 1
+        metrics.delete(metric)
+        if expected_metric_times_remaining == 0
+          matched_expected_metrics << expected_metric
         end
       end
 
-      assert expected_metric_times_remaining == 0,
-          "Metric expected #{expected_metric_times} times but seen"\
-          " #{expected_metric_times-expected_metric_times_remaining}"\
-          " times: #{expected_metric.inspect}"
+      msg = +"Metric expected #{expected_metric_times} times but seen " \
+        "#{expected_metric_times - expected_metric_times_remaining} " \
+        "times: #{expected_metric.inspect}."
+      msg << "\nCaptured metrics with the same key: #{filtered_metrics}" if filtered_metrics.any?
+
+      assert(expected_metric_times_remaining == 0, msg)
     end
     expected_metrics -= matched_expected_metrics
 
-    assert expected_metrics.empty?,
-      "Unexpected StatsD calls; the following metric expectations were not satisfied: #{expected_metrics.inspect}"
+    assert(expected_metrics.empty?,
+      "Unexpected StatsD calls; the following metric expectations were not satisfied: #{expected_metrics.inspect}")
   end
 
   private
@@ -87,6 +93,6 @@ module StatsD::Instrument::Assertions
   end
 
   def within_numeric_range?(object)
-    object.kind_of?(Numeric) && (0.0..1.0).cover?(object)
+    object.is_a?(Numeric) && (0.0..1.0).cover?(object)
   end
 end

data/lib/statsd/instrument/backend.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 # This abstract class specifies the interface a backend implementation should conform to.
 # @abstract
 class StatsD::Instrument::Backend
-
   # Collects a metric.
   #
   # @param metric [StatsD::Instrument::Metric] The metric to collect
   # @return [void]
-  def collect_metric(metric)
+  def collect_metric(_metric)
     raise NotImplementedError, "Use a concerete backend implementation"
   end
 end

data/lib/statsd/instrument/backends/capture_backend.rb

@@ -1,5 +1,6 @@
-module StatsD::Instrument::Backends
+# frozen_string_literal: true
 
+module StatsD::Instrument::Backends
   # The capture backend is used to capture the metrics that are collected, so you can
   # run assertions on them.
   #

data/lib/statsd/instrument/backends/logger_backend.rb

@@ -1,10 +1,10 @@
-module StatsD::Instrument::Backends
+# frozen_string_literal: true
 
+module StatsD::Instrument::Backends
   # The logger backend simply logs every metric to a logger
   # @!attribute logger
   #    @return [Logger]
   class LoggerBackend < StatsD::Instrument::Backend
-
     attr_accessor :logger
 
     def initialize(logger)
@@ -14,7 +14,7 @@ module StatsD::Instrument::Backends
     # @param metric [StatsD::Instrument::Metric]
     # @return [void]
     def collect_metric(metric)
-      logger.info "[StatsD] #{metric}"
+      logger.info("[StatsD] #{metric}")
     end
   end
 end

data/lib/statsd/instrument/backends/null_backend.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StatsD::Instrument::Backends
   # The null backend does nothing when receiving a metric, effectively disabling the gem completely.
   class NullBackend < StatsD::Instrument::Backend

data/lib/statsd/instrument/backends/udp_backend.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'monitor'
 
 module StatsD::Instrument::Backends
   class UDPBackend < StatsD::Instrument::Backend
-
     BASE_SUPPORTED_METRIC_TYPES = { c: true, ms: true, g: true, s: true }
 
     class DogStatsDProtocol
@@ -24,11 +25,11 @@ module StatsD::Instrument::Backends
       SUPPORTED_METRIC_TYPES = BASE_SUPPORTED_METRIC_TYPES.merge(h: true, _e: true, _sc: true, d: true)
 
       def generate_packet(metric)
-        packet = ""
+        packet = +""
 
         if metric.type == :_e
-          escaped_title = metric.name.tr('\n', '\\n')
-          escaped_text = metric.value.tr('\n', '\\n')
+          escaped_title = metric.name.gsub("\n", "\\n")
+          escaped_text = metric.value.gsub("\n", "\\n")
 
           packet << "_e{#{escaped_title.size},#{escaped_text.size}}:#{escaped_title}|#{escaped_text}"
           packet << generate_metadata(metric, EVENT_OPTIONS)
@@ -41,6 +42,7 @@ module StatsD::Instrument::Backends
 
         packet << "|@#{metric.sample_rate}" if metric.sample_rate < 1
         packet << "|##{metric.tags.join(',')}" if metric.tags
+
         packet
       end
 
@@ -57,7 +59,7 @@ module StatsD::Instrument::Backends
       SUPPORTED_METRIC_TYPES = BASE_SUPPORTED_METRIC_TYPES.merge(kv: true)
 
       def generate_packet(metric)
-        packet = "#{metric.name}:#{metric.value}|#{metric.type}"
+        packet = +"#{metric.name}:#{metric.value}|#{metric.type}"
         packet << "|@#{metric.sample_rate}" unless metric.sample_rate == 1
         packet << "\n"
         packet
@@ -68,7 +70,7 @@ module StatsD::Instrument::Backends
       SUPPORTED_METRIC_TYPES = BASE_SUPPORTED_METRIC_TYPES
 
       def generate_packet(metric)
-        packet = "#{metric.name}:#{metric.value}|#{metric.type}"
+        packet = +"#{metric.name}:#{metric.value}|#{metric.type}"
         packet << "|@#{metric.sample_rate}" if metric.sample_rate < 1
         packet
       end
@@ -88,19 +90,20 @@ module StatsD::Instrument::Backends
 
     def implementation=(value)
       @packet_factory = case value
-        when :datadog
-          DogStatsDProtocol.new
-        when :statsite
-          StatsiteStatsDProtocol.new
-        else
-          StatsDProtocol.new
-        end
+      when :datadog
+        DogStatsDProtocol.new
+      when :statsite
+        StatsiteStatsDProtocol.new
+      else
+        StatsDProtocol.new
+      end
       @implementation = value
     end
 
     def collect_metric(metric)
       unless @packet_factory.class::SUPPORTED_METRIC_TYPES[metric.type]
-        StatsD.logger.warn("[StatsD] Metric type #{metric.type.inspect} not supported on #{implementation} implementation.")
+        StatsD.logger.warn("[StatsD] Metric type #{metric.type.inspect} is not supported " \
+          "on #{implementation} implementation.")
         return false
       end
 
@@ -139,13 +142,13 @@ module StatsD::Instrument::Backends
       synchronize do
         socket.send(command, 0) > 0
       end
-    rescue ThreadError => e
+    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 command without a lock.
       socket.send(command, 0) > 0
-    rescue SocketError, IOError, SystemCallError, Errno::ECONNREFUSED => e
-      StatsD.logger.error "[StatsD] #{e.class.name}: #{e.message}"
+    rescue SocketError, IOError, SystemCallError => e
+      StatsD.logger.error("[StatsD] #{e.class.name}: #{e.message}")
       invalidate_socket
     end
 

data/lib/statsd/instrument/environment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 # The environment module is used to detect, and initialize the environment in

data/lib/statsd/instrument/helpers.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module StatsD::Instrument::Helpers
   def capture_statsd_calls(&block)
     mock_backend = StatsD::Instrument::Backends::CaptureBackend.new
-    old_backend, StatsD.backend = StatsD.backend, mock_backend
+    old_backend = StatsD.backend
+    StatsD.backend = mock_backend
+
     block.call
     mock_backend.collected_metrics
   ensure
-    if old_backend.kind_of?(StatsD::Instrument::Backends::CaptureBackend)
+    if old_backend.is_a?(StatsD::Instrument::Backends::CaptureBackend)
       old_backend.collected_metrics.concat(mock_backend.collected_metrics)
     end
 

data/lib/statsd/instrument/matchers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rspec/expectations'
 require 'rspec/core/version'
 
@@ -9,7 +11,7 @@ module StatsD::Instrument::Matchers
     histogram: :h,
     distribution: :d,
     set: :s,
-    key_value: :kv
+    key_value: :kv,
   }
 
   class Matcher
@@ -23,13 +25,10 @@ module StatsD::Instrument::Matchers
     end
 
     def matches?(block)
-      begin
-        expect_statsd_call(@metric_type, @metric_name, @options, &block)
-      rescue RSpec::Expectations::ExpectationNotMetError => e
-        @message = e.message
-
-        false
-      end
+      expect_statsd_call(@metric_type, @metric_name, @options, &block)
+    rescue RSpec::Expectations::ExpectationNotMetError => e
+      @message = e.message
+      false
     end
 
     def failure_message
@@ -50,8 +49,12 @@ module StatsD::Instrument::Matchers
       metrics = capture_statsd_calls(&block)
       metrics = metrics.select { |m| m.type == metric_type && m.name == metric_name }
 
-      raise RSpec::Expectations::ExpectationNotMetError, "No StatsD calls for metric #{metric_name} were made." if metrics.empty?
-      raise RSpec::Expectations::ExpectationNotMetError, "The numbers of StatsD calls for metric #{metric_name} was unexpected. Expected #{options[:times].inspect}, got #{metrics.length}" if options[:times] && options[:times] != metrics.length
+      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]
@@ -63,7 +66,7 @@ module StatsD::Instrument::Matchers
 
         found = options[:times] ? num_matches == options[:times] : num_matches > 0
 
-        if !found
+        unless found
           message = metric_information(metric_name, options, metrics, expectation)
           raise RSpec::Expectations::ExpectationNotMetError, message
         end

data/lib/statsd/instrument/metric.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # The Metric class represents a metric sample to be send by a backend.
 #
 # @!attribute type
 #   @return [Symbol] The metric type. Must be one of {StatsD::Instrument::Metric::TYPES}
 # @!attribute name
 #   @return [String] The name of the metric. {StatsD#prefix} will automatically be applied
-#     to the metric in the constructor, unless the <tt>:no_prefix</tt> option is set or is 
+#     to the metric in the constructor, unless the <tt>:no_prefix</tt> option is set or is
 #     overridden by the <tt>:prefix</tt> option. Note that <tt>:no_prefix</tt> has greater
 #     precedence than <tt>:prefix</tt>.
 # @!attribute value
@@ -29,7 +31,6 @@
 # @see StatsD::Instrument::Backend A StatsD::Instrument::Backend is used to collect metrics.
 #
 class StatsD::Instrument::Metric
-
   attr_accessor :type, :name, :value, :sample_rate, :tags, :metadata
 
   # Initializes a new metric instance.
@@ -47,9 +48,18 @@ class StatsD::Instrument::Metric
   # @option options [Array<String>, Hash<String, String>, nil] :tags The tags to apply to this metric.
   #   See {.normalize_tags} for more information.
   def initialize(options = {})
-    @type = options[:type] or raise ArgumentError, "Metric :type is required."
-    @name = options[:name] or raise ArgumentError, "Metric :name is required."
-    @name = normalize_name(@name)
+    if options[:type]
+      @type = options[:type]
+    else
+      raise ArgumentError, "Metric :type is required."
+    end
+
+    if options[:name]
+      @name = normalize_name(options[:name])
+    else
+      raise ArgumentError, "Metric :name is required."
+    end
+
     unless options[:no_prefix]
       @name = if options[:prefix]
         "#{options[:prefix]}.#{@name}"
@@ -58,10 +68,13 @@ class StatsD::Instrument::Metric
       end
     end
 
-    @value       = options[:value] || default_value
+    @value = options[:value] || default_value
     @sample_rate = options[:sample_rate] || StatsD.default_sample_rate
-    @tags        = StatsD::Instrument::Metric.normalize_tags(options[:tags])
-    @metadata    = options.reject { |k, _| [:type, :name, :value, :sample_rate, :tags].include?(k) }
+    @tags = StatsD::Instrument::Metric.normalize_tags(options[:tags])
+    if StatsD.default_tags
+      @tags = Array(@tags) + StatsD.default_tags
+    end
+    @metadata = options.reject { |k, _| [:type, :name, :value, :sample_rate, :tags].include?(k) }
   end
 
   # The default value for this metric, which will be used if it is not set.
@@ -73,36 +86,36 @@ class StatsD::Instrument::Metric
   # @raise ArgumentError if the metric type doesn't have a default value
   def default_value
     case type
-      when :c; 1
-      else raise ArgumentError, "A value is required for metric type #{type.inspect}."
+    when :c then 1
+    else raise ArgumentError, "A value is required for metric type #{type.inspect}."
     end
   end
 
   # @private
   # @return [String]
   def to_s
-    str = "#{TYPES[type]} #{name}:#{value}"
+    str = +"#{TYPES[type]} #{name}:#{value}"
     str << " @#{sample_rate}" if sample_rate != 1.0
-    str << " " << tags.map { |t| "##{t}"}.join(' ') if tags
+    tags&.each { |tag| str << " ##{tag}" }
     str
   end
 
   # @private
   # @return [String]
   def inspect
-    "#<StatsD::Instrument::Metric #{self.to_s}>"
+    "#<StatsD::Instrument::Metric #{self}>"
   end
 
   # The metric types that are supported by this library. Note that every StatsD server
   # implementation only supports a subset of them.
   TYPES = {
-    c:  'increment',
+    c: 'increment',
     ms: 'measure',
-    g:  'gauge',
-    h:  'histogram',
-    d:  'distribution',
+    g: 'gauge',
+    h: 'histogram',
+    d: 'distribution',
     kv: 'key/value',
-    s:  'set',
+    s: 'set',
   }
 
   # Strip metric names of special characters used by StatsD line protocol, replace with underscore
@@ -110,7 +123,7 @@ class StatsD::Instrument::Metric
   # @param name [String]
   # @return [String]
   def normalize_name(name)
-    name.tr(':|@'.freeze, '_')
+    name.tr(':|@', '_')
   end
 
   # Utility function to convert tags to the canonical form.
@@ -122,7 +135,7 @@ class StatsD::Instrument::Metric
   # @return [Array<String>, nil] the list of tags in canonical form.
   def self.normalize_tags(tags)
     return unless tags
-    tags = tags.map { |k, v| k.to_s + ":".freeze + v.to_s } if tags.is_a?(Hash)
-    tags.map { |tag| tag.tr('|,'.freeze, ''.freeze) }
+    tags = tags.map { |k, v| k.to_s + ":" + v.to_s } if tags.is_a?(Hash)
+    tags.map { |tag| tag.tr('|,', '') }
   end
 end

data/lib/statsd/instrument/metric_expectation.rb

@@ -1,15 +1,31 @@
+# frozen_string_literal: true
+
 # @private
 class StatsD::Instrument::MetricExpectation
-
   attr_accessor :times, :type, :name, :value, :sample_rate, :tags
   attr_reader :ignore_tags
 
   def initialize(options = {})
-    @type = options[:type] or raise ArgumentError, "Metric :type is required."
-    @name = options[:name] or raise ArgumentError, "Metric :name is required."
+    if options[:type]
+      @type = options[:type]
+    else
+      raise ArgumentError, "Metric :type is required."
+    end
+
+    if options[:name]
+      @name = options[:name]
+    else
+      raise ArgumentError, "Metric :name is required."
+    end
+
+    if options[:times]
+      @times = options[:times]
+    else
+      raise ArgumentError, "Metric :times is required."
+    end
+
     @name = StatsD.prefix ? "#{StatsD.prefix}.#{@name}" : @name unless options[:no_prefix]
     @tags = StatsD::Instrument::Metric.normalize_tags(options[:tags])
-    @times = options[:times] or raise ArgumentError, "Metric :times is required."
     @sample_rate = options[:sample_rate]
     @value = options[:value]
     @ignore_tags = StatsD::Instrument::Metric.normalize_tags(options[:ignore_tags])
@@ -29,7 +45,7 @@ class StatsD::Instrument::MetricExpectation
         actual_tags -= ignored_tags
 
         if ignore_tags.is_a?(Array)
-          actual_tags.delete_if{ |key| ignore_tags.include?(key.split(":").first) }
+          actual_tags.delete_if { |key| ignore_tags.include?(key.split(":").first) }
         end
       end
 
@@ -39,30 +55,28 @@ class StatsD::Instrument::MetricExpectation
   end
 
   def default_value
-    case type
-      when :c; 1
-    end
+    1 if type == :c
   end
 
   TYPES = {
-      c:  'increment',
-      ms: 'measure',
-      g:  'gauge',
-      h:  'histogram',
-      d:  'distribution',
-      kv: 'key/value',
-      s:  'set',
+    c: 'increment',
+    ms: 'measure',
+    g: 'gauge',
+    h: 'histogram',
+    d: 'distribution',
+    kv: 'key/value',
+    s: 'set',
   }
 
   def to_s
-    str = "#{TYPES[type]} #{name}:#{value}"
+    str = +"#{TYPES[type]} #{name}:#{value}"
     str << " @#{sample_rate}" if sample_rate != 1.0
-    str << " " << tags.map { |t| "##{t}"}.join(' ') if tags
+    str << " " << tags.map { |t| "##{t}" }.join(' ') if tags
     str << " times:#{times}" if times > 1
     str
   end
 
   def inspect
-    "#<StatsD::Instrument::MetricExpectation #{self.to_s}>"
+    "#<StatsD::Instrument::MetricExpectation #{self}>"
   end
 end