statsd-instrument 1.7.2 → 2.0.0

data/lib/statsd/instrument.rb

@@ -1,9 +1,6 @@
 require 'socket'
-require 'benchmark'
 require 'logger'
 
-require 'statsd/instrument/version'
-
 module StatsD
   module Instrument
 
@@ -11,6 +8,20 @@ module StatsD
       metric_name.respond_to?(:call) ? metric_name.call(callee, args).gsub('::', '.') : metric_name.gsub('::', '.')
     end
 
+    if Process.respond_to?(:clock_gettime)
+      def self.duration
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      end
+    else
+      def self.duration
+        start = Time.now
+        yield
+        Time.now - start
+      end
+    end
+
     def statsd_measure(method, name, *metric_options)
       add_to_method(method, name, :measure) do |old_method, new_method, metric_name, *args|
         define_method(new_method) do |*args, &block|
@@ -110,41 +121,24 @@ 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))
+      value  = 1000 * StatsD::Instrument.duration { result = block.call } if block_given?
+      metric = collect_metric(hash_argument(metric_options).merge(type: :ms, name: key, value: value))
+      result = metric unless block_given?
       result
     end
 
@@ -155,29 +149,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
@@ -190,64 +182,20 @@ module StatsD
       hash = {}
       args.each_with_index do |value, index|
         hash[order[index]] = value
-      end    
-      
-      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
+      return hash
     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(metric = StatsD::Instrument::Metric.new(options))
+      metric
     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

data/test/assertions_test.rb

@@ -0,0 +1,126 @@
+require 'test_helper'
+
+class AssertionsTest < Minitest::Test
+
+  def setup
+    test_class = Class.new(Minitest::Test)
+    test_class.send(:include, StatsD::Instrument::Assertions)
+    @test_case = test_class.new('fake')
+  end
+
+  def test_capture_metrics_inside_block_only
+    StatsD.increment('counter')
+    metrics = @test_case.capture_statsd_calls do
+      StatsD.increment('counter')
+      StatsD.gauge('gauge', 12)
+    end
+    StatsD.gauge('gauge', 15)
+
+    assert_equal 2, metrics.length
+    assert_equal 'counter', metrics[0].name
+    assert_equal 'gauge', metrics[1].name
+    assert_equal 12, metrics[1].value
+  end
+
+  def test_assert_no_statsd_calls
+    assert_no_assertion_triggered do
+      @test_case.assert_no_statsd_calls('counter') do
+        # noop
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_no_statsd_calls('counter') do
+        StatsD.increment('other')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_no_statsd_calls('counter') do
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_no_statsd_calls do
+        StatsD.increment('other')
+      end
+    end    
+  end
+
+  def test_assert_statsd_call
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('counter')
+        StatsD.increment('other')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('other')
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.gauge('counter', 42)
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter') do
+        StatsD.increment('counter')
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', times: 2) do
+        StatsD.increment('counter')
+        StatsD.increment('counter')
+      end
+    end
+
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
+        StatsD.increment('counter', sample_rate: 0.5, tags: ['a', 'b'])
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: ['a', 'b']) do
+        StatsD.increment('counter', sample_rate: 0.2, tags: ['c'])
+      end
+    end
+  end
+
+  private
+
+  def assert_no_assertion_triggered(&block)
+    block.call
+  rescue MiniTest::Assertion => assertion
+    flunk "No assertion trigger expected, but one was triggered with message #{assertion.message}."
+  else
+    pass
+  end
+
+  def assert_assertion_triggered(message = nil, &block)
+    block.call
+  rescue MiniTest::Assertion => assertion
+    if message
+      assert_equal message, assertion.message, "Assertion triggered, but message was not what was expected."
+    else
+      pass
+    end
+    assertion
+  else
+    flunk "No assertion was triggered, but one was expected."
+  end
+end

data/test/capture_backend_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class CaptureBackendTest < Minitest::Test
+  def setup
+    @backend = StatsD::Instrument::Backends::CaptureBackend.new
+    @metric1 = StatsD::Instrument::Metric::new(type: :c, name: 'mock.counter')
+    @metric2 = StatsD::Instrument::Metric::new(type: :ms, name: 'mock.measure', value: 123)
+  end
+
+  def test_collecting_metric
+    assert @backend.collected_metrics.empty?
+    @backend.collect_metric(@metric1)
+    @backend.collect_metric(@metric2)
+    assert_equal [@metric1, @metric2], @backend.collected_metrics
+  end
+
+  def test_reset
+    @backend.collect_metric(@metric1)
+    @backend.reset
+    assert @backend.collected_metrics.empty?
+    @backend.collect_metric(@metric2)
+    assert_equal [@metric2], @backend.collected_metrics
+  end
+end

data/test/environment_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class EnvironmentTest < Minitest::Test
+
+  def setup
+    ENV['STATSD_ADDR'] = nil
+    ENV['IMPLEMENTATION'] = nil
+  end
+
+  def test_uses_logger_in_development_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('development')
+    assert_instance_of StatsD::Instrument::Backends::LoggerBackend, StatsD::Instrument::Environment.default_backend
+  end
+
+  def test_uses_null_backend_in_test_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('test')
+    assert_instance_of StatsD::Instrument::Backends::NullBackend, StatsD::Instrument::Environment.default_backend
+  end
+
+  def test_uses_udp_backend_in_production_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('production')
+    assert_instance_of StatsD::Instrument::Backends::UDPBackend, StatsD::Instrument::Environment.default_backend
+  end
+
+  def test_uses_environment_variables_in_production_environment
+    StatsD::Instrument::Environment.stubs(:environment).returns('production')
+    ENV['STATSD_ADDR'] = '127.0.0.1:1234'
+    ENV['STATSD_IMPLEMENTATION'] = 'datadog'
+
+    backend = StatsD::Instrument::Environment.default_backend
+    assert_equal '127.0.0.1', backend.host
+    assert_equal 1234, backend.port
+    assert_equal :datadog, backend.implementation
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class IntegrationTest < Minitest::Test
+
+  def setup
+    @old_backend, StatsD.backend = StatsD.backend, StatsD::Instrument::Backends::UDPBackend.new("localhost:31798")
+  end
+  
+  def teardown
+    StatsD.backend = @old_backend
+  end
+
+  def test_live_local_udp_socket
+    server = UDPSocket.new
+    server.bind('localhost', 31798)
+
+    StatsD.increment('counter')
+    assert_equal "counter:1|c", server.recvfrom(100).first
+  end
+end

data/test/logger_backend_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class LoggerBackendTest < Minitest::Test
+  def setup
+    logger = Logger.new(@io = StringIO.new)
+    logger.formatter = lambda { |_,_,_, msg| "#{msg}\n" }
+    @backend = StatsD::Instrument::Backends::LoggerBackend.new(logger)
+    @metric1 = StatsD::Instrument::Metric::new(type: :c, name: 'mock.counter', tags: { a: 'b', c: 'd'})
+    @metric2 = StatsD::Instrument::Metric::new(type: :ms, name: 'mock.measure', value: 123, sample_rate: 0.3)
+  end
+
+  def test_logs_metrics
+    @backend.collect_metric(@metric1)
+    assert_equal @io.string, "[StatsD] increment mock.counter:1 #a:b #c:d\n"
+    @io.string = ""
+
+    @backend.collect_metric(@metric2)
+    assert_equal @io.string, "[StatsD] measure mock.measure:123 @0.3\n"
+  end
+end

data/test/metric_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class MetricTest < Minitest::Test
+
+  def test_required_arguments
+    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :c) }
+    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(name: 'test') }
+    assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :ms, name: 'test') }
+  end
+
+  def test_default_values
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
+    assert_equal 1, m.value
+    assert_equal StatsD.default_sample_rate, m.sample_rate
+    assert m.tags.nil?
+  end
+
+  def test_name_prefix
+    StatsD.stubs(:prefix).returns('prefix')
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
+    assert_equal 'prefix.counter', m.name
+
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', no_prefix: true)
+    assert_equal 'counter', m.name
+  end
+
+  def test_rewrite_shitty_tags
+    assert_equal ['igno_red'], StatsD::Instrument::Metric.normalize_tags(['igno,red'])
+    assert_equal ['igno_red'], StatsD::Instrument::Metric.normalize_tags(['igno  red'])
+    assert_equal ['test:test_test'], StatsD::Instrument::Metric.normalize_tags(['test:test:test'])
+    assert_equal ['topic:foo_foo', 'bar_'], StatsD::Instrument::Metric.normalize_tags(['topic:foo : foo', 'bar '])
+  end
+  
+  def test_rewrite_tags_provided_as_hash
+    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(:tag => 'value')
+    assert_equal ['tag:value', 'tag2:value2'], StatsD::Instrument::Metric.normalize_tags(:tag => 'value', :tag2 => 'value2')
+  end
+end