inst_statsd 2.0.4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f5fcae338209105c5074036e543c03f719f4b3ae
-  data.tar.gz: dbb3c4e3de0a2138737637b86b27ae9764fa7c27
+SHA256:
+  metadata.gz: 1a9bd14115668f4b354ae740b4ff35cb5b551c09e7a6795986faafb35c379826
+  data.tar.gz: 4811158906ecebf02185c5ebb4bb67f691e9f61ec3f369903d1cfa502438a554
 SHA512:
-  metadata.gz: 00c31868c01435faa215bccbfaca3675fa86c0f7b7e4a356b57c7c04cdfcf83b20f4a33d31c58c0a46d94731f9c3bf01d1ea0d05f0c6204bfe15cd7daf26bdc6
-  data.tar.gz: 91bec914d1e70b5b497b35e675c9d947f0d8924fce7a20d4b8e9c7d4366becd43fa138f61df7ddc7820ef16e77afdb4764b6d9adaa5f9191cb0f4409d2b982f2
+  metadata.gz: 8d0c8ac4747069dbe6da16c798044d585fa6a32a871730f41bf80fc5cfd0064ddad967789af655e5b3cbd6138f7c169402e43cc563bd3f0748970820cb3e622b
+  data.tar.gz: d0a88767195a8febc5e2c002d02ba9dd6da3438a4830f9c97f8fa013b325d8b8ee00835bcaf63ad2299af1f9db8479664ae55ae1e789208e16b6fcca515eb242

data/lib/inst_statsd.rb

@@ -1,7 +1,8 @@
 require 'statsd'
 
 module InstStatsd
-  VALID_SETTINGS = %i[host port namespace append_hostname mask negative_mask batch_size batch_byte_size].freeze
+  VALID_SETTINGS = %i[host port namespace append_hostname mask negative_mask batch_size batch_byte_size
+                      dog_tags].freeze
 
   class ConfigurationError < StandardError; end
 
@@ -45,11 +46,18 @@ module InstStatsd
         host: env.fetch('INST_STATSD_HOST', nil),
         port: env.fetch('INST_STATSD_PORT', nil),
         namespace: env.fetch('INST_STATSD_NAMESPACE', nil),
-        append_hostname: env.fetch('INST_STATSD_APPEND_HOSTNAME', nil)
+        append_hostname: env.fetch('INST_STATSD_APPEND_HOSTNAME', nil),
+        dog_tags: env.fetch('INST_DOG_TAGS', nil)
       }
       config.delete_if { |_k, v| v.nil? }
       convert_bool(config, :append_hostname)
-      config[:host] ? config : {}
+      if config[:host]
+        config
+      elsif config[:dog_tags]
+        config
+      else
+        {}
+      end
     end
 
     def convert_bool(hash, key)

data/lib/inst_statsd/block_stat.rb

@@ -3,9 +3,14 @@ module InstStatsd
 
     attr_accessor :stats
     attr_accessor :common_key
+    attr_accessor :short_stat
+    attr_accessor :tags
 
-    def initialize(common_key, statsd=InstStatsd::Statsd)
+    def initialize(common_key, statsd=InstStatsd::Statsd, tags: {}, short_stat: nil)
       self.common_key = common_key
+      @tags = tags
+      @short_stat = short_stat
+      @short_stat ||= common_key
       @statsd = statsd
       @stats = {}
     end
@@ -26,10 +31,10 @@ module InstStatsd
     def report
       if common_key
         stats.each do |(key, value)|
-          @statsd.timing("#{common_key}.#{key}", value)
+          @statsd.timing("#{common_key}.#{key}", value, tags: @tags, short_stat: "#{@short_stat}.#{key}")
         end
         exclusive_stats&.each do |(key, value)|
-          @statsd.timing("#{common_key}.exclusive.#{key}", value)
+          @statsd.timing("#{common_key}.exclusive.#{key}", value, tags: @tags, short_stat: "#{@short_stat}.exclusive.#{key}")
         end
       end
     end

data/lib/inst_statsd/block_tracking.rb

@@ -17,7 +17,7 @@ module InstStatsd
         RUBY
       end
 
-      def track(key, category: nil, statsd: InstStatsd::Statsd, only: nil)
+      def track(key, category: nil, statsd: InstStatsd::Statsd, only: nil, tags: {}, short_stat: nil)
         return yield if mask && mask !~ key
         return yield if negative_mask && negative_mask =~ key
 
@@ -26,7 +26,7 @@ module InstStatsd
                   else
                     Counter.counters.map { |(name, counter)| [name, counter.start] }
                   end
-        block_stat = InstStatsd::BlockStat.new(key, statsd)
+        block_stat = InstStatsd::BlockStat.new(key, statsd, tags: tags, short_stat: short_stat)
         stack(category).push(block_stat) if category
 
         result = nil

data/lib/inst_statsd/counter.rb

@@ -13,7 +13,7 @@ module InstStatsd
     attr_reader :key
     attr_reader :blocked_names
 
-    def initialize(key, blocked_names=[])
+    def initialize(key, blocked_names=[], tags: {}, short_stat: nil)
       @blocked_names = blocked_names
       @key = key
       @tls_key = "statsd.#{key}"

data/lib/inst_statsd/request_stat.rb

@@ -7,12 +7,20 @@ module InstStatsd
       @finish = finish
       @id = id
       @payload = payload
+      @statsd  = statsd
     end
 
     def common_key
       common_key = super
       return common_key if common_key
-      self.common_key = "request.#{controller}.#{action}" if controller && action
+      if @statsd.data_dog?
+        self.common_key = "request"
+        self.short_stat = "request"
+        self.tags[:controller] = controller if controller
+        self.tags[:action] = action if action
+      else
+        self.common_key = "request.#{controller}.#{action}" if controller && action
+      end
     end
 
     def report

data/lib/inst_statsd/statsd.rb

@@ -15,6 +15,9 @@
 # So if the namespace is "canvas" and the hostname is "app01", the final stat name of "my_stat" would be "stats.canvas.my_stat.app01"
 # (assuming the default statsd/graphite configuration)
 #
+# If dog_tags is set in statsd.yml, it'll use the tags param and will use
+# Data Dog instead of Statsd
+#
 # If statsd isn't configured and enabled, then calls to InstStatsd::Statsd.* will do nothing and return nil
 
 module InstStatsd
@@ -28,13 +31,17 @@ module InstStatsd
       @hostname ||= Socket.gethostname.split('.').first
     end
 
+    def self.dog_tags
+      @dog_tags ||= {}
+    end
+
     %w[increment decrement count gauge timing].each do |method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def self.#{method}(stat, *args)
+      def self.#{method}(stat, *args, tags: {}, short_stat: nil)
         if self.instance
           if Array === stat
             stat.each do |st|
-              self.#{method}(st, *args)
+              self.#{method}(st, *args, tags: {}, short_stat: nil)
             end
             return
           end
@@ -44,7 +51,16 @@ module InstStatsd
           else
             stat_name = stat.to_s
           end
-          self.instance.#{method}(stat_name, *args)
+
+          if data_dog?
+            tags.merge!(dog_tags) if tags.is_a? Hash
+            tags = convert_tags(tags)
+            tags << 'host:' unless self.append_hostname?
+            short_stat ||= stat_name
+            self.instance.#{method}(short_stat, *args, tags: tags)
+          else
+            self.instance.#{method}(stat_name, *args)
+          end
         else
           nil
         end
@@ -52,10 +68,22 @@ module InstStatsd
       RUBY
     end
 
-    def self.time(stat, sample_rate = 1)
+    def self.convert_tags(tags)
+      new_tags = []
+      if tags.is_a? Hash
+        tags.each do |tag, v|
+          new_tags << "#{tag}:#{v}"
+        end
+      else
+        return tags
+      end
+      new_tags
+    end
+
+    def self.time(stat, sample_rate = 1, tags: {}, short_stat: nil)
       start = Time.now
       result = yield
-      timing(stat, ((Time.now - start) * 1000).round, sample_rate)
+      timing(stat, ((Time.now - start) * 1000).round, sample_rate, tags: tags, short_stat: short_stat)
       result
     end
 
@@ -75,8 +103,14 @@ module InstStatsd
 
       unless defined?(@statsd)
         statsd_settings = InstStatsd.settings
-
-        if statsd_settings && statsd_settings[:host]
+        if statsd_settings.key?(:dog_tags)
+          @data_dog = true
+          host = statsd_settings[:host] || 'localhost'
+          port = statsd_settings[:port] || 8125
+          @statsd = Datadog::Statsd.new(host, port)
+          @statsd.dog_tags = statsd_settings[:dog_tags] || {}
+          @append_hostname = !statsd_settings.key?(:append_hostname) || !!statsd_settings[:append_hostname]
+        elsif statsd_settings && statsd_settings[:host]
           @statsd = ::Statsd.new(statsd_settings[:host])
           @statsd.port = statsd_settings[:port] if statsd_settings[:port]
           @statsd.namespace = statsd_settings[:namespace] if statsd_settings[:namespace]
@@ -94,6 +128,10 @@ module InstStatsd
       @append_hostname
     end
 
+    def self.data_dog?
+      @data_dog
+    end
+
     def self.reset_instance
       remove_instance_variable(:@statsd) if defined?(@statsd)
       Thread.current[:inst_statsd] = nil

data/spec/inst_statsd/block_tracking_spec.rb

@@ -7,28 +7,39 @@ describe InstStatsd::BlockTracking do
 
   it "works" do
     statsd = double()
-    allow(statsd).to receive(:timing).with('mykey.total', anything)
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 1)
+    allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}})
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {}})
 
     InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
       ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
     end
   end
 
+  it "works for data_dog" do
+    statsd = double()
+    allow(statsd).to receive(:data_dog?).and_return true
+    allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {app: "canvas", env: "prod"}})
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {app: "canvas", env: "prod"}})
+
+    InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read', tags: {app: 'canvas', env: 'prod'}, short_stat: 'mykey') do
+      ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+    end
+  end
+
   it "keeps track of exclusive stats too" do
     statsd = double()
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 2).ordered
-    expect(statsd).to receive(:timing).with('mykey.total', anything).ordered
-    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2).ordered
-    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything).ordered
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 2).ordered
-    expect(statsd).to receive(:timing).with('mykey.total', anything).ordered
-    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2).ordered
-    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything).ordered
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 5).ordered
-    expect(statsd).to receive(:timing).with('mykey.total', anything).ordered
-    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 1).ordered
-    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything).ordered
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 2, {short_stat: "mykey.sql.read", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2, {short_stat: "mykey.exclusive.sql.read", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything, {short_stat: "mykey.exclusive.total", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 2, {short_stat: "mykey.sql.read", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2, {short_stat: "mykey.exclusive.sql.read", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything, {short_stat: "mykey.exclusive.total", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 5, {short_stat: "mykey.sql.read", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 1, {short_stat: "mykey.exclusive.sql.read", tags: {}}).ordered
+    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything, {short_stat: "mykey.exclusive.total", tags: {}}).ordered
 
     InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: 'sql.read') do
       ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
@@ -52,8 +63,8 @@ describe InstStatsd::BlockTracking do
     it "only tracks keys that match the mask" do
       InstStatsd::BlockTracking.mask = /mykey/
       statsd = double()
-      allow(statsd).to receive(:timing).with('mykey.total', anything)
-      expect(statsd).to receive(:timing).with("mykey.sql.read", 1)
+      allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}})
+      expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {}})
 
       InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
         InstStatsd::BlockTracking.track("ignoreme", statsd: statsd, only: 'sql.read') do
@@ -65,8 +76,8 @@ describe InstStatsd::BlockTracking do
     it "doesn't track keys that match the negative mask" do
       InstStatsd::BlockTracking.negative_mask = /ignoreme/
       statsd = double()
-      allow(statsd).to receive(:timing).with('mykey.total', anything)
-      expect(statsd).to receive(:timing).with("mykey.sql.read", 1)
+      allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}})
+      expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {}})
 
       InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
         InstStatsd::BlockTracking.track("ignoreme", statsd: statsd, only: 'sql.read') do

data/spec/inst_statsd/inst_statsd_spec.rb

@@ -11,6 +11,7 @@ describe InstStatsd do
       'INST_STATSD_NAMESPACE',
       'INST_STATSD_PORT',
       'INST_STATSD_APPEND_HOST_NAME',
+      'INST_DOG_TAGS'
     ].each {|k| ENV.delete k}
   end
 
@@ -111,6 +112,23 @@ describe InstStatsd do
       expect(InstStatsd.env_settings(env)).to eq({})
     end
 
+    it 'returns empty hash when missing dog tags' do
+      env = {
+        'INST_DOG_API_KEY' => 'SEKRET KEY'
+      }
+      expect(InstStatsd.env_settings(env)).to eq({})
+    end
+
+    it 'builds settings hash with dog environment vars' do
+      env = {
+        'INST_DOG_TAGS' => {app: 'canvas', env: 'prod'},
+      }
+      expected = {
+        dog_tags: {app: 'canvas', env: 'prod'},
+      }
+      expect(InstStatsd.env_settings(env)).to eq(expected)
+    end
+
     it 'builds settings hash from environment vars' do
       env = {
         'INST_STATSD_HOST' => 'statsd.example.org',

data/spec/inst_statsd/request_stat_spec.rb

@@ -69,7 +69,7 @@ describe InstStatsd::RequestStat do
   end
 
   describe '#total' do
-    it 'correctly calcuates milliseconds from start, finish' do
+    it 'correctly calculates milliseconds from start, finish' do
       rs = create_subject({params: {}})
       # start and finish are in seconds
       expect(rs.total).to eq 1000
@@ -85,14 +85,14 @@ describe InstStatsd::RequestStat do
 
   describe '#report' do
     it 'doesnt send stats when no controller or action' do
-      statsd = double
+      statsd = InstStatsd::Statsd
       rs = create_subject({params: {}}, statsd)
-      expect(statsd).to_not receive(:timing).with('request.foo.index', 1000)
+      expect(statsd).to_not receive(:timing).with('request.foo.index', 1000, {short_stat: nil, tags: {}})
       rs.report
     end
 
     it 'sends total timing when controller && action are present, doesnt send db, or view if they are not' do
-      statsd = double
+      statsd = InstStatsd::Statsd
       payload = {
         params: {
           'controller' => 'foo',
@@ -100,12 +100,26 @@ describe InstStatsd::RequestStat do
         }
       }
       rs = create_subject(payload, statsd)
-      expect(statsd).to receive(:timing).with('request.foo.index.total', 1000)
+      expect(statsd).to receive(:timing).with('request.foo.index.total', 1000, {short_stat: ".total", tags: {}})
+      rs.report
+    end
+
+    it 'sends total timing when controller && action are present as tags for data dog' do
+      statsd = InstStatsd::Statsd
+      expect(statsd).to receive(:data_dog?).and_return true
+      payload = {
+        params: {
+          'controller' => 'foo',
+          'action'     => 'index'
+        }
+      }
+      rs = create_subject(payload, statsd)
+      expect(statsd).to receive(:timing).with('request.total', 1000, {short_stat: 'request.total', tags: {action: "index", controller: "foo"}} )
       rs.report
     end
 
     it 'sends view_runtime and db_runtime when present' do
-      statsd = double
+      statsd = InstStatsd::Statsd
       payload = {
         view_runtime: 70.1,
         db_runtime: 100.2,
@@ -115,14 +129,14 @@ describe InstStatsd::RequestStat do
         }
       }
       rs = create_subject(payload, statsd)
-      allow(statsd).to receive(:timing).with('request.foo.index.total', 1000)
-      expect(statsd).to receive(:timing).with('request.foo.index.view', 70.1)
-      expect(statsd).to receive(:timing).with('request.foo.index.db', 100.2)
+      allow(statsd).to receive(:timing).with('request.foo.index.total', 1000, {short_stat: ".total", tags: {}})
+      expect(statsd).to receive(:timing).with('request.foo.index.view', 70.1, {short_stat: ".view", tags: {}})
+      expect(statsd).to receive(:timing).with('request.foo.index.db', 100.2, {short_stat: ".db", tags: {}})
       rs.report
     end
 
     it 'sends cache_read_count when present' do
-      statsd = double
+      statsd = InstStatsd::Statsd
       payload = {
         params: {
           'controller' => 'foo',
@@ -134,7 +148,7 @@ describe InstStatsd::RequestStat do
     describe 'sql stats' do
 
       before :each do
-        @statsd = double
+        @statsd = InstStatsd::Statsd
         payload = {
           params: {
             'controller' => 'foo',
@@ -143,21 +157,21 @@ describe InstStatsd::RequestStat do
         }
         @rs = create_subject(payload, @statsd)
         @rs.stats['cache.read'] = 25
-        expect(@statsd).to receive(:timing).with('request.foo.index.cache.read', 25)
+        expect(@statsd).to receive(:timing).with('request.foo.index.cache.read', 25, {short_stat: ".cache.read", tags: {}})
       end
 
       it 'doesnt send sql stats when they dont exist' do
-        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000)
-        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.read', kind_of(Numeric))
-        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.write', kind_of(Numeric))
-        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.cache', kind_of(Numeric))
+        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000, {short_stat: nil, tags: {}})
+        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.read', kind_of(Numeric), {short_stat: ".sql.read", tags: {}})
+        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.write', kind_of(Numeric), {short_stat: ".sql.write", tags: {}})
+        expect(@statsd).to_not receive(:timing).with('request.foo.index.sql.cache', kind_of(Numeric), {short_stat: ".sql.cache", tags: {}})
         @rs.report
       end
 
       it 'sends sql_read_count when present' do
         @rs.stats['sql.read'] = 10
-        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000)
-        expect(@statsd).to receive(:timing).with('request.foo.index.sql.read', 10)
+        allow(@statsd).to receive(:timing).with('request.foo.index.total', 1000, {short_stat: ".total", tags: {}})
+        expect(@statsd).to receive(:timing).with('request.foo.index.sql.read', 10, {short_stat: ".sql.read", tags: {}})
         @rs.report
       end
     end

data/spec/inst_statsd/statsd_spec.rb

@@ -21,6 +21,58 @@ describe InstStatsd::Statsd do
     expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
   end
 
+  it 'sending tags should not break statsd' do
+    default_tags = {app: 'canvas', env: 'prod'}
+    short_stat = 'test2'
+    allow(InstStatsd::Statsd).to receive(:hostname).and_return('testhost')
+    allow(InstStatsd::Statsd).to receive(:dog_tags).and_return(default_tags)
+    allow(InstStatsd::Statsd).to receive(:short_stat).and_return(short_stat)
+    statsd = double
+    allow(InstStatsd::Statsd).to receive(:instance).and_return(statsd)
+    allow(InstStatsd::Statsd).to receive(:data_dog?).and_return(false)
+    allow(InstStatsd::Statsd).to receive(:append_hostname?).and_return(true)
+    METHODS.each do |method|
+      expect(statsd).to receive(method).with('test.name.testhost', 'test') # no short stat or tags
+      InstStatsd::Statsd.send(method, 'test.name', 'test', short_stat: short_stat, tags: default_tags)
+    end
+    expect(statsd).to receive('timing').with('test.name.testhost', anything, anything) # no short stat or tags
+    expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
+  end
+
+  it 'adds default dog tags default' do
+    default_tags = {app: 'canvas', env: 'prod'}
+    converted_tags = ["app:canvas", "env:prod", "host:"]
+    short_stat = 'test2'
+    allow(InstStatsd::Statsd).to receive(:dog_tags).and_return(default_tags)
+    allow(InstStatsd::Statsd).to receive(:short_stat).and_return(short_stat)
+    statsd = double
+    allow(InstStatsd::Statsd).to receive(:instance).and_return(statsd)
+    allow(InstStatsd::Statsd).to receive(:data_dog?).and_return(true)
+    allow(InstStatsd::Statsd).to receive(:append_hostname?).and_return(false)
+    METHODS.each do |method|
+      expect(statsd).to receive(method).with(short_stat, 'test', tags: converted_tags)
+      InstStatsd::Statsd.send(method, 'test.name', 'test', short_stat: short_stat)
+    end
+    expect(statsd).to receive('timing').with(short_stat, anything, anything, tags: converted_tags)
+    expect(InstStatsd::Statsd.time('test.name', short_stat: short_stat) {'test'}).to eq 'test'
+  end
+
+  it 'uses regular stat name when short_stat is omitted on data dog' do
+    default_tags = {app: 'canvas', env: 'prod'}
+    converted_tags = ["app:canvas", "env:prod", "host:"]
+    allow(InstStatsd::Statsd).to receive(:dog_tags).and_return(default_tags)
+    statsd = double
+    allow(InstStatsd::Statsd).to receive(:instance).and_return(statsd)
+    allow(InstStatsd::Statsd).to receive(:data_dog?).and_return(true)
+    allow(InstStatsd::Statsd).to receive(:append_hostname?).and_return(false)
+    METHODS.each do |method|
+      expect(statsd).to receive(method).with('test.name', 'test', tags: converted_tags)
+      InstStatsd::Statsd.send(method, 'test.name', 'test')
+    end
+    expect(statsd).to receive('timing').with('test.name', anything, anything, tags: converted_tags)
+    expect(InstStatsd::Statsd.time('test.name') {'test'}).to eq 'test'
+  end
+
   it 'omits hostname if specified in config' do
     expect(InstStatsd::Statsd).to receive(:hostname).never
     statsd = double

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst_statsd
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.0
 platform: ruby
 authors:
 - Nick Cloward
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-07 00:00:00.000000000 Z
+date: 2019-02-20 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dogstatsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: statsd-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -147,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Statsd for Instructure