Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 4 additions & 1 deletion lib/fluent/plugin/output.rb
Original file line number Diff line number Diff line change
Expand Up @@ -253,7 +253,10 @@ def acts_as_secondary(primary)

singleton_class.module_eval do
define_method(:commit_write){ |chunk_id| @primary_instance.commit_write(chunk_id, delayed: delayed_commit, secondary: true) }
define_method(:rollback_write){ |chunk_id, update_retry: true| @primary_instance.rollback_write(chunk_id, update_retry) }
# A secondary runs while the primary is already retrying, and only the retry limit
# ends that phase if the secondary never succeeds. So a rollback from the secondary
# always updates the retry state, even when the plugin passes update_retry: false.
define_method(:rollback_write){ |chunk_id, update_retry: true| @primary_instance.rollback_write(chunk_id, update_retry: true) }
end
end

Expand Down
66 changes: 66 additions & 0 deletions test/plugin/test_out_forward.rb
Original file line number Diff line number Diff line change
Expand Up @@ -1594,4 +1594,70 @@ def selected_node
assert_equal @standby, selected_node
end
end

sub_test_case 'as secondary with a destination that never acks' do
setup do
@silent_server = TCPServer.new(TARGET_HOST, 0)
@silent_port = @silent_server.addr[1]
@silent_connections = 0
@silent_thread = Thread.new do
loop do
sock = @silent_server.accept
@silent_connections += 1
Thread.new(sock) { |s| s.read rescue nil }
end
rescue IOError, Errno::EBADF
end
end

teardown do
@silent_server.close rescue nil
@silent_thread.join(1)
end

data('retry_max_times' => {'retry_type' => 'exponential_backoff', 'retry_max_times' => '2'},
'retry_timeout' => {'retry_type' => 'periodic', 'retry_timeout' => '4s'})
test 'the retry limit ends the retry after ack timeouts of the secondary' do |retry_conf|
@d = d = create_driver(%[
heartbeat_type none
require_ack_response true
ack_response_timeout 1s
<server>
host #{TARGET_HOST}
port #{unused_port(protocol: :tcp)}
</server>
<buffer>
@type memory
flush_mode immediate
flush_at_shutdown false
retry_wait 1s
retry_randomize false
retry_secondary_threshold 0.25
#{retry_conf.map { |k, v| "#{k} #{v}" }.join("\n")}
</buffer>
<secondary>
@type forward
heartbeat_type none
require_ack_response true
ack_response_timeout 1s
<server>
host #{TARGET_HOST}
port #{@silent_port}
</server>
</secondary>
])
buffer = d.instance.buffer
limit_reached = lambda do
@silent_connections > 0 &&
d.instance.retry.nil? &&
buffer.stage.empty? && buffer.queue.empty? && buffer.dequeued.empty?
end
d.run(default_tag: 'test', timeout: 20, wait_flush_completion: false, shutdown: false, flush: false, force_flush_retry: true) do
d.feed(event_time, {"a" => 1})
waiting(15) { sleep 0.1 until limit_reached.call }
end

assert_true limit_reached.call
end
end
end
21 changes: 21 additions & 0 deletions test/plugin/test_output_as_buffered_secondary.rb
Original file line number Diff line number Diff line change
Expand Up @@ -455,6 +455,27 @@ def dummy_event_stream
assert{ logs.any?{|l| l.include?("[warn]: retry succeeded by secondary.") } }
end

data('update_retry false' => {update_retry: false},
'default update_retry' => {})
test 'secondary plugin can rollback a chunk through the primary and update the retry state' do |kwargs|
priconf = config_element('buffer','tag',{'flush_thread_count' => 0, 'queued_chunks_limit_size' => 1})
secconf = config_element('secondary','',{'@type' => 'output_secondary_test2'})
@i.configure(config_element('ROOT','',{},[priconf,secconf]))
@i.register(:prefer_buffered_processing){ true }
@i.start
@i.after_start

@i.emit_events("test.tag.1", dummy_event_stream())
@i.buffer.enqueue_all
chunk = @i.buffer.dequeue_chunk

mock.proxy(@i).update_retry_state(chunk.unique_id, false).once
assert_true @i.secondary.rollback_write(chunk.unique_id, **kwargs)

assert_nil @i.buffer.dequeued[chunk.unique_id]
assert_equal [chunk.unique_id], @i.buffer.queue.map(&:unique_id)
end

test 'secondary plugin can do delayed commit even if primary does not do it' do
written = []
chunks = []
Expand Down
Loading