Class: LogStash::Util::WrappedAckedQueue::ReadClient

Inherits:
Object
  • Object
show all
Defined in:
lib/logstash/util/wrapped_acked_queue.rb

Instance Method Summary collapse

Constructor Details

#initialize(queue, batch_size = 125, wait_for = 250) ⇒ ReadClient

We generally only want one thread at a time able to access pop/take/poll operations from this queue. We also depend on this to be able to block consumers while we snapshot in-flight buffers



99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 99

def initialize(queue, batch_size = 125, wait_for = 250)
  @queue = queue
  @mutex = Mutex.new
  # Note that @inflight_batches as a central mechanism for tracking inflight
  # batches will fail if we have multiple read clients in the pipeline.
  @inflight_batches = {}
  # allow the worker thread to report the execution time of the filter + output
  @inflight_clocks = {}
  @batch_size = batch_size
  @wait_for = wait_for
end

Instance Method Details

#add_filtered_metrics(batch) ⇒ Object 



231
232
233
234
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 231

def add_filtered_metrics(batch)
  @event_metric.increment(:filtered, batch.filtered_size)
  @pipeline_metric.increment(:filtered, batch.filtered_size)
end

#add_output_metrics(batch) ⇒ Object 



236
237
238
239
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 236

def add_output_metrics(batch)
  @event_metric.increment(:out, batch.filtered_size)
  @pipeline_metric.increment(:out, batch.filtered_size)
end

#add_starting_metrics(batch) ⇒ Object 



225
226
227
228
229
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 225

def add_starting_metrics(batch)
  return if @event_metric.nil? || @pipeline_metric.nil?
  @event_metric.increment(:in, batch.starting_size)
  @pipeline_metric.increment(:in, batch.starting_size)
end

#close ⇒ Object 



111
112
113
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 111

def close
  @queue.close
end

#close_batch(batch) ⇒ Object 



195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 195

def close_batch(batch)
  @mutex.lock
  begin
    batch.close
    # there seems to be concurrency issues with metrics, keep it in the mutex
    @inflight_batches.delete(Thread.current)
    stop_clock(batch)
  ensure
    @mutex.unlock
  end
end

#current_inflight_batch ⇒ Object 



154
155
156
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 154

def current_inflight_batch
  @inflight_batches.fetch(Thread.current, [])
end

#define_initial_metrics_values(namespaced_metric) ⇒ Object 



139
140
141
142
143
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 139

def define_initial_metrics_values(namespaced_metric)
  namespaced_metric.report_time(:duration_in_millis, 0)
  namespaced_metric.increment(:filtered, 0)
  namespaced_metric.increment(:out, 0)
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


115
116
117
118
119
120
121
122
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 115

def empty?
  @mutex.lock
  begin
    @queue.is_empty?
  ensure
    @mutex.unlock
  end
end

#inflight_batches ⇒ Object 



145
146
147
148
149
150
151
152
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 145

def inflight_batches
  @mutex.lock
  begin
    yield(@inflight_batches)
  ensure
    @mutex.unlock
  end
end

#new_batch ⇒ ReadBatch

create a new empty batch

Returns:



160
161
162
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 160

def new_batch
  ReadBatch.new(@queue, @batch_size, @wait_for)
end

#read_batch ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 164

def read_batch
  if @queue.closed?
    raise QueueClosedError.new("Attempt to take a batch from a closed AckedQueue")
  end

  batch = new_batch
  @mutex.lock
  begin
    batch.read_next
  ensure
    @mutex.unlock
  end
  start_metrics(batch)
  batch
end

#set_batch_dimensions(batch_size, wait_for) ⇒ Object 



124
125
126
127
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 124

def set_batch_dimensions(batch_size, wait_for)
  @batch_size = batch_size
  @wait_for = wait_for
end

#set_current_thread_inflight_batch(batch) ⇒ Object 



191
192
193
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 191

def set_current_thread_inflight_batch(batch)
  @inflight_batches[Thread.current] = batch
end

#set_events_metric(metric) ⇒ Object 



129
130
131
132
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 129

def set_events_metric(metric)
  @event_metric = metric
  define_initial_metrics_values(@event_metric)
end

#set_pipeline_metric(metric) ⇒ Object 



134
135
136
137
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 134

def set_pipeline_metric(metric)
  @pipeline_metric = metric
  define_initial_metrics_values(@pipeline_metric)
end

#start_clock ⇒ Object 



207
208
209
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 207

def start_clock
  @inflight_clocks[Thread.current] = java.lang.System.current_time_millis
end

#start_metrics(batch) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 180

def start_metrics(batch)
  @mutex.lock
  begin
    # there seems to be concurrency issues with metrics, keep it in the mutex
    set_current_thread_inflight_batch(batch)
    start_clock
  ensure
    @mutex.unlock
  end
end

#stop_clock(batch) ⇒ Object 



211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/logstash/util/wrapped_acked_queue.rb', line 211

def stop_clock(batch)
  unless @inflight_clocks[Thread.current].nil?
    if batch.size > 0
      # only stop (which also records) the metrics if the batch is non-empty.
      # start_clock is now called at empty batch creation and an empty batch could
      # stay empty all the way down to the close_batch call.
      time_taken = java.lang.System.current_time_millis - @inflight_clocks[Thread.current]
      @event_metric.report_time(:duration_in_millis, time_taken)
      @pipeline_metric.report_time(:duration_in_millis, time_taken)
    end
    @inflight_clocks.delete(Thread.current)
  end
end