inst_statsd 2.0.4

data/spec/inst_statsd/block_stat_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe InstStatsd::BlockStat do
+  it "track exclusives correctly" do
+    stat = InstStatsd::BlockStat.new("key")
+    stat.stats['total'] = 5.0
+    stat.subtract_exclusives("total" => 1.5)
+    stat.subtract_exclusives("total" => 2.1)
+    expect(stat.exclusive_stats).to eql("total" => 1.4)
+  end
+end

data/spec/inst_statsd/block_tracking_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe InstStatsd::BlockTracking do
+  before(:all) do
+    InstStatsd::DefaultTracking.track_sql
+  end
+
+  it "works" do
+    statsd = double()
+    allow(statsd).to receive(:timing).with('mykey.total', anything)
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 1)
+
+    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 "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
+
+    InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: 'sql.read') do
+      ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+      InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: 'sql.read') do
+        ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+        ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+      end
+      InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: 'sql.read') do
+        ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+        ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+      end
+    end
+  end
+
+  context "mask" do
+    after do
+      InstStatsd::BlockTracking.mask = nil
+      InstStatsd::BlockTracking.negative_mask = nil
+    end
+
+    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)
+
+      InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
+        InstStatsd::BlockTracking.track("ignoreme", statsd: statsd, only: 'sql.read') do
+          ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+        end
+      end
+    end
+
+    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)
+
+      InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
+        InstStatsd::BlockTracking.track("ignoreme", statsd: statsd, only: 'sql.read') do
+          ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+        end
+      end
+    end
+  end
+end

data/spec/inst_statsd/counter_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe InstStatsd::Counter do
+
+  let(:subject) { InstStatsd::Counter.new('test', ['foo']) }
+
+  describe "#accepted_name?" do
+    it 'should return true for names not in blocked_names' do
+      expect(subject.accepted_name?('bar')).to eq true
+    end
+
+    it 'should return false for names in blocked_names' do
+      expect(subject.accepted_name?('foo')).to eq false
+    end
+
+    it 'should return true for empty string names' do
+      expect(subject.accepted_name?('')).to eq true
+    end
+
+    it 'should return true for empty nil names' do
+      expect(subject.accepted_name?(nil)).to eq true
+    end
+  end
+
+  describe "#track" do
+    it 'should increment when given allowed names' do
+      cookie = subject.start
+      subject.track('bar')
+      subject.track('baz')
+      expect(subject.finalize_count(cookie)).to eq 2
+    end
+
+    it 'should not increment when given a blocked name' do
+      cookie = subject.start
+      subject.track('foo') #shouldn't count as foo is a blocked name
+      subject.track('name')
+      expect(subject.finalize_count(cookie)).to eq 1
+    end
+  end
+
+  describe "#finalize_count" do
+    it 'should return the current count' do
+      cookie = subject.start
+      subject.track('bar')
+      expect(subject.finalize_count(cookie)).to eq 1
+    end
+
+    it 'should not interfere with multiple people using the object' do
+      cookie1 = subject.start
+      subject.track('bar')
+      cookie2 = subject.start
+      subject.track('bar')
+      expect(subject.finalize_count(cookie1)).to eq 2
+      expect(subject.finalize_count(cookie2)).to eq 1
+    end
+  end
+
+end

data/spec/inst_statsd/inst_statsd_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe InstStatsd do
+  before(:each) do
+    InstStatsd.settings = nil
+  end
+
+  after(:each) do
+    [
+      'INST_STATSD_HOST',
+      'INST_STATSD_NAMESPACE',
+      'INST_STATSD_PORT',
+      'INST_STATSD_APPEND_HOST_NAME',
+    ].each {|k| ENV.delete k}
+  end
+
+  describe ".settings" do
+    it "have default settings" do
+      expect(InstStatsd.settings).to eq({})
+    end
+
+    it "can be assigned a new value" do
+      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'
+
+      expected = {
+        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'
+
+      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' }
+      expect { InstStatsd.settings = settings }.to raise_error(InstStatsd::ConfigurationError)
+    end
+
+    it 'converts string keys to symbols' do
+      settings = { 'host' => 'bar', 'port' => 1234 }
+      InstStatsd.settings = settings
+      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'}
+      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'}
+      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}
+      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'}
+      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'}
+      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}
+      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'}
+      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)
+    end
+
+  end
+
+  describe ".env_settings" do
+    it 'returns empty hash when no INST_STATSD_HOST found' do
+      env = {
+        'INST_STATSD_NAMESPACE' => 'canvas'
+      }
+      expect(InstStatsd.env_settings(env)).to eq({})
+    end
+
+    it 'builds settings hash from environment vars' do
+      env = {
+        'INST_STATSD_HOST' => 'statsd.example.org',
+        'INST_STATSD_NAMESPACE' => 'canvas',
+      }
+      expected = {
+        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'
+
+      expected = {
+        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',
+      }
+      expected = {
+        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',
+      }
+      expected = {
+        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
+      env = {
+        'INST_STATSD_HOST' => 'statsd.example.org',
+        'INST_STATSD_APPEND_HOSTNAME' => false,
+      }
+      expected = {
+        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
+      env = {
+        'INST_STATSD_HOST' => 'statsd.example.org',
+        'INST_STATSD_APPEND_HOSTNAME' => true,
+      }
+      expected = {
+        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

@@ -0,0 +1,23 @@
+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
+    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
+      logger = InstStatsd::NullLogger.new(log_path)
+      %w[debug info warn error fatal unknown].each { |m| logger.send(m, 'foo') }
+      log_contents = File.read(log_path)
+      expect(log_contents).to eq ''
+    end
+  end
+
+end

data/spec/inst_statsd/request_logger_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'logger'
+
+describe InstStatsd::RequestLogger do
+
+  describe '#build_log_message' do
+    before :all 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')
+      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({})
+      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)
+      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)
+      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)")
+    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)
+        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')
+        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)
+        expect(results).to eq("[STATSD] (total: 72.14)")
+        allow(request_stat).to receive(:stats).and_return(total: 72.1348209)
+        results = @logger.build_log_message(request_stat)
+        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)
+      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)
+      logger.log(request_stat)
+    end
+    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)
+      logger.log(request_stat, "DEFAULT_METRICS")
+    end
+  end
+
+end