qubole-statsd-instrument 2.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0694d4ff0f7d5f512163a9b3bfc818a91bdda979
+  data.tar.gz: 7b589905601377964502e99086d82015af0ff333
+SHA512:
+  metadata.gz: eb4fc7372e4d8c70bb5a0431ca1c5621837e804eb2411dcc7b0719b703b1babae02a3fa8926af7550135a512692531e68ca7a6e8c366e5a793d3334fe7ed72ac
+  data.tar.gz: 18f7e78a40037fe3a410ecb7652fe2af190c6151e9b18b7af6229ceac11b080c66cce8e140bf630c294f31f49c56135f41ea39c4b3c097839cf6ca8d2f5f861f

data/.gitignore

@@ -0,0 +1,7 @@
+.yardoc
+doc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+vendor/

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+
+sudo: false

data/CHANGELOG.md

@@ -0,0 +1,89 @@
+# Changelog
+
+This file documents the changes between releases of this library. When creating a pull request,
+please at an entry to the "unreleased changes" section below.
+
+### Unreleased changes
+
+### Version 2.1.3
+
+- The `assert_statsd_calls` test helper will now raise an exception whenever a block isn't passed.
+- Sending stats inside an exit handler will no longer cause programs to exit abruptly.
+
+### Version 2.1.2
+
+- Use `prepend` instead of rewriting classes for metaprogramming methods.
+- RSpec: make matchers more flexible.
+- Bugfix: Only ask Rails for the environment when it's actually loaded.
+
+### Version 2.1.1
+
+- Add `assert_statsd_calls` to from validating cases where one has multiple metrics with the same name and type being recorded, but with different options.
+
+### Version 2.1.0
+
+- Fix rspec-rails compatibility
+- Add `value` keyword argument to all metric types.
+
+### Version 2.0.12
+
+- Make StatsD client thread-safe
+- Assertions: Ensure sample rates have proper values.
+- Assertions: Make tag assertions work more intuitively
+- RSpec: Add backwards compatibility for RSpec 2
+
+### Version 2.0.11
+
+- Don't change method visibility when adding instrumentation to methods using metaprogramming
+- RSpec: add support for Compound expectations
+
+### Version 2.0.10
+
+- Assertions: allow ignoring certain tags when asserting for other tags to be present.
+
+### Version 2.0.9
+
+- Better error message for `assert_no_statsd_calls`
+
+### Version 2.0.8
+
+- More tag handling performance improvements.
+- RSpec matchers documentation improvements
+
+### Version 2.0.7
+
+- Tag handling performance improvements.
+- Test against Ruby 2.2.
+- Drop support for Ruby 1.9.3.
+
+### Version 2.0.6
+
+- Fix some loading order issues in Rails environments.
+- Default behavior: in a **staging** environment, the defaults are now the same as in a **production environment**.
+- Documentation overhaul
+
+### Version 2.0.5
+
+- Allow for nested assertions using the `assert_statsd_*` assertion methods.
+
+### Version 2.0.4
+
+- Add a Railtie to fix some initialization issues.
+
+### Version 2.0.3
+
+- Assertion method bugfixes
+
+### Version 2.0.2
+
+- Documentation fixes
+
+### Version 2.0.1
+
+- Add assertion methods `assert_statsd_histogram`, `assert_statsd_set`, and `assert_statsd_key_value`.
+
+### Version 2.0.0
+
+- Complete rewrite using pluggable backends.
+- Add assertion methods in `StatsD::Instrument::Assertions` to make testing easier and less brittle.
+- Drop support for Ruby 1.8

data/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+# Contributing
+
+This project is MIT licensed and welcomes outside contributions.
+
+## Reporting issues
+
+Report issues using the [Github issues tracker](https://github.com/Shopify/statsd-instrument/issues/new).
+
+When reporting issues, please incldue 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
+
+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.
+4. Ping **@jstorimer** and/or **@wvanbergen** for a code review.
+
+Some notes:
+
+- Make sure to follow to coding style.
+- 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.
+
+## Release procedure
+
+1. Update the version number in `lib/statsd/instrument/version.rb`.
+2. Move the "Unreleased changes" items in [CHANGELOG.md](./CHANGELOG.md) to a new section for the release.
+3. Commit these changes.
+4. Run `bundle exec rake release`.

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Shopify
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,319 @@
+# StatsD client for Ruby apps
+
+[![Built on Travis](https://secure.travis-ci.org/Shopify/statsd-instrument.png?branch=master)](https://secure.travis-ci.org/Shopify/statsd-instrument)
+
+This is a ruby client for statsd (http://github.com/etsy/statsd). It provides a lightweight way to track and measure metrics in your application.
+
+We call out to statsd by sending data over a UDP socket. UDP sockets are fast, but unreliable, there is no guarantee that your data will ever arrive at its location. In other words, fire and forget. This is perfect for this use case because it means your code doesn't get bogged down trying to log statistics. We send data to statsd several times per request and haven't noticed a performance hit.
+
+For more information about StatsD, see the [README of the Etsy project](http://github.com/etsy/statsd).
+
+## Configuration
+
+The library comes with different backends. Based on your environment (detected using environment
+variables), it will select one of the following backends by default:
+
+- **Production** and **staging** environment: `StatsD::Instrument::Backends::UDPBackend` will actually send UDP packets.
+  It will configure itself using environment variables: it uses `STATSD_ADDR` for the address to connect
+  to (default `"localhost:8125"`), and `STATSD_IMPLEMENTATION` to set the protocol variant. (See below)
+- **Test** environment: `StatsD::Instrument::Backends::NullBackend` will swallow all calls. See below for
+  notes on writing tests.
+- **Development**, and all other, environments: `StatsD::Instrument::Backends::LoggerBackend` will log all
+  calls to stdout.
+
+You can override the currently active backend by setting `StatsD.backend`:
+
+``` ruby
+# Sets up a UDP backend. First argument is the UDP address to send StatsD packets to,
+# second argument specifies the protocol variant (i.e. `:statsd`, `:statsite`, or `:datadog`).
+StatsD.backend = StatsD::Instrument::Backends::UDPBackend.new("1.2.3.4:8125", :statsite)
+
+# Sets up a logger backend
+StatsD.backend = StatsD::Instrument::Backends::LoggerBackend.new(Rails.logger)
+```
+
+The other available settings, with their default, are
+
+``` ruby
+# Logger to which commands are logged when using the LoggerBackend, which is
+# the default in development environment. Also, any errors or warnings will
+# be logged here.
+StatsD.logger = defined?(Rails) ? Rails.logger : Logger.new($stderr)
+
+# An optional prefix to be added to each metric.
+StatsD.prefix = nil # but can be set to any string
+
+# Sample 10% of events. By default all events are reported, which may overload your network or server.
+# You can, and should vary this on a per metric basis, depending on frequency and accuracy requirements
+StatsD.default_sample_rate = (ENV['STATSD_SAMPLE_RATE'] || 0.1 ).to_f
+```
+
+## StatsD keys
+
+StatsD keys look like 'admin.logins.api.success'. Dots are used as namespace separators.
+In Graphite, they will show up as folders.
+
+## Usage
+
+You can either use the basic methods to submit stats over StatsD, or you can use the metaprogramming methods to instrument your methods with some basic stats (call counts, successes & failures, and timings).
+
+#### StatsD.measure
+
+Lets you benchmark how long the execution of a specific method takes.
+
+``` ruby
+# You can pass a key and a ms value
+StatsD.measure('GoogleBase.insert', 2.55)
+
+# or more commonly pass a block that calls your code
+StatsD.measure('GoogleBase.insert') do
+  GoogleBase.insert(product)
+end
+```
+
+#### StatsD.increment
+
+Lets you increment a key in statsd to keep a count of something. If the specified key doesn't exist it will create it for you.
+
+``` ruby
+# increments default to +1
+StatsD.increment('GoogleBase.insert')
+# you can also specify how much to increment the key by
+StatsD.increment('GoogleBase.insert', 10)
+# you can also specify a sample rate, so only 1/10 of events
+# actually get to statsd. Useful for very high volume data
+StatsD.increment('GoogleBase.insert', 1, sample_rate: 0.1)
+```
+
+#### StatsD.gauge
+
+A gauge is a single numerical value that tells you the state of the system at a point in time. A good example would be the number of messages in a queue.
+
+``` ruby
+StatsD.gauge('GoogleBase.queued', 12, sample_rate: 1.0)
+```
+
+Normally, you shouldn't update this value too often, and therefore there is no need to sample this kind metric.
+
+#### StatsD.set
+
+A set keeps track of the number of unique values that have been seen. This is a good fit for keeping track of the number of unique visitors. The value can be a string.
+
+``` ruby
+# Submit the customer ID to the set. It will only be counted if it hasn't been seen before.
+StatsD.set('GoogleBase.customers', "12345", sample_rate: 1.0)
+```
+
+Because you are counting unique values, the results of using a sampling value less than 1.0 can lead to unexpected, hard to interpret results.
+
+### Metaprogramming Methods
+
+As mentioned, it's most common to use the provided metaprogramming methods. This lets you define all of your instrumentation in one file and not litter your code with instrumentation details. You should enable a class for instrumentation by extending it with the `StatsD::Instrument` class.
+
+``` ruby
+GoogleBase.extend StatsD::Instrument
+```
+
+Then use the methods provided below to instrument methods in your class.
+
+#### statsd\_measure
+
+This will measure how long a method takes to run, and submits the result to the given key.
+
+``` ruby
+GoogleBase.statsd_measure :insert, 'GoogleBase.insert'
+```
+
+#### statsd\_count
+
+This will increment the given key even if the method doesn't finish (ie. raises).
+
+``` ruby
+GoogleBase.statsd_count :insert, 'GoogleBase.insert'
+```
+
+Note how I used the 'GoogleBase.insert' key above when measuring this method, and I reused here when counting the method calls. StatsD automatically separates these two kinds of stats into namespaces so there won't be a key collision here.
+
+#### statsd\_count\_if
+
+This will only increment the given key if the method executes successfully.
+
+``` ruby
+GoogleBase.statsd_count_if :insert, 'GoogleBase.insert'
+```
+
+So now, if GoogleBase#insert raises an exception or returns false (ie. result == false), we won't increment the key. If you want to define what success means for a given method you can pass a block that takes the result of the method.
+
+``` ruby
+GoogleBase.statsd_count_if :insert, 'GoogleBase.insert' do |response|
+  response.code == 200
+end
+```
+
+In the above example we will only increment the key in statsd if the result of the block returns true. So the method is returning a Net::HTTP response and we're checking the status code.
+
+#### statsd\_count\_success
+
+Similar to statsd_count_if, except this will increment one key in the case of success and another key in the case of failure.
+
+``` ruby
+GoogleBase.statsd_count_success :insert, 'GoogleBase.insert'
+```
+
+So if this method fails execution (raises or returns false) we'll increment the failure key ('GoogleBase.insert.failure'), otherwise we'll increment the success key ('GoogleBase.insert.success'). Notice that we're modifying the given key before sending it to statsd.
+
+Again you can pass a block to define what success means.
+
+``` ruby
+GoogleBase.statsd_count_success :insert, 'GoogleBase.insert' do |response|
+  response.code == 200
+end
+```
+
+### Instrumenting Class Methods
+
+You can instrument class methods, just like instance methods, using the metaprogramming methods. You simply have to configure the instrumentation on the singleton class of the Class you want to instrument.
+
+```ruby
+AWS::S3::Base.singleton_class.statsd_measure :request, 'S3.request'
+```
+
+### Dynamic Metric Names
+
+You can use a lambda function instead of a string dynamically set
+the name of the metric. The lambda function must accept two arguments:
+the object the function is being called on and the array of arguments
+passed.
+
+```ruby
+GoogleBase.statsd_count :insert, lambda{|object, args| object.class.to_s.downcase + "." + args.first.to_s + ".insert" }
+```
+
+### Tags
+
+The Datadog implementation support tags, which you can use to slice and dice metrics in their UI. You can specify a list of tags as an option, either standalone tag (e.g. `"mytag"`), or key value based, separated by a colon: `"env:production"`.
+
+``` ruby
+StatsD.increment('my.counter', tags: ['env:production', 'unicorn'])
+GoogleBase.statsd_count :insert, 'GoogleBase.insert', tags: ['env:production']
+```
+
+If implementation is not set to `:datadog`, tags will not be included in the UDP packets, and a
+warning is logged to `StatsD.logger`.
+
+## Testing
+
+This library comes with a module called `StatsD::Instrument::Assertions` and `StatsD::Instrument::Matchers` to help you write tests
+to verify StatsD is called properly.
+
+### minitest
+
+``` ruby
+class MyTestcase < Minitest::Test
+  include StatsD::Instrument::Assertions
+
+  def test_some_metrics
+    # This will pass if there is exactly one matching StatsD call
+    # it will ignore any other, non matching calls.
+    assert_statsd_increment('counter.name', sample_rate: 1.0) do
+      StatsD.increment('unrelated') # doesn't match
+      StatsD.increment('counter.name', sample_rate: 1.0) # matches
+      StatsD.increment('counter.name', sample_rate: 0.1) # doesn't match
+    end
+
+    # Set `times` if there will be multiple matches:
+    assert_statsd_increment('counter.name', times: 2) do
+      StatsD.increment('unrelated') # doesn't match
+      StatsD.increment('counter.name', sample_rate: 1.0) # matches
+      StatsD.increment('counter.name', sample_rate: 0.1) # matches too
+    end
+  end
+
+  def test_no_udp_traffic
+    # Verifies no StatsD calls occured at all.
+    assert_no_statsd_calls do
+      do_some_work
+    end
+
+    # Verifies no StatsD calls occured for the given metric.
+    assert_no_statsd_calls('metric_name') do
+      do_some_work
+    end
+  end
+
+  def test_more_complicated_stuff
+    # capture_statsd_calls will capture all the StatsD calls in the
+    # given block, and returns them as an array. You can then run your
+    # own assertions on it.
+    metrics = capture_statsd_calls do
+      StatsD.increment('mycounter', sample_rate: 0.01)
+    end
+
+    assert_equal 1, metrics.length
+    assert_equal 'mycounter', metrics[0].name
+    assert_equal :c, metrics[0].type
+    assert_equal 1, metrics[0].value
+    assert_equal 0.01, metrics[0].sample_rate
+  end
+end
+
+```
+
+### RSpec
+
+```ruby
+RSpec.configure do |config|
+  config.include StatsD::Instrument::Matchers
+end
+
+RSpec.describe 'Matchers' do
+  context 'trigger_statsd_increment' do
+    it 'will pass if there is exactly one matching StatsD call' do
+      expect { StatsD.increment('counter') }.to trigger_statsd_increment('counter')
+    end
+
+    it 'will pass if it matches the correct number of times' do
+      expect {
+        2.times do
+          StatsD.increment('counter')
+        end
+      }.to trigger_statsd_increment('counter', times: 2)
+    end
+
+    it 'will pass if it matches argument' do
+      expect {
+        StatsD.measure('counter', 0.3001)
+      }.to trigger_statsd_measure('counter', value: be_between(0.29, 0.31))
+    end
+
+    it 'will pass if there is no matching StatsD call on negative expectation' do
+      expect { StatsD.increment('other_counter') }.not_to trigger_statsd_increment('counter')
+    end
+  end
+end
+```
+
+## Notes
+
+### Compatibility
+
+Tested using Travis CI against Ruby 2.0, 2.1, 2.2, Rubinius, and JRuby.
+
+### Reliance on DNS
+
+Out of the box StatsD is set up to be unidirectional fire-and-forget over UDP. Configuring
+the StatsD host to be a non-ip will trigger a DNS lookup (i.e. a synchronous TCP round trip).
+This can be particularly problematic in clouds that have a shared DNS infrastructure such as AWS.
+
+1. Using a hardcoded IP avoids the DNS lookup but generally requires an application deploy to change.
+2. Hardcoding the DNS/IP pair in /etc/hosts allows the IP to change without redeploying your application but fails to scale as the number of servers increases.
+3. Installing caching software such as nscd that uses the DNS TTL avoids most DNS lookups but makes the exact moment of change indeterminate.
+
+
+## Links
+
+This library was developed for shopify.com and is MIT licensed.
+
+- [API documentation](http://www.rubydoc.info/gems/statsd-instrument/frames)
+- [The changelog](./CHANGELOG.md) covers the changes between releases.
+- [Contributing notes](./CONTRIBUTING.md) if you are interested in contributing to this library.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new('test') do |t|
+  t.ruby_opts << '-rubygems'
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/*.rb']
+end
+
+task :default => :test

data/lib/statsd/instrument/assertions.rb

@@ -0,0 +1,88 @@
+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."
+  end
+
+  def assert_statsd_increment(metric_name, options = {}, &block)
+    assert_statsd_call(:c, metric_name, options, &block)
+  end
+
+  def assert_statsd_measure(metric_name, options = {}, &block)
+    assert_statsd_call(:ms, metric_name, options, &block)
+  end
+
+  def assert_statsd_gauge(metric_name, options = {}, &block)
+    assert_statsd_call(:g, metric_name, options, &block)
+  end
+
+  def assert_statsd_histogram(metric_name, options = {}, &block)
+    assert_statsd_call(:h, metric_name, options, &block)
+  end
+
+  def assert_statsd_set(metric_name, options = {}, &block)
+    assert_statsd_call(:s, metric_name, options, &block)
+  end
+
+  def assert_statsd_key_value(metric_name, options = {}, &block)
+    assert_statsd_call(:kv, metric_name, options, &block)
+  end
+
+  # @private
+  def assert_statsd_calls(expected_metrics, &block)
+    unless block
+      raise ArgumentError, "block must be given"
+    end
+
+    metrics = capture_statsd_calls(&block)
+    matched_expected_metrics = []
+
+    expected_metrics.each do |expected_metric|
+      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."
+
+      filtered_metrics.each do |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
+        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}"
+    end
+    expected_metrics -= matched_expected_metrics
+
+    assert expected_metrics.empty?,
+      "Unexpected StatsD calls; the following metric expectations were not satisfied: #{expected_metrics.inspect}"
+  end
+
+  private
+
+  def assert_statsd_call(metric_type, metric_name, options = {}, &block)
+    options[:name] = metric_name
+    options[:type] = metric_type
+    options[:times] ||= 1
+    expected_metric = StatsD::Instrument::MetricExpectation.new(options)
+    assert_statsd_calls([expected_metric], &block)
+  end
+
+  def within_numeric_range?(object)
+    object.kind_of?(Numeric) && (0.0..1.0).cover?(object)
+  end
+end

data/lib/statsd/instrument/backend.rb

@@ -0,0 +1,17 @@
+# 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)
+    raise NotImplementedError, "Use a concerete backend implementation"
+  end
+end
+
+require 'statsd/instrument/backends/logger_backend'
+require 'statsd/instrument/backends/null_backend'
+require 'statsd/instrument/backends/capture_backend'
+require 'statsd/instrument/backends/udp_backend'

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

@@ -0,0 +1,29 @@
+module StatsD::Instrument::Backends
+
+  # The capture backend is used to capture the metrics that are collected, so you can
+  # run assertions on them.
+  #
+  # @!attribute collected_metrics [r]
+  #   @return [Array<StatsD::Instrument::Metric>] The list of metrics that were collected.
+  # @see StatsD::Instrument::Assertions
+  class CaptureBackend < StatsD::Instrument::Backend
+    attr_reader :collected_metrics
+
+    def initialize
+      reset
+    end
+
+    # Adds a metric to the ist of collected metrics.
+    # @param metric [StatsD::Instrument::Metric]  The metric to collect.
+    # @return [void]
+    def collect_metric(metric)
+      @collected_metrics << metric
+    end
+
+    # Resets the list of collected metrics to an empty list.
+    # @return [void]
+    def reset
+      @collected_metrics = []
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+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)
+      @logger = logger
+    end
+
+    # @param metric [StatsD::Instrument::Metric]
+    # @return [void]
+    def collect_metric(metric)
+      logger.info "[StatsD] #{metric}"
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module StatsD::Instrument::Backends
+  # The null backend does nothing when receiving a metric, effectively disabling the gem completely.
+  class NullBackend < StatsD::Instrument::Backend
+    def collect_metric(metric)
+    end
+  end
+end