inst_statsd 3.0.2 → 3.0.4

data/spec/inst_statsd/inst_statsd_spec.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe InstStatsd do
-  before(:each) do
+  before do
     InstStatsd.settings = nil
   end
 
-  after(:each) do
-    [
-      'INST_STATSD_HOST',
-      'INST_STATSD_NAMESPACE',
-      'INST_STATSD_PORT',
-      'INST_STATSD_APPEND_HOST_NAME',
-      'INST_DOG_TAGS'
-    ].each {|k| ENV.delete k}
+  after do
+    %w[
+      INST_STATSD_HOST
+      INST_STATSD_NAMESPACE
+      INST_STATSD_PORT
+      INST_STATSD_APPEND_HOST_NAME
+      INST_DOG_TAGS
+    ].each { |k| ENV.delete k }
   end
 
   describe ".settings" do
@@ -23,185 +23,189 @@ describe InstStatsd do
     end
 
     it "can be assigned a new value" do
-      settings = { host: 'bar', port: 1234 }
+      settings = { host: "bar", port: 1234 }
       InstStatsd.settings = settings
 
       expect(InstStatsd.settings).to eq settings
     end
 
-    it 'pulls from ENV if not already set' do
-      ENV['INST_STATSD_HOST'] = 'statsd.example.org'
-      ENV['INST_STATSD_NAMESPACE'] = 'canvas'
+    it "pulls from ENV if not already set" do
+      ENV["INST_STATSD_HOST"] = "statsd.example.org"
+      ENV["INST_STATSD_NAMESPACE"] = "canvas"
 
       expected = {
-        host: 'statsd.example.org',
-        namespace: 'canvas',
+        host: "statsd.example.org",
+        namespace: "canvas"
       }
       expect(InstStatsd.settings).to eq(expected)
     end
 
-    it 'configured settings are merged into and take precedence over any existing ENV settings' do
-      ENV['INST_STATSD_HOST'] = 'statsd.example.org'
-      ENV['INST_STATSD_NAMESPACE'] = 'canvas'
+    it "configured settings are merged into and take precedence over any existing ENV settings" do
+      ENV["INST_STATSD_HOST"] = "statsd.example.org"
+      ENV["INST_STATSD_NAMESPACE"] = "canvas"
 
-      settings = { host: 'statsd.example-override.org' }
+      settings = { host: "statsd.example-override.org" }
       InstStatsd.settings = settings
 
       expect(InstStatsd.settings).to eq(InstStatsd.env_settings.merge(settings))
       expect(InstStatsd.settings[:host]).to eq(settings[:host])
     end
 
-    it 'validates settings' do
-      settings = { foo: 'blah' }
+    it "validates settings" do
+      settings = { foo: "blah" }
       expect { InstStatsd.settings = settings }.to raise_error(InstStatsd::ConfigurationError)
     end
 
-    it 'converts string keys to symbols' do
-      settings = { 'host' => 'bar', 'port' => 1234 }
+    it "converts string keys to symbols" do
+      settings = { "host" => "bar", "port" => 1234 }
       InstStatsd.settings = settings
-      expect(InstStatsd.settings).to eq({ host: 'bar', port: 1234 })
+      expect(InstStatsd.settings).to eq({ host: "bar", port: 1234 })
     end
   end
 
   describe ".convert_bool" do
-    it 'sets string true values to boolean true' do
-      config = {potential_string_bool: 'true'}
+    it "sets string true values to boolean true" do
+      config = { potential_string_bool: "true" }
       InstStatsd.convert_bool(config, :potential_string_bool)
       expect(config[:potential_string_bool]).to be(true)
     end
-    it 'sets string True values to boolean true' do
-      config = {potential_string_bool: 'True'}
+
+    it "sets string True values to boolean true" do
+      config = { potential_string_bool: "True" }
       InstStatsd.convert_bool(config, :potential_string_bool)
       expect(config[:potential_string_bool]).to be(true)
     end
-    it 'sets boolean true values to boolean true' do
-      config = {potential_string_bool: true}
+
+    it "sets boolean true values to boolean true" do
+      config = { potential_string_bool: true }
       InstStatsd.convert_bool(config, :potential_string_bool)
       expect(config[:potential_string_bool]).to be(true)
     end
-    it 'sets false strings to boolean false' do
-      config = {potential_string_bool: 'false'}
+
+    it "sets false strings to boolean false" do
+      config = { potential_string_bool: "false" }
       InstStatsd.convert_bool(config, :potential_string_bool)
       expect(config[:potential_string_bool]).to be(false)
     end
-    it 'sets False strings to boolean false' do
-      config = {potential_string_bool: 'False'}
+
+    it "sets False strings to boolean false" do
+      config = { potential_string_bool: "False" }
       InstStatsd.convert_bool(config, :potential_string_bool)
       expect(config[:potential_string_bool]).to be(false)
     end
-    it 'sets false booleans to boolean false' do
-      config = {potential_string_bool: false}
+
+    it "sets false booleans to boolean false" do
+      config = { potential_string_bool: false }
       InstStatsd.convert_bool(config, :potential_string_bool)
       expect(config[:potential_string_bool]).to be(false)
     end
-    it 'makes no change for nil values' do
-      config = {foo: 'bar'}
+
+    it "makes no change for nil values" do
+      config = { foo: "bar" }
       InstStatsd.convert_bool(config, :potential_string_bool)
-      expect(config).to eq({foo: 'bar'})
-    end
-    it 'raises error for non true or false strings or booleans' do
-      config = {potential_string_bool: 'trrruuue'}
-      expect{InstStatsd.convert_bool(config, :potential_string_bool)}.to raise_error(InstStatsd::ConfigurationError)
+      expect(config).to eq({ foo: "bar" })
     end
 
+    it "raises error for non true or false strings or booleans" do
+      config = { potential_string_bool: "trrruuue" }
+      expect { InstStatsd.convert_bool(config, :potential_string_bool) }.to raise_error(InstStatsd::ConfigurationError)
+    end
   end
 
   describe ".env_settings" do
-    it 'returns empty hash when no INST_STATSD_HOST found' do
+    it "returns empty hash when no INST_STATSD_HOST found" do
       env = {
-        'INST_STATSD_NAMESPACE' => 'canvas'
+        "INST_STATSD_NAMESPACE" => "canvas"
       }
       expect(InstStatsd.env_settings(env)).to eq({})
     end
 
-    it 'returns empty hash when missing dog tags' do
+    it "returns empty hash when missing dog tags" do
       env = {
-        'INST_DOG_API_KEY' => 'SEKRET KEY'
+        "INST_DOG_API_KEY" => "SEKRET KEY"
       }
       expect(InstStatsd.env_settings(env)).to eq({})
     end
 
-    it 'builds settings hash with dog environment vars' do
+    it "builds settings hash with dog environment vars" do
       env = {
-        'INST_DOG_TAGS' => '{"app": "canvas", "env": "prod"}',
+        "INST_DOG_TAGS" => '{"app": "canvas", "env": "prod"}'
       }
       expected = {
-        dog_tags: {"app" => "canvas", "env" => "prod"},
+        dog_tags: { "app" => "canvas", "env" => "prod" }
       }
       expect(InstStatsd.env_settings(env)).to eq(expected)
     end
 
-    it 'builds settings hash from environment vars' do
+    it "builds settings hash from environment vars" do
       env = {
-        'INST_STATSD_HOST' => 'statsd.example.org',
-        'INST_STATSD_NAMESPACE' => 'canvas',
+        "INST_STATSD_HOST" => "statsd.example.org",
+        "INST_STATSD_NAMESPACE" => "canvas"
       }
       expected = {
-        host: 'statsd.example.org',
-        namespace: 'canvas',
+        host: "statsd.example.org",
+        namespace: "canvas"
       }
       expect(InstStatsd.env_settings(env)).to eq(expected)
     end
 
-    it 'uses ENV if env argument hash not passed' do
-      ENV['INST_STATSD_HOST'] = 'statsd.example.org'
-      ENV['INST_STATSD_NAMESPACE'] = 'canvas'
+    it "uses ENV if env argument hash not passed" do
+      ENV["INST_STATSD_HOST"] = "statsd.example.org"
+      ENV["INST_STATSD_NAMESPACE"] = "canvas"
 
       expected = {
-        host: 'statsd.example.org',
-        namespace: 'canvas',
+        host: "statsd.example.org",
+        namespace: "canvas"
       }
       expect(InstStatsd.env_settings).to eq(expected)
     end
 
     it 'converts env append_hostname "false" to boolean' do
       env = {
-        'INST_STATSD_HOST' => 'statsd.example.org',
-        'INST_STATSD_APPEND_HOSTNAME' => 'false',
+        "INST_STATSD_HOST" => "statsd.example.org",
+        "INST_STATSD_APPEND_HOSTNAME" => "false"
       }
       expected = {
-        host: 'statsd.example.org',
-        append_hostname: false,
+        host: "statsd.example.org",
+        append_hostname: false
       }
       expect(InstStatsd.env_settings(env)).to eq(expected)
     end
 
     it 'converts env append_hostname "true" to boolean' do
       env = {
-        'INST_STATSD_HOST' => 'statsd.example.org',
-        'INST_STATSD_APPEND_HOSTNAME' => 'true',
+        "INST_STATSD_HOST" => "statsd.example.org",
+        "INST_STATSD_APPEND_HOSTNAME" => "true"
       }
       expected = {
-        host: 'statsd.example.org',
-        append_hostname: true,
+        host: "statsd.example.org",
+        append_hostname: true
       }
       expect(InstStatsd.env_settings(env)).to eq(expected)
     end
 
-    it 'keeps boolean false values for append_hostname' do
+    it "keeps boolean false values for append_hostname" do
       env = {
-        'INST_STATSD_HOST' => 'statsd.example.org',
-        'INST_STATSD_APPEND_HOSTNAME' => false,
+        "INST_STATSD_HOST" => "statsd.example.org",
+        "INST_STATSD_APPEND_HOSTNAME" => false
       }
       expected = {
-        host: 'statsd.example.org',
-        append_hostname: false,
+        host: "statsd.example.org",
+        append_hostname: false
       }
       expect(InstStatsd.env_settings(env)).to eq(expected)
     end
 
-    it 'keeps boolean true values for append_hostname' do
+    it "keeps boolean true values for append_hostname" do
       env = {
-        'INST_STATSD_HOST' => 'statsd.example.org',
-        'INST_STATSD_APPEND_HOSTNAME' => true,
+        "INST_STATSD_HOST" => "statsd.example.org",
+        "INST_STATSD_APPEND_HOSTNAME" => true
       }
       expected = {
-        host: 'statsd.example.org',
-        append_hostname: true,
+        host: "statsd.example.org",
+        append_hostname: true
       }
       expect(InstStatsd.env_settings(env)).to eq(expected)
     end
-
   end
-
 end

data/spec/inst_statsd/null_logger_spec.rb

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe InstStatsd::NullLogger do
-
-  describe 'initialize' do
-    it 'takes any arguments' do
-      expect{InstStatsd::NullLogger.new}.to_not raise_error
-      expect{InstStatsd::NullLogger.new(1, 2, 3)}.to_not raise_error
+  describe "initialize" do
+    it "takes any arguments" do
+      expect { InstStatsd::NullLogger.new }.not_to raise_error
+      expect { InstStatsd::NullLogger.new(1, 2, 3) }.not_to raise_error
     end
   end
 
-  describe 'debug, info, warn, fatal, and unknown' do
-    it 'should all no-op instead of logging' do
-      log_path = 'spec/support/test.log'
-      File.open(log_path, 'w') { |f| f.write('') } # empty log file
+  describe "debug, info, warn, fatal, and unknown" do
+    it "should all no-op instead of logging" do
+      log_path = "spec/support/test.log"
+      File.write(log_path, "") # empty log file
       logger = InstStatsd::NullLogger.new(log_path)
-      %w[debug info warn error fatal unknown].each { |m| logger.send(m, 'foo') }
+      %w[debug info warn error fatal unknown].each { |m| logger.send(m, "foo") }
       log_contents = File.read(log_path)
-      expect(log_contents).to eq ''
+      expect(log_contents).to eq ""
     end
   end
-
 end

data/spec/inst_statsd/request_logger_spec.rb

@@ -1,60 +1,56 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'logger'
+require "spec_helper"
+require "logger"
 
 describe InstStatsd::RequestLogger do
-
-  describe '#build_log_message' do
-    before :all do
-      @logger = InstStatsd::RequestLogger.new(Logger.new(STDOUT))
+  describe "#build_log_message" do
+    before do
+      @logger = InstStatsd::RequestLogger.new(Logger.new($stdout))
     end
-    it 'includes the supplied header' do
-      request_stat = double('request_stat')
-      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
-      allow(request_stat).to receive(:stats).and_return({})
-      results = @logger.build_log_message(request_stat, 'FOO_STATS')
+
+    it "includes the supplied header" do
+      request_stat = instance_double(InstStatsd::RequestStat)
+      allow(request_stat).to receive_messages(exclusive_stats: nil, stats: {})
+      results = @logger.build_log_message(request_stat, "FOO_STATS")
       expect(results).to eq("[FOO_STATS]")
     end
-    it 'falls back to the default header' do
-      request_stat = double('request_stat')
-      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
-      allow(request_stat).to receive(:stats).and_return({})
+
+    it "falls back to the default header" do
+      request_stat = instance_double(InstStatsd::RequestStat)
+      allow(request_stat).to receive_messages(exclusive_stats: nil, stats: {})
       results = @logger.build_log_message(request_stat)
       expect(results).to eq("[STATSD]")
     end
-    it 'includes stats that are available' do
-      request_stat = double('request_stat')
-      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
-      allow(request_stat).to receive(:stats).and_return(
-          "total" => 100.21,
-          "active.record" => 24)
+
+    it "includes stats that are available" do
+      request_stat = instance_double(InstStatsd::RequestStat)
+      allow(request_stat).to receive_messages(exclusive_stats: nil, stats: { "total" => 100.21,
+                                                                             "active.record" => 24 })
       results = @logger.build_log_message(request_stat)
       expect(results).to eq("[STATSD] (total: 100.21) (active_record: 24.00)")
     end
 
-    it 'includes exclusive_stats if there are any' do
-      request_stat = double('request_stat')
-      allow(request_stat).to receive(:stats).and_return(
-          "total" => 100.21,
-          "active.record" => 24)
-      allow(request_stat).to receive(:exclusive_stats).and_return(
-          "total" => 54.32,
-          "active.record" => 1)
+    it "includes exclusive_stats if there are any" do
+      request_stat = instance_double(InstStatsd::RequestStat)
+      allow(request_stat).to receive_messages(stats: { "total" => 100.21,
+                                                       "active.record" => 24 },
+                                              exclusive_stats: { "total" => 54.32,
+                                                                 "active.record" => 1 })
       results = @logger.build_log_message(request_stat)
-      expect(results).to eq("[STATSD] (total: 100.21) (active_record: 24.00) (exclusive_total: 54.32) (exclusive_active_record: 1.00)")
+      expect(results).to eq("[STATSD] (total: 100.21) (active_record: 24.00) (exclusive_total: 54.32) (exclusive_active_record: 1.00)") # rubocop:disable Layout/LineLength
     end
 
-    describe 'decimal precision' do
-      it 'forces 2 decimal precision' do
-        request_stat = double('request_stat')
-        allow(request_stat).to receive(:stats).and_return(total: 72.1)
-        allow(request_stat).to receive(:exclusive_stats).and_return(nil)
+    describe "decimal precision" do
+      it "forces 2 decimal precision" do
+        request_stat = instance_double(InstStatsd::RequestStat)
+        allow(request_stat).to receive_messages(stats: { total: 72.1 }, exclusive_stats: nil)
         results = @logger.build_log_message(request_stat)
         expect(results).to eq("[STATSD] (total: 72.10)")
       end
-      it 'rounds values to 2 decimals' do
-        request_stat = double('request_stat')
+
+      it "rounds values to 2 decimals" do
+        request_stat = instance_double(InstStatsd::RequestStat)
         allow(request_stat).to receive(:stats).and_return(total: 72.1382928)
         allow(request_stat).to receive(:exclusive_stats).and_return(nil)
         results = @logger.build_log_message(request_stat)
@@ -64,28 +60,25 @@ describe InstStatsd::RequestLogger do
         expect(results).to eq("[STATSD] (total: 72.13)")
       end
     end
-
   end
 
-  describe '#log' do
-    it 'sends info method to logger if logger exists' do
-      std_out_logger = Logger.new(STDOUT)
+  describe "#log" do
+    it "sends info method to logger if logger exists" do
+      std_out_logger = Logger.new($stdout)
       logger = InstStatsd::RequestLogger.new(std_out_logger)
       expect(std_out_logger).to receive(:info)
-      request_stat = double('request_stat')
-      allow(request_stat).to receive(:stats).and_return({})
-      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
+      request_stat = instance_double(InstStatsd::RequestStat)
+      allow(request_stat).to receive_messages(stats: {}, exclusive_stats: nil)
       logger.log(request_stat)
     end
-    it 'sends info method with build_log_message output if logger exists' do
-      std_out_logger = Logger.new(STDOUT)
+
+    it "sends info method with build_log_message output if logger exists" do
+      std_out_logger = Logger.new($stdout)
       logger = InstStatsd::RequestLogger.new(std_out_logger)
       expect(std_out_logger).to receive(:info).with("[DEFAULT_METRICS] (total: 100.20)")
-      request_stat = double('request_stat')
-      allow(request_stat).to receive(:stats).and_return(total: 100.2)
-      allow(request_stat).to receive(:exclusive_stats).and_return(nil)
+      request_stat = instance_double(InstStatsd::RequestStat)
+      allow(request_stat).to receive_messages(stats: { total: 100.2 }, exclusive_stats: nil)
       logger.log(request_stat, "DEFAULT_METRICS")
     end
   end
-
 end