inst_statsd 3.0.2 → 3.0.3

data/spec/inst_statsd/statsd_spec.rb

@@ -1,142 +1,159 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
+
+require "datadog/statsd"
 
 describe InstStatsd::Statsd do
-  METHODS = %w[increment decrement count gauge timing].freeze
+  let(:methods) { %w[increment decrement count gauge timing].freeze }
+  let(:increment_decrement) { %w[increment decrement].freeze }
 
   after do
     InstStatsd.settings = {}
     InstStatsd::Statsd.reset_instance
   end
 
-  it 'includes the events module' do
+  it "includes the events module" do
     expect(described_class).to respond_to :event
   end
 
-  it 'appends the hostname to stat names by default' do
-    allow(InstStatsd::Statsd).to receive(:hostname).and_return('testhost')
-    statsd = double
-    allow(InstStatsd::Statsd).to receive(:instance).and_return(statsd)
-    allow(InstStatsd::Statsd).to receive(:append_hostname?).and_return(true)
-    METHODS.each do |method|
-      expect(statsd).to receive(method).with('test.name.testhost', 'test')
-      InstStatsd::Statsd.send(method, 'test.name', 'test')
+  it "appends the hostname to stat names by default" do
+    statsd = instance_double(Datadog::Statsd)
+    allow(InstStatsd::Statsd).to receive_messages(hostname: "testhost", instance: statsd, append_hostname?: true)
+    methods.each do |method|
+      expect(statsd).to receive(method).with("test.name.testhost", "test")
+      InstStatsd::Statsd.send(method, "test.name", "test")
     end
-    expect(statsd).to receive('timing').with('test.name.testhost', anything, anything)
-    expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
+    expect(statsd).to receive("timing").with("test.name.testhost", anything, anything)
+    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'
+  it "sending tags should not break statsd" do
+    default_tags = { app: "canvas", env: "prod" }
+    short_stat = "test2"
     env = {
-      'INST_DOG_TAGS' => '{"app": "canvas", "env": "prod"}',
+      "INST_DOG_TAGS" => '{"app": "canvas", "env": "prod"}'
     }
     InstStatsd.env_settings(env)
-    allow(InstStatsd::Statsd).to receive(:hostname).and_return('testhost')
-    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)
+    statsd = instance_double(Datadog::Statsd)
+    allow(InstStatsd::Statsd).to receive_messages(hostname: "testhost",
+                                                  short_stat: short_stat,
+                                                  instance: statsd,
+                                                  data_dog?: false,
+                                                  append_hostname?: 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'
+    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'}
+  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)
+    short_stat = "test2"
+    statsd = instance_double(Datadog::Statsd)
+    allow(InstStatsd::Statsd).to receive_messages(dog_tags: default_tags,
+                                                  short_stat: short_stat,
+                                                  instance: statsd,
+                                                  data_dog?: true,
+                                                  append_hostname?: false)
+    methods.each do |method|
+      args = [short_stat]
+      args << "test" unless increment_decrement.include?(method)
+
+      expect(statsd).to receive(method).with(*args, { tags: converted_tags })
+      InstStatsd::Statsd.send(method, *args, short_stat: short_stat)
     end
-    expect(statsd).to receive('timing').with(short_stat, anything, sample_rate: anything, tags: converted_tags)
-    expect(InstStatsd::Statsd.time('test.name', short_stat: short_stat) {'test'}).to eq 'test'
+    expect(statsd).to receive("timing").with(short_stat, anything, { sample_rate: 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'}
+  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')
+    statsd = instance_double(Datadog::Statsd)
+    allow(InstStatsd::Statsd).to receive_messages(dog_tags: default_tags,
+                                                  instance: statsd,
+                                                  data_dog?: true,
+                                                  append_hostname?: false)
+    methods.each do |method|
+      args = ["test.name"]
+      args << "test" unless increment_decrement.include?(method)
+
+      expect(statsd).to receive(method).with(*args, { tags: converted_tags })
+      InstStatsd::Statsd.send(method, *args)
     end
-    expect(statsd).to receive('timing').with('test.name', anything, sample_rate: anything, tags: converted_tags)
-    expect(InstStatsd::Statsd.time('test.name') {'test'}).to eq 'test'
+    expect(statsd).to receive("timing").with("test.name", anything, { sample_rate: 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
-    allow(InstStatsd::Statsd).to receive(:instance).and_return(statsd)
-    allow(InstStatsd::Statsd).to receive(:append_hostname?).and_return(false)
-    METHODS.each do |method|
-      expect(statsd).to receive(method).with('test.name', 'test')
-      InstStatsd::Statsd.send(method, 'test.name', 'test')
+  it "omits hostname if specified in config" do
+    expect(InstStatsd::Statsd).not_to receive(:hostname)
+    statsd = instance_double(Datadog::Statsd)
+    allow(InstStatsd::Statsd).to receive_messages(instance: statsd, append_hostname?: false)
+    methods.each do |method|
+      expect(statsd).to receive(method).with("test.name", "test")
+      InstStatsd::Statsd.send(method, "test.name", "test")
     end
-    expect(statsd).to receive('timing').with('test.name', anything, anything)
-    expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
+    expect(statsd).to receive("timing").with("test.name", anything, anything)
+    expect(InstStatsd::Statsd.time("test.name") { "test" }).to eq "test"
   end
 
-  context 'with datadog enabled' do
-    it 'handles being called with an array of stat names' do
+  context "with datadog enabled" do
+    it "handles being called with an array of stat names" do
       converted_tags = %w[tag:value host:]
-      statsd = double
-      allow(InstStatsd::Statsd).to receive(:instance).and_return(statsd)
-      allow(InstStatsd::Statsd).to receive(:append_hostname?).and_return(false)
-      allow(InstStatsd::Statsd).to receive(:data_dog?).and_return(true)
-      METHODS.each do |method|
-        expect(statsd).to receive(method).once.with('test.one', 'value', tags: converted_tags)
-        expect(statsd).to receive(method).once.with('test.two', 'value', tags: converted_tags)
-        InstStatsd::Statsd.send(method, %w[test.one test.two], 'value', tags: {tag: 'value'}, short_stat: 'short_stat')
+      statsd = instance_double(Datadog::Statsd)
+      allow(InstStatsd::Statsd).to receive_messages(instance: statsd, append_hostname?: false, data_dog?: true)
+      methods.each do |method|
+        args = []
+        args << "values" unless increment_decrement.include?(method)
+
+        expect(statsd).to receive(method).once.with("test.one", *args, { tags: converted_tags })
+        expect(statsd).to receive(method).once.with("test.two", *args, { tags: converted_tags })
+        InstStatsd::Statsd.send(method,
+                                %w[test.one test.two],
+                                *args,
+                                tags: { tag: "value" },
+                                short_stat: "short_stat")
       end
-      expect(statsd).to receive('timing').once.with('test.one', anything, tags: converted_tags, sample_rate: anything)
-      expect(statsd).to receive('timing').once.with('test.two', anything, tags: converted_tags, sample_rate: anything)
-      expect(InstStatsd::Statsd.time(%w[test.one test.two], tags: {tag: 'value'}, short_stat: 'short_stat') { 'test' }).to eq 'test'
+      expect(statsd).to receive("timing").once.with("test.one",
+                                                    anything,
+                                                    { tags: converted_tags, sample_rate: anything })
+      expect(statsd).to receive("timing").once.with("test.two",
+                                                    anything,
+                                                    { tags: converted_tags, sample_rate: anything })
+      expect(InstStatsd::Statsd.time(%w[test.one test.two], tags: { tag: "value" }, short_stat: "short_stat") do
+               "test"
+             end).to eq "test"
     end
   end
 
   it "ignores all calls if statsd isn't enabled" do
     allow(InstStatsd::Statsd).to receive(:instance).and_return(nil)
-    METHODS.each do |method|
-      expect(InstStatsd::Statsd.send(method, 'test.name')).to be_nil
+    methods.each do |method|
+      expect(InstStatsd::Statsd.send(method, "test.name")).to be_nil
     end
-    expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
+    expect(InstStatsd::Statsd.time("test.name") { "test" }).to eq "test"
   end
 
-  it 'configures a statsd instance' do
+  it "configures a statsd instance" do
     expect(InstStatsd::Statsd.instance).to be_nil
 
-    InstStatsd.settings = { host: 'localhost', namespace: 'test', port: 1234 }
+    InstStatsd.settings = { host: "localhost", namespace: "test", port: 1234 }
     InstStatsd::Statsd.reset_instance
 
     instance = InstStatsd::Statsd.instance
-    expect(instance).to be_a ::Statsd
-    expect(instance.host).to eq 'localhost'
+    expect(instance).to be_a Statsd
+    expect(instance.host).to eq "localhost"
     expect(instance.port).to eq 1234
-    expect(instance.namespace).to eq 'test'
+    expect(instance.namespace).to eq "test"
   end
 
-  describe '.batch' do
-    it 'is properly reentrant' do
-      InstStatsd.settings = { host: 'localhost', namespace: 'test', port: 1234 }
+  describe ".batch" do
+    it "is properly reentrant" do
+      InstStatsd.settings = { host: "localhost", namespace: "test", port: 1234 }
       InstStatsd::Statsd.reset_instance
 
       statsd = InstStatsd::Statsd.instance
@@ -144,9 +161,9 @@ describe InstStatsd::Statsd do
         batch1 = InstStatsd::Statsd.instance
         InstStatsd::Statsd.batch do
           batch2 = InstStatsd::Statsd.instance
-          expect(statsd).to be_a ::Statsd
-          expect(batch1).to be_a ::Statsd::Batch
-          expect(batch2).to be_a ::Statsd::Batch
+          expect(statsd).to be_a Statsd
+          expect(batch1).to be_a Statsd::Batch
+          expect(batch2).to be_a Statsd::Batch
           expect(batch1).not_to eq batch2
         end
         expect(InstStatsd::Statsd.instance).to eq batch1
@@ -155,21 +172,21 @@ describe InstStatsd::Statsd do
     end
   end
 
-  describe '.escape' do
-    it 'replaces any dots in str with a _ when no replacment given' do
-      result = InstStatsd::Statsd.escape('lots.of.dots')
-      expect(result).to eq 'lots_of_dots'
+  describe ".escape" do
+    it "replaces any dots in str with a _ when no replacment given" do
+      result = InstStatsd::Statsd.escape("lots.of.dots")
+      expect(result).to eq "lots_of_dots"
     end
 
-    it 'replaces any dots in str with replacement arg' do
-      result = InstStatsd::Statsd.escape('lots.of.dots', '/')
-      expect(result).to eq 'lots/of/dots'
+    it "replaces any dots in str with replacement arg" do
+      result = InstStatsd::Statsd.escape("lots.of.dots", "/")
+      expect(result).to eq "lots/of/dots"
     end
 
-    it 'returns str when given a str that doesnt respond to gsub' do
+    it "returns str when given a str that doesnt respond to gsub" do
       result = InstStatsd::Statsd.escape(nil)
-      expect(result).to eq nil
-      hash = { foo: 'bar' }
+      expect(result).to be_nil
+      hash = { foo: "bar" }
       result = InstStatsd::Statsd.escape(hash)
       expect(result).to eq hash
     end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'inst_statsd'
+require "inst_statsd"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
@@ -8,5 +8,5 @@ RSpec.configure do |config|
 
   config.raise_errors_for_deprecations!
 
-  config.order = 'random'
+  config.order = "random"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst_statsd
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Nick Cloward
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-09-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: aroi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.7
 - !ruby/object:Gem::Dependency
   name: dogstatsd-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -52,21 +66,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: aroi
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.7
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,21 +108,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -108,7 +136,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop-inst
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -122,7 +150,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -173,7 +215,8 @@ files:
 homepage: https://github.com/instructure/inst_statsd
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -193,17 +236,4 @@ rubygems_version: 3.2.6
 signing_key: 
 specification_version: 4
 summary: Statsd for Instructure
-test_files:
-- spec/inst_statsd/block_stat_spec.rb
-- spec/inst_statsd/block_tracking_spec.rb
-- spec/inst_statsd/counter_spec.rb
-- spec/inst_statsd/event_spec.rb
-- spec/inst_statsd/inst_statsd_spec.rb
-- spec/inst_statsd/null_logger_spec.rb
-- spec/inst_statsd/request_logger_spec.rb
-- spec/inst_statsd/request_stat_spec.rb
-- spec/inst_statsd/request_tracking_spec.rb
-- spec/inst_statsd/sql_tracker_spec.rb
-- spec/inst_statsd/statsd_spec.rb
-- spec/spec_helper.rb
-- spec/support/test.log
+test_files: []