inst_statsd 2.2.0 → 3.0.4

data/spec/inst_statsd/request_stat_spec.rb

@@ -1,183 +1,197 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-
-def create_subject(payload={}, statsd=nil)
-  args = ['name', 1000, 1001, 1234, payload]
+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})
+  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
+    it "should return nil when payload db_runtime key doesnt exists" do
       rs = create_subject
-      expect(rs.db_runtime).to eq nil
+      expect(rs.db_runtime).to be_nil
     end
   end
 
-  describe '#view_runtime' do
-    it 'should return the payload view_runtime' do
+  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
+    it "should return nil when payload view_runtime key doesnt exists" do
       rs = create_subject
-      expect(rs.view_runtime).to eq nil
+      expect(rs.view_runtime).to be_nil
     end
   end
 
-  describe '#controller' do
+  describe "#controller" do
     it "should return params['controller']" do
-      rs = create_subject({params: {'controller' => 'foo'}})
-      expect(rs.controller).to eq 'foo'
+      rs = create_subject({ params: { "controller" => "foo" } })
+      expect(rs.controller).to eq "foo"
     end
 
-    it 'should return nil if no params are available' do
+    it "should return nil if no params are available" do
       rs = create_subject
-      expect(rs.controller).to eq nil
+      expect(rs.controller).to be_nil
     end
 
-    it 'should return nil if no controller is available on params' do
-      rs = create_subject({params: {}})
-      expect(rs.controller).to eq nil
+    it "should return nil if no controller is available on params" do
+      rs = create_subject({ params: {} })
+      expect(rs.controller).to be_nil
     end
   end
 
-  describe '#action' do
+  describe "#action" do
     it "should return params['action']" do
-      rs = create_subject({params: {'action' => 'index'}})
-      expect(rs.action).to eq 'index'
+      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 be_nil
     end
 
-    it 'should return nil if no params are available' do
+    it "should return nil if no action is available on params" do
+      rs = create_subject({ params: {} })
+      expect(rs.action).to be_nil
+    end
+  end
+
+  describe "#status" do
+    it "should return nil if status is not defined" do
       rs = create_subject
-      expect(rs.action).to eq nil
+      expect(rs.status).to be_nil
     end
 
-    it 'should return nil if no action is available on params' do
-      rs = create_subject({params: {}})
-      expect(rs.action).to eq nil
+    it "should return HTTP status group if present" do
+      expect(create_subject({ status: 200 }).status).to eq "2XX"
+      expect(create_subject({ status: 201 }).status).to eq "2XX"
+      expect(create_subject({ status: 302 }).status).to eq "3XX"
+      expect(create_subject({ status: 400 }).status).to eq "4XX"
+      expect(create_subject({ status: 404 }).status).to eq "4XX"
+      expect(create_subject({ status: 503 }).status).to eq "5XX"
     end
   end
 
-  describe '#total' do
-    it 'correctly calculates milliseconds from start, finish' do
-      rs = create_subject({params: {}})
+  describe "#total" 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
     end
 
-    it 'defaults to zero if either start or finish are nil' do
-      rs = InstStatsd::RequestStat.new('name', nil, 1001, 1111, {params: {}})
+    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: {}})
+      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
+  describe "#report" do
+    it "doesnt send stats when no controller or action" do
       statsd = InstStatsd::Statsd
-      rs = create_subject({params: {}}, statsd)
-      expect(statsd).to_not receive(:timing).with('request.foo.index', 1000, {short_stat: nil, tags: {}})
+      rs = create_subject({ params: {} }, statsd)
+      expect(statsd).not_to 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
+    it "sends total timing when controller && action are present, doesnt send db, or view if they are not" do
       statsd = InstStatsd::Statsd
       payload = {
         params: {
-          'controller' => 'foo',
-          'action'     => 'index'
+          "controller" => "foo",
+          "action" => "index"
         }
       }
       rs = create_subject(payload, statsd)
-      expect(statsd).to receive(:timing).with('request.foo.index.total', 1000, {short_stat: ".total", tags: {}})
+      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
+    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'
-        }
+          "controller" => "foo",
+          "action" => "index"
+        },
+        status: 200
       }
       rs = create_subject(payload, statsd)
-      expect(statsd).to receive(:timing).with('request.total', 1000, {short_stat: 'request.total', tags: {action: "index", controller: "foo"}} )
+      expect(statsd).to receive(:timing).with("request.total",
+                                              1000,
+                                              { short_stat: "request.total",
+                                                tags: { action: "index", controller: "foo", status: "2XX" } })
       rs.report
     end
 
-    it 'sends view_runtime and db_runtime when present' do
+    it "sends view_runtime and db_runtime when present" do
       statsd = InstStatsd::Statsd
       payload = {
         view_runtime: 70.1,
         db_runtime: 100.2,
         params: {
-          'controller' => 'foo',
-          'action'     => 'index'
+          "controller" => "foo",
+          "action" => "index"
         }
       }
       rs = create_subject(payload, statsd)
-      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: {}})
+      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 = InstStatsd::Statsd
-      payload = {
-        params: {
-          'controller' => 'foo',
-          'action'     => 'index'
-        }
-      }
-    end
-
-    describe 'sql stats' do
-
-      before :each do
+    describe "sql stats" do
+      before do
         @statsd = InstStatsd::Statsd
         payload = {
           params: {
-            'controller' => 'foo',
-            'action'     => 'index'
+            "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, {short_stat: ".cache.read", tags: {}})
+        @rs.stats["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, {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: {}})
+      it "doesnt send sql stats when they dont exist" do
+        allow(@statsd).to receive(:timing).with("request.foo.index.total", 1000, { short_stat: nil, tags: {} })
+        expect(@statsd).not_to receive(:timing).with("request.foo.index.sql.read",
+                                                     kind_of(Numeric),
+                                                     { short_stat: ".sql.read", tags: {} })
+        expect(@statsd).not_to receive(:timing).with("request.foo.index.sql.write",
+                                                     kind_of(Numeric),
+                                                     { short_stat: ".sql.write", tags: {} })
+        expect(@statsd).not_to 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, {short_stat: ".total", tags: {}})
-        expect(@statsd).to receive(:timing).with('request.foo.index.sql.read', 10, {short_stat: ".sql.read", tags: {}})
+      it "sends sql_read_count when present" do
+        @rs.stats["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
-
   end
-
 end

data/spec/inst_statsd/request_tracking_spec.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe InstStatsd::RequestTracking do
-
-  describe '#enable' do
-    it 'should delegate log messages to the optional logger' do
-      log_double = double()
+  describe "#enable" do
+    it "should delegate log messages to the optional logger" do
+      log_double = instance_double(Logger)
       expect(log_double).to receive(:info)
       InstStatsd::RequestTracking.enable logger: log_double
-      InstStatsd::RequestTracking.start_processing
-      InstStatsd::RequestTracking.finalize_processing('name', 1000, 10001, 1234, {})
+      InstStatsd::RequestTracking.send(:start_processing)
+      InstStatsd::RequestTracking.send(:finalize_processing, "name", 1000, 10_001, 1234, {})
     end
   end
 end

data/spec/inst_statsd/sql_tracker_spec.rb

@@ -1,30 +1,29 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 module InstStatsd
   describe SqlTracker do
-
-    describe '#start' do
-      it 'resets values to zero' do
+    describe "#start" do
+      it "resets values to zero" do
         subject = SqlTracker.new
         subject.start
-        subject.track 'CACHE', 'SELECT * FROM some_table'
+        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
+    describe "#track" do
+      before 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
+        return unless @num_reads.nil?
+
+        @num_reads, @num_writes, @num_caches = @subject.finalize_counts(@cookies)
       end
 
       def num_reads
@@ -42,57 +41,56 @@ module InstStatsd
         @num_caches
       end
 
-      it 'considers CACHE above all' do
-        @subject.track 'CACHE', 'SELECT * FROM some_table'
+      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'
+      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'
+      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'])
+      it "doesnt track names set as blocked" do
+        tracker = SqlTracker.new(blocked_names: ["SCHEMA"])
         cookies = tracker.start
-        tracker.track 'SCHEMA', 'SELECT * FROM some_table'
+        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
+      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()
+      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
+        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()
+      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
+        tracker.track "UPDATE", sql
       end
     end
-
   end
 end