inst_statsd 2.2.0 → 3.0.4

data/lib/inst_statsd/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module InstStatsd
+  VERSION = "3.0.4"
+end

data/lib/inst_statsd.rb

@@ -1,23 +1,32 @@
 # frozen_string_literal: true
 
-require 'statsd'
+require "statsd"
 
 module InstStatsd
-  VALID_SETTINGS = %i[host port namespace append_hostname mask negative_mask batch_size batch_byte_size
-                      dog_tags].freeze
+  VALID_SETTINGS = %i[host
+                      port
+                      namespace
+                      append_hostname
+                      mask
+                      negative_mask
+                      batch_size
+                      batch_byte_size
+                      dog_tags
+                      socket_path].freeze
 
   class ConfigurationError < StandardError; end
 
-  require 'inst_statsd/statsd'
-  require 'inst_statsd/block_stat'
-  require 'inst_statsd/block_tracking'
-  require 'inst_statsd/request_stat'
-  require 'inst_statsd/counter'
-  require 'inst_statsd/sql_tracker'
-  require 'inst_statsd/default_tracking'
-  require 'inst_statsd/request_logger'
-  require 'inst_statsd/request_tracking'
-  require 'inst_statsd/null_logger'
+  require "inst_statsd/event"
+  require "inst_statsd/statsd"
+  require "inst_statsd/block_stat"
+  require "inst_statsd/block_tracking"
+  require "inst_statsd/request_stat"
+  require "inst_statsd/counter"
+  require "inst_statsd/sql_tracker"
+  require "inst_statsd/default_tracking"
+  require "inst_statsd/request_logger"
+  require "inst_statsd/request_tracking"
+  require "inst_statsd/null_logger"
 
   class << self
     def settings
@@ -32,11 +41,11 @@ module InstStatsd
       return nil if value.nil?
 
       validated = {}
+      regexp_methods = %i[mask negative_mask]
       value.each do |k, v|
-        unless VALID_SETTINGS.include?(k.to_sym)
-          raise InstStatsd::ConfigurationError, "Invalid key: #{k}"
-        end
-        v = Regexp.new(v) if %i[mask negative_mask].include?(k.to_sym) && v.is_a?(String)
+        raise InstStatsd::ConfigurationError, "Invalid key: #{k}" unless VALID_SETTINGS.include?(k.to_sym)
+
+        v = Regexp.new(v) if regexp_methods.include?(k.to_sym) && v.is_a?(String)
         validated[k.to_sym] = v
       end
 
@@ -44,19 +53,17 @@ module InstStatsd
     end
 
     def env_settings(env = ENV)
-      dog_tags = JSON.parse(env['INST_DOG_TAGS']).to_h if env['INST_DOG_TAGS']
+      dog_tags = JSON.parse(env["INST_DOG_TAGS"]).to_h if env["INST_DOG_TAGS"]
       config = {
-        host: env.fetch('INST_STATSD_HOST', nil),
-        port: env.fetch('INST_STATSD_PORT', nil),
-        namespace: env.fetch('INST_STATSD_NAMESPACE', nil),
-        append_hostname: env.fetch('INST_STATSD_APPEND_HOSTNAME', nil),
+        host: env.fetch("INST_STATSD_HOST", nil),
+        port: env.fetch("INST_STATSD_PORT", nil),
+        namespace: env.fetch("INST_STATSD_NAMESPACE", nil),
+        append_hostname: env.fetch("INST_STATSD_APPEND_HOSTNAME", nil),
         dog_tags: dog_tags
       }
-      config.delete_if { |_k, v| v.nil? }
+      config.compact!
       convert_bool(config, :append_hostname)
-      if config[:host]
-        config
-      elsif config[:dog_tags]
+      if config[:host] || config[:dog_tags]
         config
       else
         {}
@@ -66,11 +73,12 @@ module InstStatsd
     def convert_bool(hash, key)
       value = hash[key]
       return if value.nil?
-      unless ['true', 'True', 'false', 'False', true, false].include?(value)
+
+      unless ["true", "True", "false", "False", true, false].include?(value)
         message = "#{key} must be a boolean, or the string representation of a boolean, got: #{value}"
         raise InstStatsd::ConfigurationError, message
       end
-      hash[key] = ['true', 'True', true].include?(value)
+      hash[key] = ["true", "True", true].include?(value)
     end
   end
 end

data/spec/inst_statsd/block_stat_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe InstStatsd::BlockStat do
   it "track exclusives correctly" do
     stat = InstStatsd::BlockStat.new("key")
-    stat.stats['total'] = 5.0
+    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)

data/spec/inst_statsd/block_tracking_spec.rb

@@ -1,62 +1,82 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe InstStatsd::BlockTracking do
-  before(:all) do
+  before(:all) do # rubocop:disable RSpec/BeforeAfterAll
     InstStatsd::DefaultTracking.track_sql
   end
 
   it "works" do
-    statsd = double()
-    allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}})
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {}})
+    statsd = double
+    allow(statsd).to receive(:timing).with("mykey.total", anything, { short_stat: "mykey.total", tags: {} })
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 1, { short_stat: "mykey.sql.read", tags: {} })
 
-    InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read') do
-      ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+    InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: "sql.read") do
+      ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
     end
   end
 
   it "works for data_dog" do
-    statsd = double()
+    statsd = double
     allow(statsd).to receive(:data_dog?).and_return true
-    allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {app: "canvas", env: "prod"}})
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {app: "canvas", env: "prod"}})
+    allow(statsd).to receive(:timing).with("mykey.total",
+                                           anything,
+                                           { short_stat: "mykey.total", tags: { app: "canvas", env: "prod" } })
+    expect(statsd).to receive(:timing).with("mykey.sql.read",
+                                            1,
+                                            { short_stat: "mykey.sql.read", tags: { app: "canvas", env: "prod" } })
 
-    InstStatsd::BlockTracking.track("mykey", statsd: statsd, only: 'sql.read', tags: {app: 'canvas', env: 'prod'}, short_stat: 'mykey') do
-      ActiveSupport::Notifications.instrument('sql.active_record', name: "LOAD", sql: "SELECT * FROM users") {}
+    InstStatsd::BlockTracking.track("mykey",
+                                    statsd: statsd,
+                                    only: "sql.read",
+                                    tags: { app: "canvas", env: "prod" },
+                                    short_stat: "mykey") do
+      ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
     end
   end
 
   it "keeps track of exclusive stats too" do
-    statsd = double()
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 2, {short_stat: "mykey.sql.read", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2, {short_stat: "mykey.exclusive.sql.read", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything, {short_stat: "mykey.exclusive.total", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 2, {short_stat: "mykey.sql.read", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 2, {short_stat: "mykey.exclusive.sql.read", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything, {short_stat: "mykey.exclusive.total", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with("mykey.sql.read", 5, {short_stat: "mykey.sql.read", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read", 1, {short_stat: "mykey.exclusive.sql.read", tags: {}}).ordered
-    expect(statsd).to receive(:timing).with('mykey.exclusive.total', anything, {short_stat: "mykey.exclusive.total", tags: {}}).ordered
+    statsd = double
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 2, { short_stat: "mykey.sql.read", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.total", anything, { short_stat: "mykey.total", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read",
+                                            2,
+                                            { short_stat: "mykey.exclusive.sql.read", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.total",
+                                            anything,
+                                            { short_stat: "mykey.exclusive.total", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 2, { short_stat: "mykey.sql.read", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.total", anything, { short_stat: "mykey.total", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read",
+                                            2,
+                                            { short_stat: "mykey.exclusive.sql.read", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.total",
+                                            anything,
+                                            { short_stat: "mykey.exclusive.total", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.sql.read", 5, { short_stat: "mykey.sql.read", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.total", anything, { short_stat: "mykey.total", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.sql.read",
+                                            1,
+                                            { short_stat: "mykey.exclusive.sql.read", tags: {} }).ordered
+    expect(statsd).to receive(:timing).with("mykey.exclusive.total",
+                                            anything,
+                                            { short_stat: "mykey.exclusive.total", tags: {} }).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") {}
+    InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: "sql.read") do
+      ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
+      InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: "sql.read") do
+        ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
+        ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
       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") {}
+      InstStatsd::BlockTracking.track("mykey", category: :nested, statsd: statsd, only: "sql.read") do
+        ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
+        ActiveSupport::Notifications.instrument("sql.active_record", name: "LOAD", sql: "SELECT * FROM users") { nil }
       end
     end
   end
 
-  context "mask" do
+  context "with a mask" do
     after do
       InstStatsd::BlockTracking.mask = nil
       InstStatsd::BlockTracking.negative_mask = nil
@@ -64,26 +84,26 @@ describe InstStatsd::BlockTracking do
 
     it "only tracks keys that match the mask" do
       InstStatsd::BlockTracking.mask = /mykey/
-      statsd = double()
-      allow(statsd).to receive(:timing).with('mykey.total', anything, {short_stat: "mykey.total", tags: {}})
-      expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {}})
+      statsd = double
+      allow(statsd).to receive(:timing).with("mykey.total", anything, { short_stat: "mykey.total", tags: {} })
+      expect(statsd).to receive(:timing).with("mykey.sql.read", 1, { short_stat: "mykey.sql.read", tags: {} })
 
-      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") {}
+      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") { nil }
         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, {short_stat: "mykey.total", tags: {}})
-      expect(statsd).to receive(:timing).with("mykey.sql.read", 1, {short_stat: "mykey.sql.read", tags: {}})
+      statsd = double
+      allow(statsd).to receive(:timing).with("mykey.total", anything, { short_stat: "mykey.total", tags: {} })
+      expect(statsd).to receive(:timing).with("mykey.sql.read", 1, { short_stat: "mykey.sql.read", tags: {} })
 
-      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") {}
+      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") { nil }
         end
       end
     end

data/spec/inst_statsd/counter_spec.rb

@@ -1,60 +1,58 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe InstStatsd::Counter do
-
-  let(:subject) { InstStatsd::Counter.new('test', ['foo']) }
+  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
+    it "should return true for names not in blocked_names" do
+      expect(subject.accepted_name?("bar")).to be true
     end
 
-    it 'should return false for names in blocked_names' do
-      expect(subject.accepted_name?('foo')).to eq false
+    it "should return false for names in blocked_names" do
+      expect(subject.accepted_name?("foo")).to be false
     end
 
-    it 'should return true for empty string names' do
-      expect(subject.accepted_name?('')).to eq true
+    it "should return true for empty string names" do
+      expect(subject.accepted_name?("")).to be true
     end
 
-    it 'should return true for empty nil names' do
-      expect(subject.accepted_name?(nil)).to eq true
+    it "should return true for empty nil names" do
+      expect(subject.accepted_name?(nil)).to be true
     end
   end
 
   describe "#track" do
-    it 'should increment when given allowed names' do
+    it "should increment when given allowed names" do
       cookie = subject.start
-      subject.track('bar')
-      subject.track('baz')
+      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
+    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')
+      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
+    it "should return the current count" do
       cookie = subject.start
-      subject.track('bar')
+      subject.track("bar")
       expect(subject.finalize_count(cookie)).to eq 1
     end
 
-    it 'should not interfere with multiple people using the object' do
+    it "should not interfere with multiple people using the object" do
       cookie1 = subject.start
-      subject.track('bar')
+      subject.track("bar")
       cookie2 = subject.start
-      subject.track('bar')
+      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/event_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "datadog/statsd"
+
+RSpec.describe InstStatsd::Event do
+  include described_class
+
+  let(:title) { "Title" }
+  let(:text) { "Some text." }
+
+  let(:instance) { instance_double(Datadog::Statsd) }
+  let(:data_dog?) { true }
+  let(:dog_tags) { {} }
+  let(:opts) { {} }
+
+  describe "#event" do
+    subject { event(title, text, **opts) }
+
+    context "with title and text only" do
+      let(:opts) { {} }
+
+      it 'invokes "event" on the instance with title and text' do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          tags: {}
+        )
+
+        subject
+      end
+    end
+
+    context "with alert_type set" do
+      let(:opts) { { alert_type: :error } }
+
+      it 'invokes "event" on the instance with expected arguments' do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          alert_type: :error,
+          tags: {}
+        )
+
+        subject
+      end
+    end
+
+    context "with priority set" do
+      let(:opts) { { priority: :low } }
+
+      it 'invokes "event" on the instance with expected arguments' do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          priority: :low,
+          tags: {}
+        )
+
+        subject
+      end
+    end
+
+    context "with date_happened set" do
+      let(:opts) { { date_happened: date_happened } }
+      let(:date_happened) { Time.now.to_i }
+
+      it 'invokes "event" on the instance with expected arguments' do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          date_happened: date_happened,
+          tags: {}
+        )
+
+        subject
+      end
+    end
+
+    context "with an invalid type set" do
+      let(:opts) { { type: :banana } }
+
+      it "does not sent the invalid aggregation key" do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          tags: {}
+        )
+
+        subject
+      end
+    end
+
+    context "with a valid type set" do
+      let(:opts) { { type: :deploy } }
+
+      it "sets the valid aggregation key" do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          tags: { type: :deploy }
+        )
+
+        subject
+      end
+    end
+
+    context "with custom tags" do
+      let(:opts) { { tags: { project: "cool-project" } } }
+
+      it 'invokes "event" on the instance with expected arguments' do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          tags: { project: "cool-project" }
+        )
+
+        subject
+      end
+    end
+
+    context "with all opts set" do
+      let(:date_happened) { Time.now.to_i }
+      let(:opts) do
+        {
+          type: :deploy,
+          alert_type: :warning,
+          priority: :low,
+          date_happened: date_happened,
+          tags: { foo: "bar" }
+        }
+      end
+
+      it "sets all arguments" do
+        expect(instance).to receive(:event).with(
+          title,
+          text,
+          alert_type: :warning,
+          priority: :low,
+          date_happened: date_happened,
+          tags: { foo: "bar", type: :deploy }
+        )
+
+        subject
+      end
+    end
+
+    context "when the instance is not DataDog" do
+      let(:data_dog?) { false }
+
+      it { is_expected.to be_nil }
+
+      it 'does not invoke "event" on the instance' do
+        expect(instance).not_to receive(:event)
+
+        subject
+      end
+    end
+  end
+end