statsd-instrument 1.7.2 → 2.0.0beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d50bba4fad7c7d60e2272ec23888004b0cbebbd1
+  data.tar.gz: b36122aa5c275370c1a0e3e9edd3803321a4a960
+SHA512:
+  metadata.gz: 0e060d63fb216442bd387a131adca06326560aec60813efe34a608182b5066e698fdf217f13bee3ffbdcd8489e105079b0e99aca507729627a73014b5e2749e6
+  data.tar.gz: 39f3c512927e0c8ac41ff7c21936853d1d7e048b02ed3030c2c21bd67e3f07f703d6093fa54062617e102b9b273a809c23c218675b1a6280b349a46f71630856

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - ree
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1.1
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -1,5 +1,2 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 gemspec
-
-gem 'SystemTimer', :require => nil, :platform => :mri_18
-gem 'rake', '~> 10.0.0' if RUBY_VERSION.to_f < 1.9

data/README.md

@@ -4,9 +4,9 @@
 
 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 it's 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.
+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.
 
-The fact that all of your stats data may not make it into statsd is no issue. Graphite (the graph database that statsd is built on) will only show you trends in your data. Internally it only keeps enough data to satisfy the levels of granularity we specify. As well as satisfying it's requirement as a fixed size database. We can throw as much data at it as we want it and it will do it's best to show us the trends over time and get rid of the fluff.
+The fact that all of your stats data may not make it into statsd is no issue. Graphite (the graph database that statsd is built on) will only show you trends in your data. Internally it only keeps enough data to satisfy the levels of granularity we specify. As well as satisfying its requirement as a fixed size database. We can throw as much data at it as we want it and it will do its best to show us the trends over time and get rid of the fluff.
 
 For Shopify, our retention periods are:
 
@@ -18,39 +18,48 @@ This is the same as what Etsy uses (mentioned in the README for http://github.co
 
 ## Configuration
 
-``` ruby
-# The UDP endpoint to which you want to submit your metrics.
-# This is set to the environment variable STATSD_ADDR if it is set.
-StatsD.server = 'statsd.myservice.com:8125' 
+The library comes with different backends. Based on your environment (detected using environment 
+variables), it will select one of the following backends by default:
 
-# Events are only actually submitted in production mode. For any other value, thewy are logged instead
-# This value is set by to the value of the RAILS_ENV or RACK_ENV environment variable if it is set.
-StatsD.mode = :production
+- **Production** environment: `StatsD::Instrument::Backend::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::Backend::NullBackend` will swallow all calls. See below for 
+  notes on writing tests.
+- **Development**, and all other, environments: `StatsD::Instrument::Backend::LoggerBackend` will log all
+  calls to stdout.
 
-# Logger to which commands are logged when not in :production mode.
-# In  production only errors are logged to the console.
-StatsD.logger = Rails.logger
+You can override the currently active backend by setting `StatsD.backend`:
 
-# An optional prefix to be added to each stat.
-StatsD.prefix = 'my_app' 
+``` 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::Backend::UDPBackend.new("1.2.3.4:8125", :statsite)
 
-# 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 = 0.1 
+# Sets up a logger backend
+StatsD.backend = StatsD::Instrument::Backend::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 = defiend?(Rails) : Rails.logger ? Logger.new($stderr)
 
-There are several implementations of StatsD out there, all with slight protocol variations. You can this library to use the proper protocol by informing it about what implementation you use. By default, it will use the `STATSD_IMPLEMENTATION` environment variable, if it is not set it will use the protocol of the original Etsy implementation.
+# An optional prefix to be added to each metric.
+StatsD.prefix = nil # but can be set to any string
 
-```
-StatsD.implementation = :datadog  # Enable datadog extensions: tags and histograms
-StatsD.implementation = :statsite # Enable keyvalue-style gauges 
+# 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'. Each dot in the key represents a 'folder' in the graphite interface. You can include any data you want in the keys.
+StatsD keys look like 'admin.logins.api.success'. Dots are used as namespace separators.
+In Graphite, they will show up as folders.
 
 ## Usage
 
@@ -185,7 +194,7 @@ the object the function is being called on and the array of arguments
 passed.
 
 ```ruby
-GoogleBase.statsd_count :insert, lamdba{|object, args| object.class.to_s.downcase + "." + args.first.to_s + ".insert" }
+GoogleBase.statsd_count :insert, lambda{|object, args| object.class.to_s.downcase + "." + args.first.to_s + ".insert" }
 ```
 
 ### Tags
@@ -197,9 +206,70 @@ 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 come swith a module called `StatsD::Instrument::Assertions` to help you write tests
+to verify StatsD is called properly.
+
+``` 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
+
+```
+
 ## 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 (ie synchronous round trip network call) for each metric sent. This can be particularly problematic in clouds that have a shared DNS infrastructure such as AWS.
+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.
 
 ### Common Workarounds
 
@@ -211,11 +281,9 @@ Out of the box StatsD is set up to be unidirectional fire-and-forget over UDP. C
 
 Tested on several Ruby versions using Travis CI:
 
-* Ruby 1.8.7
-* Ruby Enterprise Edition 1.8.7
 * Ruby 1.9.3
 * Ruby 2.0.0
-* Ruby 2.1.0
+* Ruby 2.1.1
 
 ## Contributing
 
@@ -224,5 +292,5 @@ This project is MIT licensed and welcomes outside contributions.
 1. Fork the repository, and create a feature branch.
 2. Implement the feature, and add tests that cover the new changes functionality.
 3. Update the README.
-4. Create a pull request. Make sure that you get a CI pass on it.
+4. Create a pull request. Make sure that you get a Travis CI pass on it.
 5. Ping @jstorimer and/or @wvanbergen for review.

data/lib/statsd/instrument/assertions.rb

@@ -0,0 +1,46 @@
+module StatsD::Instrument::Assertions
+
+  def capture_statsd_calls(&block)
+    mock_backend = StatsD::Instrument::Backends::CaptureBackend.new
+    old_backend, StatsD.backend = StatsD.backend, mock_backend
+    block.call
+    mock_backend.collected_metrics
+  ensure
+    StatsD.backend = old_backend
+  end
+
+  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 #{metric_name} 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
+
+  private
+
+  def assert_statsd_call(metric_type, metric_name, options = {}, &block)
+    options[:times] ||= 1
+    metrics = capture_statsd_calls(&block)
+    metrics = metrics.select { |m| m.type == metric_type && m.name == metric_name }
+    assert metrics.length > 0, "No StatsD calls for metric #{metric_name} were made."
+    assert options[:times] === metrics.length, "The amount of StatsD calls for metric #{metric_name} was unexpected"
+    metric = metrics.first
+
+    assert_equal options[:sample_rate], metric.sample_rate, "Unexpected value submitted for StatsD metric #{metric_name}" if options[:sample_rate]
+    assert_equal options[:value], metric.value, "Unexpected StatsD sample rate for metric #{metric_name}" if options[:value]
+    assert_equal Set.new(options[:tags]), Set.new(metric.tags), "Unexpected StatsD tags for metric #{metric_name}" if options[:tags]
+
+    metric
+  end
+end

data/lib/statsd/instrument/backend.rb

@@ -0,0 +1,10 @@
+class StatsD::Instrument::Backend
+  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,17 @@
+module StatsD::Instrument::Backends
+  class CaptureBackend < StatsD::Instrument::Backend
+    attr_reader :collected_metrics
+
+    def initialize
+      reset
+    end
+
+    def collect_metric(metric)
+      @collected_metrics << metric
+    end
+
+    def reset
+      @collected_metrics = []
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module StatsD::Instrument::Backends
+  class LoggerBackend < StatsD::Instrument::Backend
+    
+    attr_accessor :logger
+    
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def collect_metric(metric)
+      logger.info "[StatsD] #{metric}"
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module StatsD::Instrument::Backends
+  class NullBackend < StatsD::Instrument::Backend
+    def collect_metric(metric)
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module StatsD::Instrument::Backends
+  class UDPBackend < StatsD::Instrument::Backend
+
+    DEFAULT_IMPLEMENTATION = :statsd
+
+    attr_reader :host, :port
+    attr_accessor :implementation
+
+    def initialize(server = nil, implementation = nil)
+      self.server = server || "localhost:8125"
+      self.implementation = (implementation || DEFAULT_IMPLEMENTATION).to_sym
+    end
+
+    def collect_metric(metric)
+      unless implementation_supports_metric_type?(metric.type)
+        StatsD.logger.warn("[StatsD] Metric type #{metric.type.inspect} not supported on #{implementation} implementation.")
+        return false
+      end
+
+      if metric.sample_rate < 1.0 && rand > metric.sample_rate
+        return false
+      end
+
+      write_packet(generate_packet(metric))
+    end
+
+    def implementation_supports_metric_type?(type)
+      case type
+        when :h;  implementation == :datadog
+        when :kv; implementation == :statsite
+        else true
+      end
+    end
+
+    def server=(connection_string)
+      self.host, port = connection_string.split(':', 2)
+      self.port = port.to_i
+      invalidate_socket
+    end
+
+    def host=(host)
+      @host = host
+      invalidate_socket
+    end
+
+    def port=(port)
+      @port = port
+      invalidate_socket
+    end
+
+    def socket
+      if @socket.nil?
+        @socket = UDPSocket.new
+        @socket.connect(host, port)
+      end
+      @socket
+    end
+
+    def generate_packet(metric)
+      command = "#{metric.name}:#{metric.value}|#{metric.type}"
+      command << "|@#{metric.sample_rate}" if metric.sample_rate < 1 || (implementation == :statsite && metric.sample_rate > 1)
+      if metric.tags 
+        if tags_supported?
+          command << "|##{metric.tags.join(',')}"
+        else
+          StatsD.logger.warn("[StatsD] Tags are only supported on Datadog implementation.")
+        end
+      end
+
+      command << "\n" if implementation == :statsite
+      command
+    end
+
+    def tags_supported?
+      implementation == :datadog
+    end
+
+    def write_packet(command)
+      socket.send(command, 0) > 0
+    rescue SocketError, IOError, SystemCallError => e
+      StatsD.logger.error "[StatsD] #{e.class.name}: #{e.message}"
+    end
+
+    def invalidate_socket
+      @socket = nil
+    end
+  end
+end

data/lib/statsd/instrument/environment.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module StatsD::Instrument::Environment
+  extend self
+
+  def default_backend
+    case environment
+    when 'production'
+      StatsD::Instrument::Backends::UDPBackend.new(ENV['STATSD_ADDR'], ENV['STATSD_IMPLEMENTATION'])
+    when 'test'
+      StatsD::Instrument::Backends::NullBackend.new
+    else
+      StatsD::Instrument::Backends::LoggerBackend.new(StatsD.logger)
+    end
+  end
+
+  def environment
+    if defined?(Rails)
+      Rails.env.to_s
+    else
+      ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['ENV'] || 'development'
+    end
+  end  
+end
+
+StatsD.default_sample_rate = ENV.fetch('STATSD_SAMPLE_RATE', 1.0).to_f
+StatsD.logger = defined?(Rails) ? Rails.logger : Logger.new($stderr)

data/lib/statsd/instrument/metric.rb

@@ -0,0 +1,50 @@
+class StatsD::Instrument::Metric
+
+  attr_accessor :type, :name, :value, :sample_rate, :tags
+
+  def initialize(options = {})
+    @type = options[:type] or raise ArgumentError, "Metric :type is required."
+    @name = options[:name] or raise ArgumentError, "Metric :name is required."
+    @name = StatsD.prefix ? "#{StatsD.prefix}.#{@name}" : @name unless options[:no_prefix]
+
+    @value       = options[:value] || default_value
+    @sample_rate = options[:sample_rate] || StatsD.default_sample_rate
+    @tags        = StatsD::Instrument::Metric.normalize_tags(options[:tags])
+  end
+
+  def default_value
+    case type
+      when :c; 1
+      else raise ArgumentError, "A value is required for metric type #{type.inspect}."
+    end
+  end
+
+  def to_s
+    str = "#{TYPES[type]} #{name}:#{value}"
+    str << " @#{sample_rate}" if sample_rate != 1.0
+    str << " " << tags.map { |t| "##{t}"}.join(' ') if tags
+    str
+  end
+
+  def inspect
+    "#<StatsD::Instrument::Metric #{self.to_s}>"
+  end
+
+  TYPES = {
+    c:  'increment',
+    ms: 'measure',
+    g:  'gauge',
+    h:  'histogram',
+    kv: 'key/value',
+    s:  'set',
+  }
+
+  def self.normalize_tags(tags)
+    return if tags.nil?
+    tags = tags.map { |k, v| "#{k}:#{v}" } if tags.is_a?(Hash)
+    tags.map do |tag| 
+      components = tag.split(':', 2)
+      components.map { |c| c.gsub(/[^\w\.-]+/, '_') }.join(':')
+    end
+  end
+end

data/lib/statsd/instrument/version.rb

@@ -1,5 +1,5 @@
 module StatsD
   module Instrument
-    VERSION = "1.7.2"
+    VERSION = "2.0.0beta"
   end
 end

data/lib/statsd/instrument.rb

@@ -2,8 +2,6 @@ require 'socket'
 require 'benchmark'
 require 'logger'
 
-require 'statsd/instrument/version'
-
 module StatsD
   module Instrument
 
@@ -110,41 +108,23 @@ module StatsD
   end
 
   class << self
-    attr_accessor :host, :port, :mode, :logger, :enabled, :default_sample_rate, :prefix, :implementation
-
-    def server=(conn)
-      self.host, port = conn.split(':')
-      self.port = port.to_i
-      invalidate_socket
-    end
+    attr_accessor :logger, :default_sample_rate, :prefix
+    attr_writer :backend
 
-    def host=(host)
-      @host = host
-      invalidate_socket
-    end
-
-    def port=(port)
-      @port = port
-      invalidate_socket
-    end
-
-    def invalidate_socket
-      @socket = nil
+    def backend
+      @backend ||= StatsD::Instrument::Environment.default_backend
     end
 
     # glork:320|ms
-    def measure(key, value = nil, *metric_options)
+    def measure(key, value = nil, *metric_options, &block)
       if value.is_a?(Hash) && metric_options.empty?
         metric_options = [value]
         value = nil
       end
 
       result = nil
-      ms = value || 1000 * Benchmark.realtime do
-        result = yield
-      end
-
-      collect(:ms, key, ms, hash_argument(metric_options))
+      ms = value || 1000 * Benchmark.realtime { result = block.call }
+      collect_metric(hash_argument(metric_options).merge(type: :ms, name: key, value: ms))
       result
     end
 
@@ -155,29 +135,27 @@ module StatsD
         value = 1
       end
 
-      collect(:c, key, value, hash_argument(metric_options))
+      collect_metric(hash_argument(metric_options).merge(type: :c, name: key, value: value))
     end
 
     # gaugor:333|g
     # guagor:1234|kv|@1339864935 (statsite)
     def gauge(key, value, *metric_options)
-      collect(:g, key, value, hash_argument(metric_options))
+      collect_metric(hash_argument(metric_options).merge(type: :g, name: key, value: value))
     end
 
     # histogram:123.45|h
     def histogram(key, value, *metric_options)
-      raise NotImplementedError, "StatsD.histogram only supported on :datadog implementation." unless self.implementation == :datadog
-      collect(:h, key, value, hash_argument(metric_options))
+      collect_metric(hash_argument(metric_options).merge(type: :h, name: key, value: value))
     end
 
     def key_value(key, value, *metric_options)
-      raise NotImplementedError, "StatsD.key_value only supported on :statsite implementation." unless self.implementation == :statsite
-      collect(:kv, key, value, hash_argument(metric_options))
+      collect_metric(hash_argument(metric_options).merge(type: :kv, name: key, value: value))
     end
 
     # uniques:765|s
     def set(key, value, *metric_options)
-      collect(:s, key, value, hash_argument(metric_options))
+      collect_metric(hash_argument(metric_options).merge(type: :s, name: key, value: value))
     end
 
     private
@@ -195,59 +173,14 @@ module StatsD
       return hash
     end
 
-    def socket
-      if @socket.nil?
-        @socket = UDPSocket.new
-        @socket.connect(host, port)
-      end
-      @socket
-    end
-
-    def collect(type, k, v, options = {})
-      return unless enabled
-      sample_rate = options[:sample_rate] || StatsD.default_sample_rate
-      return if sample_rate < 1 && rand > sample_rate
-
-      packet = generate_packet(type, k, v, sample_rate, options[:tags])
-      write_packet(packet)
-    end
-
-    def write_packet(command)
-      if mode.to_s == 'production'
-        socket.send(command, 0)
-      else
-        logger.info "[StatsD] #{command}"
-      end
-    rescue SocketError, IOError, SystemCallError => e
-      logger.error e
-    end
-
-    def clean_tags(tags)
-      tags = tags.map { |k, v| "#{k}:#{v}" } if tags.is_a?(Hash)
-      tags.map do |tag| 
-        components = tag.split(':', 2)
-        components.map { |c| c.gsub(/[^\w\.-]+/, '_') }.join(':')
-      end
-    end
-
-    def generate_packet(type, k, v, sample_rate = default_sample_rate, tags = nil)
-      command = self.prefix ? self.prefix + '.' : ''
-      command << "#{k}:#{v}|#{type}"
-      command << "|@#{sample_rate}" if sample_rate < 1 || (self.implementation == :statsite && sample_rate > 1)
-      if tags
-        raise ArgumentError, "Tags are only supported on :datadog implementation" unless self.implementation == :datadog
-        command << "|##{clean_tags(tags).join(',')}"
-      end
-
-      command << "\n" if self.implementation == :statsite
-      command
+    def collect_metric(options)
+      backend.collect_metric(StatsD::Instrument::Metric.new(options))
     end
   end
 end
 
-StatsD.enabled = true
-StatsD.default_sample_rate = 1.0
-StatsD.implementation = ENV.fetch('STATSD_IMPLEMENTATION', 'statsd').to_sym
-StatsD.server = ENV['STATSD_ADDR'] if ENV.has_key?('STATSD_ADDR')
-StatsD.mode = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-StatsD.logger = Logger.new($stderr)
+require 'statsd/instrument/metric'
+require 'statsd/instrument/backend'
+require 'statsd/instrument/assertions'
+require 'statsd/instrument/environment'
+require 'statsd/instrument/version'

data/statsd-instrument.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.homepage    = "https://github.com/Shopify/statsd-instrument"
   spec.summary     = %q{A StatsD client for Ruby apps}
   spec.description = %q{A StatsD client for Ruby appspec. Provides metaprogramming methods to inject StatsD instrumentation into your code.}
-  spec.license       = "MIT"
+  spec.license     = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -19,5 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'mocha'
 end