inst_statsd 2.0.4

data/spec/inst_statsd/request_stat_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+
+def create_subject(payload={}, statsd=nil)
+  args = ['name', 1000, 1001, 1234, payload]
+  args << statsd if statsd
+  InstStatsd::RequestStat.new(*args)
+end
+
+
+describe InstStatsd::RequestStat do
+
+  describe '#db_runtime' do
+    it 'should return the payload db_runtime' do
+      rs = create_subject({db_runtime: 11.11})
+      expect(rs.db_runtime).to eq 11.11
+    end
+
+    it 'should return nil when payload db_runtime key doesnt exists' do
+      rs = create_subject
+      expect(rs.db_runtime).to eq nil
+    end
+  end
+
+  describe '#view_runtime' do
+    it 'should return the payload view_runtime' do
+      rs = create_subject(view_runtime: 11.11)
+      expect(rs.view_runtime).to eq 11.11
+    end
+
+    it 'should return nil when payload view_runtime key doesnt exists' do
+      rs = create_subject
+      expect(rs.view_runtime).to eq nil
+    end
+  end
+
+  describe '#controller' do
+    it "should return params['controller']" do
+      rs = create_subject({params: {'controller' => 'foo'}})
+      expect(rs.controller).to eq 'foo'
+    end
+
+    it 'should return nil if no params are available' do
+      rs = create_subject
+      expect(rs.controller).to eq nil
+    end
+
+    it 'should return nil if no controller is available on params' do
+      rs = create_subject({params: {}})
+      expect(rs.controller).to eq nil
+    end
+  end
+
+  describe '#action' do
+    it "should return params['action']" do
+      rs = create_subject({params: {'action' => 'index'}})
+      expect(rs.action).to eq 'index'
+    end
+
+    it 'should return nil if no params are available' do
+      rs = create_subject
+      expect(rs.action).to eq nil
+    end
+
+    it 'should return nil if no action is available on params' do
+      rs = create_subject({params: {}})
+      expect(rs.action).to eq nil
+    end
+  end
+
+  describe '#total' do
+    it 'correctly calcuates milliseconds from start, finish' do
+      rs = create_subject({params: {}})
+      # start and finish are in seconds
+      expect(rs.total).to eq 1000
+    end
+
+    it 'defaults to zero if either start or finish are nil' do
+      rs = InstStatsd::RequestStat.new('name', nil, 1001, 1111, {params: {}})
+      expect(rs.total).to eq 0
+      rs = InstStatsd::RequestStat.new('name', 1, nil, 1111, {params: {}})
+      expect(rs.total).to eq 0
+    end
+  end
+
+  describe '#report' do
+    it 'doesnt send stats when no controller or action' do
+      statsd = double
+      rs = create_subject({params: {}}, statsd)
+      expect(statsd).to_not receive(:timing).with('request.foo.index', 1000)
+      rs.report
+    end
+
+    it 'sends total timing when controller && action are present, doesnt send db, or view if they are not' do
+      statsd = double
+      payload = {
+        params: {
+          'controller' => 'foo',
+          'action'     => 'index'
+        }
+      }
+      rs = create_subject(payload, statsd)
+      expect(statsd).to receive(:timing).with('request.foo.index.total', 1000)
+      rs.report
+    end
+
+    it 'sends view_runtime and db_runtime when present' do
+      statsd = double
+      payload = {
+        view_runtime: 70.1,
+        db_runtime: 100.2,
+        params: {
+          'controller' => 'foo',
+          'action'     => 'index'
+        }
+      }
+      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)
+      rs.report
+    end
+
+    it 'sends cache_read_count when present' do
+      statsd = double
+      payload = {
+        params: {
+          'controller' => 'foo',
+          'action'     => 'index'
+        }
+      }
+    end
+
+    describe 'sql stats' do
+
+      before :each do
+        @statsd = double
+        payload = {
+          params: {
+            'controller' => 'foo',
+            'action'     => 'index'
+          }
+        }
+        @rs = create_subject(payload, @statsd)
+        @rs.stats['cache.read'] = 25
+        expect(@statsd).to receive(:timing).with('request.foo.index.cache.read', 25)
+      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))
+        @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)
+        @rs.report
+      end
+    end
+
+  end
+
+end

data/spec/inst_statsd/request_tracking_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe InstStatsd::RequestTracking do
+
+  describe '#enable' do
+    it 'should delegate log messages to the optional logger' do
+      log_double = double()
+      expect(log_double).to receive(:info)
+      InstStatsd::RequestTracking.enable logger: log_double
+      InstStatsd::RequestTracking.start_processing
+      InstStatsd::RequestTracking.finalize_processing('name', 1000, 10001, 1234, {})
+    end
+  end
+end

data/spec/inst_statsd/sql_tracker_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module InstStatsd
+  describe SqlTracker do
+
+    describe '#start' do
+      it 'resets values to zero' do
+        subject = SqlTracker.new
+        subject.start
+        subject.track 'CACHE', 'SELECT * FROM some_table'
+        cookies = subject.start
+        expect(subject.finalize_counts(cookies)).to eq([0, 0, 0])
+      end
+    end
+
+    describe '#track' do
+      before :each do
+        @subject = SqlTracker.new
+        @cookies = @subject.start
+      end
+
+      def finish
+        if @num_reads.nil?
+          @num_reads, @num_writes, @num_caches = @subject.finalize_counts(@cookies)
+        end
+      end
+
+      def num_reads
+        finish
+        @num_reads
+      end
+
+      def num_writes
+        finish
+        @num_writes
+      end
+
+      def num_caches
+        finish
+        @num_caches
+      end
+
+      it 'considers CACHE above all' do
+        @subject.track 'CACHE', 'SELECT * FROM some_table'
+        expect(num_caches).to eq(1)
+        expect(num_reads).to eq(0)
+      end
+
+      it 'marks as read when select is in the first 15 chars of the sql' do
+        @subject.track 'LOAD', '  SELECT "context_external_tools".* FROM'
+        expect(num_reads).to eq(1)
+        expect(num_writes).to eq(0)
+      end
+
+      it 'marks as read with no select, but a LOAD name' do
+        @subject.track 'LOAD', 'WITH RECURSIVE t AS'
+        expect(num_reads).to eq(1)
+        expect(num_writes).to eq(0)
+      end
+
+      it 'doesnt track names set as blocked' do
+        tracker = SqlTracker.new(blocked_names: ['SCHEMA'])
+        cookies = tracker.start
+        tracker.track 'SCHEMA', 'SELECT * FROM some_table'
+        expect(tracker.finalize_counts(cookies)[0]).to eq(0)
+      end
+
+      it 'doesnt track nil names or sql values' do
+        @subject.track nil, 'SELECT *'
+        @subject.track 'CACHE', nil
+        expect(num_reads).to eq(0)
+      end
+
+      it 'passes full sql to counter.track calls for reads' do
+        sql = '  SELECT \'context_external_tools\'.* FROM'
+        read_counter = double()
+        allow(read_counter).to receive(:start)
+        expect(read_counter).to receive(:track).with sql
+        tracker = SqlTracker.new(read_counter: read_counter)
+        tracker.start
+        tracker.track 'LOAD', sql
+      end
+
+      it 'passes full sql to counter.track calls for writes' do
+        sql = '  UPDATE \'context_external_tools\'.* FROM'
+        write_counter = double()
+        allow(write_counter).to receive(:start)
+        expect(write_counter).to receive(:track).with sql
+        tracker = SqlTracker.new(write_counter: write_counter)
+        tracker.start
+        tracker.track 'UPDATE', sql
+      end
+    end
+
+  end
+end

data/spec/inst_statsd/statsd_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe InstStatsd::Statsd do
+  METHODS = %w[increment decrement count gauge timing].freeze
+
+  after do
+    InstStatsd.settings = {}
+    InstStatsd::Statsd.reset_instance
+  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')
+    end
+    expect(statsd).to receive('timing').with('test.name.testhost', anything, anything)
+    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')
+    end
+    expect(statsd).to receive('timing').with('test.name', anything, anything)
+    expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
+  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
+    end
+    expect(InstStatsd::Statsd.time('test.name') { 'test' }).to eq 'test'
+  end
+
+  it 'configures a statsd instance' do
+    expect(InstStatsd::Statsd.instance).to be_nil
+
+    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.port).to eq 1234
+    expect(instance.namespace).to eq 'test'
+  end
+
+  describe '.batch' do
+    it 'is properly reentrant' do
+      InstStatsd.settings = { host: 'localhost', namespace: 'test', port: 1234 }
+      InstStatsd::Statsd.reset_instance
+
+      statsd = InstStatsd::Statsd.instance
+      InstStatsd::Statsd.batch 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(batch1).not_to eq batch2
+        end
+        expect(InstStatsd::Statsd.instance).to eq batch1
+      end
+      expect(InstStatsd::Statsd.instance).to eq statsd
+    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'
+    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'
+    end
+
+    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' }
+      result = InstStatsd::Statsd.escape(hash)
+      expect(result).to eq hash
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'inst_statsd'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.raise_errors_for_deprecations!
+
+  config.order = 'random'
+end

data/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+result=0
+
+echo "################ inst_statsd ################"
+echo "################ Running tests against Rails 3 ################"
+bundle check || bundle install
+bundle exec rspec spec
+let result=$result+$?
+
+if [ $result -eq 0 ]; then
+  echo "SUCCESS"
+else
+  echo "FAILURE"
+fi
+
+exit $result

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: inst_statsd
+version: !ruby/object:Gem::Version
+  version: 2.0.4
+platform: ruby
+authors:
+- Nick Cloward
+- Jason Madsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: statsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: aroi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  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:
+    - - ">="
+      - !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: 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: rspec
+  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'
+description: 
+email:
+- ncloward@instructure.com
+- jmadsen@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/inst_statsd.rb
+- lib/inst_statsd/block_stat.rb
+- lib/inst_statsd/block_tracking.rb
+- lib/inst_statsd/counter.rb
+- lib/inst_statsd/default_tracking.rb
+- lib/inst_statsd/null_logger.rb
+- lib/inst_statsd/request_logger.rb
+- lib/inst_statsd/request_stat.rb
+- lib/inst_statsd/request_tracking.rb
+- lib/inst_statsd/sql_tracker.rb
+- lib/inst_statsd/statsd.rb
+- spec/inst_statsd/block_stat_spec.rb
+- spec/inst_statsd/block_tracking_spec.rb
+- spec/inst_statsd/counter_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.sh
+homepage: https://github.com/instructure/inst_statsd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+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/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