deimos-ruby 1.6.1 → 1.8.0.pre.beta1

data/spec/utils/db_poller_spec.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+# @param seconds [Integer]
+# @return [Time]
+def time_value(secs: 0, mins: 0)
+  Time.local(2015, 5, 5, 1, 0, 0) + (secs + (mins * 60))
+end
+
+each_db_config(Deimos::Utils::DbPoller) do
+
+  before(:each) do
+    Deimos::PollInfo.delete_all
+  end
+
+  describe '#start!' do
+
+    before(:each) do
+      producer_class = Class.new(Deimos::Producer) do
+        schema 'MySchema'
+        namespace 'com.my-namespace'
+        topic 'my-topic'
+        key_config field: 'test_id'
+      end
+      stub_const('MyProducer', producer_class)
+
+      producer_class = Class.new(Deimos::Producer) do
+        schema 'MySchemaWithId'
+        namespace 'com.my-namespace'
+        topic 'my-topic'
+        key_config plain: true
+      end
+      stub_const('MyProducerWithID', producer_class)
+    end
+
+    it 'should raise an error if no pollers configured' do
+      Deimos.configure {}
+      expect { described_class.start! }.to raise_error('No pollers configured!')
+    end
+
+    it 'should start pollers as configured' do
+      Deimos.configure do
+        db_poller do
+          producer_class 'MyProducer'
+        end
+        db_poller do
+          producer_class 'MyProducerWithID'
+        end
+      end
+
+      allow(Deimos::Utils::DbPoller).to receive(:new)
+      signal_double = instance_double(Sigurd::SignalHandler, run!: nil)
+      allow(Sigurd::SignalHandler).to receive(:new).and_return(signal_double)
+      described_class.start!
+      expect(Deimos::Utils::DbPoller).to have_received(:new).twice
+      expect(Deimos::Utils::DbPoller).to have_received(:new).
+        with(Deimos.config.db_poller_objects[0])
+      expect(Deimos::Utils::DbPoller).to have_received(:new).
+        with(Deimos.config.db_poller_objects[1])
+    end
+  end
+
+  describe 'pollers' do
+    include_context 'with widgets'
+
+    let(:poller) do
+      poller = described_class.new(config)
+      allow(poller).to receive(:sleep)
+      poller
+    end
+
+    let(:config) { Deimos.config.db_poller_objects.first.dup }
+
+    before(:each) do
+      Widget.delete_all
+      producer_class = Class.new(Deimos::ActiveRecordProducer) do
+        schema 'MySchemaWithId'
+        namespace 'com.my-namespace'
+        topic 'my-topic-with-id'
+        key_config none: true
+        record_class Widget
+
+        # :nodoc:
+        def self.generate_payload(attrs, widget)
+          super.merge(message_id: widget.generated_id)
+        end
+      end
+      stub_const('MyProducer', producer_class)
+
+      Deimos.configure do
+        db_poller do
+          producer_class 'MyProducer'
+          run_every 1.minute
+        end
+      end
+    end
+
+    after(:each) do
+      travel_back
+    end
+
+    it 'should crash if initialized with an invalid producer' do
+      config.producer_class = 'NoProducer'
+      expect { described_class.new(config) }.to raise_error('Class NoProducer not found!')
+    end
+
+    describe '#retrieve_poll_info' do
+
+      it 'should start from beginning when configured' do
+        poller.retrieve_poll_info
+        expect(Deimos::PollInfo.count).to eq(1)
+        info = Deimos::PollInfo.last
+        expect(info.producer).to eq('MyProducer')
+        expect(info.last_sent).to eq(Time.new(0))
+        expect(info.last_sent_id).to eq(0)
+      end
+
+      it 'should start from now when configured' do
+        travel_to time_value
+        config.start_from_beginning = false
+        poller.retrieve_poll_info
+        expect(Deimos::PollInfo.count).to eq(1)
+        info = Deimos::PollInfo.last
+        expect(info.producer).to eq('MyProducer')
+        expect(info.last_sent).to eq(time_value)
+        expect(info.last_sent_id).to eq(0)
+      end
+
+    end
+
+    specify '#start' do
+      i = 0
+      expect(poller).to receive(:process_updates).twice do
+        i += 1
+        poller.stop if i == 2
+      end
+      poller.start
+    end
+
+    specify '#should_run?' do
+      Deimos::PollInfo.create!(producer: 'MyProducer',
+                               last_sent: time_value)
+      poller.retrieve_poll_info
+
+      # run_every is set to 1 minute
+      travel_to time_value(secs: 62)
+      expect(poller.should_run?).to eq(true)
+
+      travel_to time_value(secs: 30)
+      expect(poller.should_run?).to eq(false)
+
+      travel_to time_value(mins: -1) # this shouldn't be possible but meh
+      expect(poller.should_run?).to eq(false)
+
+      # take the 2 seconds of delay_time into account
+      travel_to time_value(secs: 60)
+      expect(poller.should_run?).to eq(false)
+    end
+
+    specify '#process_batch' do
+      travel_to time_value
+      widgets = (1..3).map { Widget.create!(test_id: 'some_id', some_int: 4) }
+      widgets.last.update_attribute(:updated_at, time_value(mins: -30))
+      expect(MyProducer).to receive(:send_events).with(widgets)
+      poller.retrieve_poll_info
+      poller.process_batch(widgets)
+      info = Deimos::PollInfo.last
+      expect(info.last_sent.in_time_zone).to eq(time_value(mins: -30))
+      expect(info.last_sent_id).to eq(widgets.last.id)
+    end
+
+    describe '#process_updates' do
+      before(:each) do
+        Deimos::PollInfo.create!(producer: 'MyProducer',
+                                 last_sent: time_value(mins: -61),
+                                 last_sent_id: 0)
+        poller.retrieve_poll_info
+        travel_to time_value
+        stub_const('Deimos::Utils::DbPoller::BATCH_SIZE', 3)
+      end
+
+      let!(:old_widget) do
+        # old widget, earlier than window
+        Widget.create!(test_id: 'some_id', some_int: 40,
+                       updated_at: time_value(mins: -200))
+      end
+
+      let!(:last_widget) do
+        # new widget, before delay
+        Widget.create!(test_id: 'some_id', some_int: 10,
+                       updated_at: time_value(secs: -1))
+      end
+
+      let!(:widgets) do
+        (1..7).map do |i|
+          Widget.create!(test_id: 'some_id', some_int: i,
+                         updated_at: time_value(mins: -61, secs: 30 + i))
+        end
+      end
+
+      it 'should update the full table' do
+        info = Deimos::PollInfo.last
+        config.full_table = true
+        expect(MyProducer).to receive(:poll_query).at_least(:once).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([old_widget, widgets[0], widgets[1]]).and_wrap_original do |m, *args|
+            m.call(*args)
+            expect(info.reload.last_sent.in_time_zone).to eq(time_value(mins: -61, secs: 32))
+            expect(info.last_sent_id).to eq(widgets[1].id)
+          end
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[2], widgets[3], widgets[4]]).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[5], widgets[6]]).and_call_original
+        poller.process_updates
+
+        # this is the updated_at of widgets[6]
+        expect(info.reload.last_sent.in_time_zone).to eq(time_value(mins: -61, secs: 37))
+        expect(info.last_sent_id).to eq(widgets[6].id)
+
+        last_widget.update_attribute(:updated_at, time_value(mins: -250))
+
+        travel 61.seconds
+        # should reprocess the table
+        expect(poller).to receive(:process_batch).ordered.
+          with([last_widget, old_widget, widgets[0]]).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[1], widgets[2], widgets[3]]).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[4], widgets[5], widgets[6]]).and_call_original
+        poller.process_updates
+
+        expect(info.reload.last_sent.in_time_zone).to eq(time_value(mins: -61, secs: 37))
+        expect(info.last_sent_id).to eq(widgets[6].id)
+      end
+
+      it 'should send events across multiple batches' do
+        allow(MyProducer).to receive(:poll_query).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[0], widgets[1], widgets[2]]).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[3], widgets[4], widgets[5]]).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[6]]).and_call_original
+        poller.process_updates
+
+        expect(MyProducer).to have_received(:poll_query).
+          with(time_from: time_value(mins: -61),
+               time_to: time_value(secs: -2),
+               column_name: :updated_at,
+               min_id: 0)
+
+        travel 61.seconds
+        # process the last widget which came in during the delay
+        expect(poller).to receive(:process_batch).with([last_widget]).
+          and_call_original
+        poller.process_updates
+
+        # widgets[6] updated_at value
+        expect(MyProducer).to have_received(:poll_query).
+          with(time_from: time_value(mins: -61, secs: 37),
+               time_to: time_value(secs: 59), # plus 61 seconds minus 2 seconds for delay
+               column_name: :updated_at,
+               min_id: widgets[6].id)
+
+        travel 61.seconds
+        # nothing else to process
+        expect(poller).not_to receive(:process_batch)
+        poller.process_updates
+        poller.process_updates
+
+        expect(MyProducer).to have_received(:poll_query).twice.
+          with(time_from: time_value(secs: -1),
+               time_to: time_value(secs: 120), # plus 122 seconds minus 2 seconds
+               column_name: :updated_at,
+               min_id: last_widget.id)
+      end
+
+      it 'should recover correctly with errors and save the right ID' do
+        widgets.each do |w|
+          w.update_attribute(:updated_at, time_value(mins: -61, secs: 30))
+        end
+        allow(MyProducer).to receive(:poll_query).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[0], widgets[1], widgets[2]]).and_call_original
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[3], widgets[4], widgets[5]]).and_raise('OH NOES')
+
+        expect { poller.process_updates }.to raise_exception('OH NOES')
+
+        expect(MyProducer).to have_received(:poll_query).
+          with(time_from: time_value(mins: -61),
+               time_to: time_value(secs: -2),
+               column_name: :updated_at,
+               min_id: 0)
+
+        info = Deimos::PollInfo.last
+        expect(info.last_sent.in_time_zone).to eq(time_value(mins: -61, secs: 30))
+        expect(info.last_sent_id).to eq(widgets[2].id)
+
+        travel 61.seconds
+        # process the last widget which came in during the delay
+        expect(poller).to receive(:process_batch).ordered.
+          with([widgets[3], widgets[4], widgets[5]]).and_call_original
+        expect(poller).to receive(:process_batch).with([widgets[6], last_widget]).
+          and_call_original
+        poller.process_updates
+        expect(MyProducer).to have_received(:poll_query).
+          with(time_from: time_value(mins: -61, secs: 30),
+               time_to: time_value(secs: 59),
+               column_name: :updated_at,
+               min_id: widgets[2].id)
+
+        expect(info.reload.last_sent.in_time_zone).to eq(time_value(secs: -1))
+        expect(info.last_sent_id).to eq(last_widget.id)
+      end
+
+    end
+
+  end
+end

data/spec/utils/deadlock_retry_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+RSpec.describe Deimos::Utils::DeadlockRetry do
+  include_context 'with widgets'
+
+  before(:each) do
+    allow(described_class).to receive(:sleep)
+  end
+
+  describe 'deadlock handling' do
+    let(:batch) { [{ key: 1, payload: { test_id: 'abc', some_int: 3 } }] }
+
+    it 'should retry deadlocks 3 times' do
+      # Should receive original attempt + 2 retries
+      expect(Widget).
+        to receive(:create).
+        and_raise(ActiveRecord::Deadlocked.new('Lock wait timeout exceeded')).
+        exactly(3).times
+
+      # After 3 tries, should let it bubble up
+      expect {
+        described_class.wrap do
+          Widget.create(test_id: 'abc')
+        end
+      }.to raise_error(ActiveRecord::Deadlocked)
+    end
+
+    it 'should stop retrying deadlocks after success' do
+      allow(Widget).
+        to receive(:create).
+        with(hash_including(test_id: 'first')).
+        and_call_original
+
+      # Fail on first attempt, succeed on second
+      expect(Widget).
+        to receive(:create).
+        with(hash_including(test_id: 'second')).
+        and_raise(ActiveRecord::Deadlocked.new('Deadlock found when trying to get lock')).
+        once.
+        ordered
+
+      expect(Widget).
+        to receive(:create).
+        with(hash_including(test_id: 'second')).
+        once.
+        ordered.
+        and_call_original
+
+      # Should not raise anything
+      described_class.wrap do
+        Widget.create(test_id: 'first')
+        Widget.create(test_id: 'second')
+      end
+
+      expect(Widget.all).to match_array([
+                                          have_attributes(test_id: 'first'),
+                                          have_attributes(test_id: 'second')
+                                        ])
+    end
+
+    it 'should not retry non-deadlock exceptions' do
+      expect(Widget).
+        to receive(:create).
+        and_raise(ActiveRecord::StatementInvalid.new('Oops!!')).
+        once
+
+      expect {
+        described_class.wrap do
+          Widget.create(test_id: 'abc')
+        end
+      }.to raise_error(ActiveRecord::StatementInvalid, 'Oops!!')
+    end
+  end
+end

data/spec/utils/lag_reporter_spec.rb

@@ -2,8 +2,11 @@
 
 describe Deimos::Utils::LagReporter do
 
+  let(:kafka_client) { instance_double(Kafka::Client) }
+  let(:partition1_tags) { %w(consumer_group:group1 partition:1 topic:my-topic) }
+  let(:partition2_tags) { %w(consumer_group:group1 partition:2 topic:my-topic) }
+
   before(:each) do
-    kafka_client = instance_double(Kafka::Client)
     allow(kafka_client).to receive(:last_offset_for).and_return(100)
     allow(Phobos).to receive(:create_kafka_client).and_return(kafka_client)
     Deimos.configure { |c| c.consumers.report_lag = true }
@@ -20,38 +23,22 @@ describe Deimos::Utils::LagReporter do
       'heartbeat.consumer.kafka',
       group_id: 'group1', topic_partitions: { 'my-topic': [1] }
     )
-
   end
 
   it 'should report lag' do
     expect(Deimos.config.metrics).to receive(:gauge).ordered.twice.
-      with('consumer_lag', 95,
-           tags: %w(
-             consumer_group:group1
-             partition:1
-             topic:my-topic
-           ))
+      with('consumer_lag', 95, tags: partition1_tags)
     expect(Deimos.config.metrics).to receive(:gauge).ordered.once.
-      with('consumer_lag', 80,
-           tags: %w(
-             consumer_group:group1
-             partition:2
-             topic:my-topic
-           ))
+      with('consumer_lag', 80, tags: partition2_tags)
     expect(Deimos.config.metrics).to receive(:gauge).ordered.once.
-      with('consumer_lag', 0,
-           tags: %w(
-             consumer_group:group1
-             partition:2
-             topic:my-topic
-           ))
+      with('consumer_lag', 0, tags: partition2_tags)
     ActiveSupport::Notifications.instrument(
       'seek.consumer.kafka',
       offset: 5, topic: 'my-topic', group_id: 'group1', partition: 1
     )
     ActiveSupport::Notifications.instrument(
       'start_process_message.consumer.kafka',
-      offset_lag: 80, topic: 'my-topic', group_id: 'group1', partition: 2
+      offset: 20, topic: 'my-topic', group_id: 'group1', partition: 2
     )
     ActiveSupport::Notifications.instrument(
       'heartbeat.consumer.kafka',
@@ -59,8 +46,28 @@ describe Deimos::Utils::LagReporter do
     )
     ActiveSupport::Notifications.instrument(
       'start_process_batch.consumer.kafka',
-      offset_lag: 0, topic: 'my-topic', group_id: 'group1', partition: 2
+      last_offset: 100, topic: 'my-topic', group_id: 'group1', partition: 2
+    )
+    ActiveSupport::Notifications.instrument(
+      'heartbeat.consumer.kafka',
+      group_id: 'group1', topic_partitions: { 'my-topic': [1, 2] }
+    )
+  end
+
+  it 'should update lag after heartbeat' do
+    expect(Deimos.config.metrics).to receive(:gauge).ordered.once.
+      with('consumer_lag', 94, tags: partition2_tags)
+    expect(Deimos.config.metrics).to receive(:gauge).ordered.once.
+      with('consumer_lag', 95, tags: partition2_tags)
+    ActiveSupport::Notifications.instrument(
+      'seek.consumer.kafka',
+      offset: 6, topic: 'my-topic', group_id: 'group1', partition: 2
+    )
+    ActiveSupport::Notifications.instrument(
+      'heartbeat.consumer.kafka',
+      group_id: 'group1', topic_partitions: { 'my-topic': [1, 2] }
     )
+    allow(kafka_client).to receive(:last_offset_for).and_return(101)
     ActiveSupport::Notifications.instrument(
       'heartbeat.consumer.kafka',
       group_id: 'group1', topic_partitions: { 'my-topic': [1, 2] }