inst-jobs-statsd 1.0.0

data/spec/inst_jobs_statsd/stats/counters/failed_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe InstJobsStatsd::Stats::Counters::Failed do
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Counters::Failed).to receive(:enable_failed_count)
+      InstJobsStatsd::Stats::Counters::Failed.enable
+    end
+  end
+
+  describe '.report_failed_count' do
+    let(:x) { Struct.new(:perform).new(true) }
+    it do
+      expect(InstStatsd::Statsd).to receive(:count)
+        .with(array_including(/\.failed$/), 1, 1)
+
+      InstJobsStatsd::Stats::Counters::Failed.enable_failed_count
+      x.send_later(:perform)
+      Delayed::Job.first.fail!
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/counters/orphaned_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe InstJobsStatsd::Stats::Counters::Orphaned do
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Counters::Orphaned).to receive(:enable_orphaned_count)
+      InstJobsStatsd::Stats::Counters::Orphaned.enable
+    end
+  end
+
+  describe '.report_orphaned_count' do
+    let(:x) { Struct.new(:perform).new(true) }
+
+    before do
+      Delayed::Worker.lifecycle.reset!
+      InstJobsStatsd::Stats::Counters::Orphaned.enable
+
+      4.times { x.send_later(:perform) }
+      Delayed::Job.order(:id).limit(3)
+                  .update_all(locked_by: 'test', locked_at: Delayed::Job.db_time_now)
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:count)
+        .with(array_including(/\.orphaned$/), 2, 1)
+      Delayed::Worker.lifecycle.run_callbacks(:perform, nil, Delayed::Job.first) {}
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/counters/run_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe InstJobsStatsd::Stats::Counters::Run do
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Counters::Run).to receive(:enable_run_count)
+      InstJobsStatsd::Stats::Counters::Run.enable
+    end
+  end
+
+  describe '.report_run_count' do
+    let(:x) { Struct.new(:perform).new(true) }
+
+    before do
+      Delayed::Worker.lifecycle.reset!
+      InstJobsStatsd::Stats::Counters::Run.enable
+
+      2.times { x.send_later(:perform) }
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:count)
+        .twice.with(array_including(/\.run$/), 1, 1)
+      Delayed::Job.all.each do |job|
+        Delayed::Worker.lifecycle.run_callbacks(:perform, {}, job) {}
+      end
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/periodic/failed_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe InstJobsStatsd::Stats::Periodic::Failed do
+  before do
+    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
+  end
+
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Periodic::Failed).to receive(:enable_failed_depth)
+      InstJobsStatsd::Stats::Periodic::Failed.enable
+    end
+  end
+
+  describe '.report_failed_depth' do
+    let(:x) { Struct.new(:perform).new(true) }
+    let(:now) { Delayed::Job.db_time_now }
+
+    before do
+      InstJobsStatsd::Stats::Periodic.enable_callbacks
+      InstJobsStatsd::Stats::Periodic::Failed.enable_failed_depth
+
+      x.send_later(:perform)
+      Delayed::Job.first.fail!
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .with(array_including(/\.failed_depth$/), 1, 1)
+      InstJobsStatsd::Stats::Periodic::Failed.report_failed_depth
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/periodic/queue_spec.rb

@@ -0,0 +1,95 @@
+RSpec.describe InstJobsStatsd::Stats::Periodic::Queue do
+  before do
+    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
+  end
+
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Periodic::Queue).to receive(:enable_queue_depth)
+      expect(InstJobsStatsd::Stats::Periodic::Queue).to receive(:enable_queue_age)
+      InstJobsStatsd::Stats::Periodic::Queue.enable
+    end
+  end
+
+  describe '.report_queue_depth' do
+    let(:x) { Struct.new(:perform).new(true) }
+    let(:now) { Delayed::Job.db_time_now }
+
+    before do
+      InstJobsStatsd::Stats::Periodic::Queue.enable_queue_depth
+
+      x.send_later(:perform)
+      Delayed::Job.first.update(locked_at: Delayed::Job.db_time_now, locked_by: 'test')
+
+      x.send_later(:perform)
+      x.send_later_enqueue_args(:perform, run_at: now + 1.minute)
+      x.send_later_enqueue_args(:perform, run_at: now + 10.minutes)
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .with(array_including(/\.queue_depth$/), 1, 1)
+      InstJobsStatsd::Stats::Periodic::Queue.report_queue_depth
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .with(array_including(/\.queue_depth$/), 2, 1)
+      Timecop.freeze(2.minutes.from_now) do
+        InstJobsStatsd::Stats::Periodic::Queue.report_queue_depth
+      end
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .with(array_including(/\.queue_depth$/), 3, 1)
+      Timecop.freeze(20.minutes.from_now) do
+        InstJobsStatsd::Stats::Periodic::Queue.report_queue_depth
+      end
+    end
+  end
+
+  describe '.report_queue_age' do
+    let(:x) { Struct.new(:perform).new(true) }
+    let(:now) { Delayed::Job.db_time_now }
+
+    before do
+      InstJobsStatsd::Stats::Periodic::Queue.enable_queue_age
+
+      x.send_later(:perform)
+      Delayed::Job.first.update(locked_at: Delayed::Job.db_time_now, locked_by: 'test')
+
+      x.send_later(:perform)
+      x.send_later_enqueue_args(:perform, run_at: now + 1.minute)
+      x.send_later_enqueue_args(:perform, run_at: now + 10.minutes)
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.queue_age_total$/), number_near(0), 1)
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.queue_age_max$/), number_near(0), 1)
+      InstJobsStatsd::Stats::Periodic::Queue.report_queue_age
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.queue_age_total$/), number_near(180), 1)
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.queue_age_max$/), number_near(120), 1)
+      Timecop.freeze(2.minutes.from_now) do
+        InstJobsStatsd::Stats::Periodic::Queue.report_queue_age
+      end
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.queue_age_total$/), number_near(2940), 1)
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.queue_age_max$/), number_near(1200), 1)
+      Timecop.freeze(20.minutes.from_now) do
+        InstJobsStatsd::Stats::Periodic::Queue.report_queue_age
+      end
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/periodic/run_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe InstJobsStatsd::Stats::Periodic::Run do
+  before do
+    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
+  end
+
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Periodic::Run).to receive(:enable_run_depth)
+      expect(InstJobsStatsd::Stats::Periodic::Run).to receive(:enable_run_age)
+      InstJobsStatsd::Stats::Periodic::Run.enable
+    end
+  end
+
+  describe '.report_run_depth' do
+    let(:x) { Struct.new(:perform).new(true) }
+    let(:now) { Delayed::Job.db_time_now }
+
+    before do
+      InstJobsStatsd::Stats::Periodic::Run.enable_run_depth
+
+      x.send_later(:perform)
+      x.send_later(:perform)
+      Delayed::Job.first.update(locked_at: Delayed::Job.db_time_now, locked_by: 'test')
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .with(array_including(/\.run_depth$/), 1, 1)
+      InstJobsStatsd::Stats::Periodic::Run.report_run_depth
+    end
+  end
+
+  describe '.report_run_age' do
+    let(:x) { Struct.new(:perform).new(true) }
+    let(:now) { Delayed::Job.db_time_now }
+
+    before do
+      InstJobsStatsd::Stats::Periodic::Run.enable_run_age
+
+      x.send_later(:perform)
+      x.send_later(:perform)
+      Delayed::Job.first.update(locked_at: now, locked_by: 'test')
+    end
+
+    it do
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.run_age_total$/), number_near(0), 1)
+      expect(InstStatsd::Statsd).to receive(:gauge)
+        .ordered.with(array_including(/\.run_age_max$/), number_near(0), 1)
+      InstJobsStatsd::Stats::Periodic::Run.report_run_age
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/periodic_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe InstJobsStatsd::Stats::Periodic do
+  before(:each) do
+    Delayed::Worker.lifecycle.reset!
+    InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
+  end
+
+  describe '.enable_callbacks' do
+    it 'only happens once' do
+      expect(InstJobsStatsd::Stats::Periodic::Callbacks).to receive(:new).once.and_call_original
+      2.times { InstJobsStatsd::Stats::Periodic.enable_callbacks }
+    end
+  end
+
+  describe '.add' do
+    it 'does nothing if not enabled' do
+      expect_any_instance_of(InstJobsStatsd::Stats::Periodic::Callbacks).not_to receive(:add)
+      InstJobsStatsd::Stats::Periodic.add(-> {})
+    end
+
+    it 'does something if enabled' do
+      expect_any_instance_of(InstJobsStatsd::Stats::Periodic::Callbacks)
+        .to receive(:add).and_call_original
+      InstJobsStatsd::Stats::Periodic.enable_callbacks
+      InstJobsStatsd::Stats::Periodic.add(-> {})
+    end
+  end
+
+  describe 'Callbacks' do
+    before(:each) do
+      InstJobsStatsd::Stats::Periodic.instance_variable_set(:@instance, nil)
+    end
+
+    it 'calls the procs at the interval' do
+      InstJobsStatsd::Stats::Periodic.enable_callbacks
+
+      @count = 0
+      InstJobsStatsd::Stats::Periodic.add(-> { @count += 1 })
+      InstJobsStatsd::Stats::Periodic.add(-> { @count += 2 })
+
+      Timecop.freeze(Delayed::Job.db_time_now + 60.seconds) do
+        Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, nil, nil) {}
+      end
+
+      expect(@count).to eq 3
+    end
+  end
+
+  describe 'Timer' do
+    before(:each) { @did_block = false }
+
+    it 'does not call the block too soon' do
+      t = InstJobsStatsd::Stats::Periodic::Timer.new(60)
+      expect { t.tick { @did_block = true } }.not_to(change { @did_block })
+    end
+
+    it 'calls the block after the interval elapses' do
+      t = InstJobsStatsd::Stats::Periodic::Timer.new(60)
+      Timecop.freeze(Delayed::Job.db_time_now + 60.seconds) do
+        expect { t.tick { @did_block = true } }.to(change { @did_block })
+      end
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/timing/failed_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe InstJobsStatsd::Stats::Timing::Failed do
+  let(:worker) { build :worker }
+  let(:job) { build :job, run_at: 1.minute.ago }
+
+  before(:each) { Delayed::Worker.lifecycle.reset! }
+
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Timing::Failed).to receive(:enable_failure_timing)
+      InstJobsStatsd::Stats::Timing::Failed.enable
+    end
+  end
+
+  describe '.enable_failure_timing' do
+    it 'reports failure time' do
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .once.with(array_including(/\.failed_after$/), any_args)
+      InstJobsStatsd::Stats::Timing::Failed.enable_failure_timing
+      Delayed::Worker.lifecycle.run_callbacks(
+        :error, worker, job, Exception.new('test')
+      ) { @in_block = true }
+      expect(@in_block).to be_truthy
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/timing/perform_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe InstJobsStatsd::Stats::Timing::Perform do
+  let(:worker) { build :worker }
+  let(:job) { build :job, run_at: 1.minute.ago }
+
+  before(:each) { Delayed::Worker.lifecycle.reset! }
+
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Timing::Perform).to receive(:enable_batching)
+      expect(InstJobsStatsd::Stats::Timing::Perform).to receive(:enable_perform_timing)
+      InstJobsStatsd::Stats::Timing::Perform.enable
+    end
+  end
+
+  describe '.enable_batching' do
+    it 'does batching' do
+      expect(InstStatsd::Statsd).to receive(:batch).and_call_original
+      InstJobsStatsd::Stats::Timing::Perform.enable_batching
+      Delayed::Worker.lifecycle.run_callbacks(:perform, worker, job) { @in_block = true }
+      expect(@in_block).to be_truthy
+    end
+  end
+
+  describe '.enable_perform_timing' do
+    it 'reports queu and perform time' do
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .once.ordered.with(array_including(/\.queue$/), any_args)
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .once.ordered.with(array_including(/\.perform$/), any_args)
+      InstJobsStatsd::Stats::Timing::Perform.enable_perform_timing
+      Delayed::Worker.lifecycle.run_callbacks(:perform, worker, job) { @in_block = true }
+      expect(@in_block).to be_truthy
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/timing/pop_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe InstJobsStatsd::Stats::Timing::Pop do
+  let(:worker) { build :worker }
+  let(:job) { build :job, run_at: 1.minute.ago }
+
+  before(:each) { Delayed::Worker.lifecycle.reset! }
+
+  describe '.enable' do
+    it 'enables all the things' do
+      expect(InstJobsStatsd::Stats::Timing::Pop).to receive(:enable_pop_timing)
+      expect(InstJobsStatsd::Stats::Timing::Pop).to receive(:enable_workqueue_pop_timing)
+      InstJobsStatsd::Stats::Timing::Pop.enable
+    end
+  end
+
+  describe '.enable_pop_timing' do
+    it 'reports pop time' do
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .once.ordered.with(array_including(/\.pop$/), any_args)
+      InstJobsStatsd::Stats::Timing::Pop.enable_pop_timing
+      Delayed::Worker.lifecycle.run_callbacks(:pop, worker) { @in_block = true }
+      expect(@in_block).to be_truthy
+    end
+  end
+
+  describe '.enable_workqueue_pop_timing' do
+    it 'reports pop time' do
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .once.ordered.with(array_including(/\.workqueuepop$/), any_args)
+      InstJobsStatsd::Stats::Timing::Pop.enable_workqueue_pop_timing
+      Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, worker, {}) { @in_block = true }
+      expect(@in_block).to be_truthy
+    end
+  end
+end

data/spec/inst_jobs_statsd/stats/timing_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe InstJobsStatsd::Stats::Timing do
+  let(:job) { build :job, run_at: 1.minute.ago }
+
+  describe 'report_tinming' do
+    context 'with a block' do
+      it 'reports the elapsed time' do
+        expect(InstStatsd::Statsd).to receive(:time)
+        InstJobsStatsd::Stats::Timing.report_timing('test', job: job) { sleep 0.001 }
+      end
+    end
+
+    context 'without a block' do
+      it 'reports the given time' do
+        expect(InstStatsd::Statsd).to receive(:timing)
+        InstJobsStatsd::Stats::Timing.report_timing('test', job: job, timing: 123)
+      end
+    end
+  end
+
+  describe 'report_job_timing_queued' do
+    it 'reports the stat' do
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .with(array_including(/\.queue$/), any_args)
+      InstJobsStatsd::Stats::Timing.report_job_timing_queued(job)
+    end
+  end
+
+  describe 'report_job_timing_failed' do
+    it 'reports the stat' do
+      expect(InstStatsd::Statsd).to receive(:timing)
+        .with(array_including(/\.failed_after$/), any_args)
+      InstJobsStatsd::Stats::Timing.report_job_timing_failed(job)
+    end
+  end
+end

data/spec/inst_statsd/default_tracking_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe InstStatsd::DefaultTracking do
+  it 'includes methods defined in the base gem' do
+    expect(InstStatsd::DefaultTracking.respond_to?(:track_sql)).to be_truthy
+  end
+
+  describe 'track_job_stats' do
+    it 'defines :track_jobs' do
+      expect(InstStatsd::DefaultTracking.respond_to?(:track_jobs)).to be_truthy
+    end
+
+    it 'only does it once' do
+      expect(InstJobsStatsd::JobsTracker).to receive(:new).once.and_call_original
+      2.times { InstStatsd::DefaultTracking.track_jobs }
+    end
+  end
+end

data/spec/matchers.rb

@@ -0,0 +1,3 @@
+RSpec::Matchers.define :number_near do |target, max_delta = 0.5|
+  match { |actual| (actual - target).abs <= max_delta }
+end

data/spec/setup_test_db.rb

@@ -0,0 +1,41 @@
+# All the below is essentially copied from inst-jobs spec_helper.rb,
+# to create the test db, run migrations, etc
+ENV['TEST_ENV_NUMBER'] ||= '1'
+ENV['TEST_DB_HOST'] ||= 'localhost'
+ENV['TEST_DB_DATABASE'] ||= "inst-jobs-test-#{ENV['TEST_ENV_NUMBER']}"
+ENV['TEST_REDIS_CONNECTION'] ||= 'redis://localhost:6379/'
+
+Delayed::Backend::Redis::Job.redis = Redis.new(url: ENV['TEST_REDIS_CONNECTION'])
+Delayed::Backend::Redis::Job.redis.select ENV['TEST_ENV_NUMBER']
+
+connection_config = {
+  adapter: :postgresql,
+  host: ENV['TEST_DB_HOST'].presence,
+  encoding: 'utf8',
+  username: ENV['TEST_DB_USERNAME'],
+  database: ENV['TEST_DB_DATABASE']
+}
+
+if ::Rails.version < '5'
+  class ActiveRecord::Migration
+    class << self
+      def [](_version); self; end
+    end
+  end
+end
+
+# create the test db if it does not exist, to help out wwtd
+ActiveRecord::Base.establish_connection(connection_config.merge(database: 'postgres'))
+begin
+  ActiveRecord::Base.connection.create_database(connection_config[:database])
+rescue ActiveRecord::StatementInvalid
+end
+ActiveRecord::Base.establish_connection(connection_config)
+# TODO reset db and migrate again, to test migrations
+
+# Apply the migrations from the inst-jobs gem
+inst_jobs_spec = Gem::Specification.find_by_name('inst-jobs')
+ActiveRecord::Migrator.migrate(inst_jobs_spec.gem_dir + '/db/migrate')
+ActiveRecord::Migrator.migrate(inst_jobs_spec.gem_dir + '/spec/migrate')
+Delayed::Backend::ActiveRecord::Job.reset_column_information
+Delayed::Backend::ActiveRecord::Job::Failed.reset_column_information

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+if /^2\.4/ =~ RUBY_VERSION && /50\./ =~ ENV['BUNDLE_GEMFILE'] # Limit coverage to one build
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter 'lib/inst_jobs_statsd/version.rb'
+    add_filter 'spec'
+    track_files 'lib/**/*.rb'
+  end
+
+  SimpleCov.minimum_coverage(100)
+end
+
+require 'inst-jobs-statsd'
+require 'delayed/testing'
+
+require 'byebug'
+require 'database_cleaner'
+require 'factory_girl'
+require 'pry'
+require 'timecop'
+
+# No reason to add default sleep time to specs:
+Delayed::Settings.sleep_delay         = 0
+Delayed::Settings.sleep_delay_stagger = 0
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) do |c|
+    c.syntax = %i[should expect]
+  end
+
+  config.include FactoryGirl::Syntax::Methods
+  config.before(:suite) do
+    FactoryGirl.find_definitions
+  end
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do |example|
+    DatabaseCleaner.strategy = (example.metadata[:sinatra] ? :truncation : :transaction)
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  config.order = :random
+  Kernel.srand config.seed
+end
+
+require_relative 'setup_test_db'
+
+Time.zone = 'UTC'
+Rails.logger = Logger.new(nil)
+
+require_relative 'matchers'