logstash-output-elasticsearch 3.0.2-java → 4.1.0-java

data/lib/logstash/outputs/elasticsearch/buffer.rb

@@ -1,124 +0,0 @@
-require 'concurrent'
-java_import java.util.concurrent.locks.ReentrantLock
-
-module LogStash; module Outputs; class ElasticSearch
-  class Buffer
-    def initialize(logger, max_size, flush_interval, &block)
-      @logger = logger
-      # You need to aquire this for anything modifying state generally
-      @operations_mutex = Mutex.new
-      @operations_lock = java.util.concurrent.locks.ReentrantLock.new
-
-      @stopping = Concurrent::AtomicBoolean.new(false)
-      @max_size = max_size
-      @submit_proc = block
-
-      @buffer = []
-
-      @last_flush = Time.now
-      @flush_interval = flush_interval
-      @flush_thread = spawn_interval_flusher
-    end
-
-    def push(item)
-      synchronize do |buffer|
-        push_unsafe(item)
-      end
-    end
-    alias_method :<<, :push
-
-    # Push multiple items onto the buffer in a single operation
-    def push_multi(items)
-      raise ArgumentError, "push multi takes an array!, not an #{items.class}!" unless items.is_a?(Array)
-      synchronize do |buffer|
-        items.each {|item| push_unsafe(item) }
-      end
-    end
-
-    def flush
-      synchronize { flush_unsafe }
-    end
-
-    def stop(do_flush=true,wait_complete=true)
-      return if stopping?
-      @stopping.make_true
-
-      # No need to acquire a lock in this case
-      return if !do_flush && !wait_complete
-
-      synchronize do
-        flush_unsafe if do_flush
-        @flush_thread.join if wait_complete
-      end
-    end
-
-    def contents
-      synchronize {|buffer| buffer}
-    end
-
-    # For externally operating on the buffer contents
-    # this takes a block and will yield the internal buffer and executes
-    # the block in a synchronized block from the internal mutex
-    def synchronize
-      @operations_mutex.synchronize { yield(@buffer) }
-    end
-
-    # These methods are private for various reasons, chief among them threadsafety!
-    # Many require the @operations_mutex to be locked to be safe
-    private
-
-    def push_unsafe(item)
-      @buffer << item
-      if @buffer.size >= @max_size
-        flush_unsafe
-      end
-    end
-
-    def spawn_interval_flusher
-      Thread.new do
-        loop do
-          sleep 0.2
-          break if stopping?
-          synchronize { interval_flush }
-        end
-      end
-    end
-
-    def interval_flush
-      if last_flush_seconds_ago >= @flush_interval
-        begin
-          @logger.debug? && @logger.debug("Flushing buffer at interval",
-                                        :instance => self.inspect,
-                                        :interval => @flush_interval)
-          flush_unsafe
-        rescue StandardError => e
-          @logger.warn("Error flushing buffer at interval!",
-                       :instance => self.inspect,
-                       :message => e.message,
-                       :class => e.class.name,
-                       :backtrace => e.backtrace
-          )
-        rescue Exception => e
-          @logger.warn("Exception flushing buffer at interval!", :error => e.message, :class => e.class.name)
-        end
-      end
-    end
-
-    def flush_unsafe
-      if @buffer.size > 0
-        @submit_proc.call(@buffer)
-        @buffer.clear
-      end
-
-      @last_flush = Time.now # This must always be set to ensure correct timer behavior
-    end
-
-    def last_flush_seconds_ago
-      Time.now - @last_flush
-    end
-
-    def stopping?
-      @stopping.true?
-    end
-  end
-end end end

data/spec/unit/buffer_spec.rb

@@ -1,118 +0,0 @@
-require "logstash/outputs/elasticsearch"
-require "logstash/outputs/elasticsearch/buffer"
-
-describe LogStash::Outputs::ElasticSearch::Buffer do
-  class OperationTarget # Used to track buffer flushesn
-    attr_reader :buffer, :buffer_history, :receive_count
-    def initialize
-      @buffer = nil
-      @buffer_history = []
-      @receive_count = 0
-    end
-
-    def receive(buffer)
-      @receive_count += 1
-      @buffer_history << buffer.clone
-      @buffer = buffer
-    end
-  end
-
-  let(:logger) { Cabin::Channel.get }
-  let(:max_size) { 10 }
-  let(:flush_interval) { 2 }
-  # Used to track flush count
-  let(:operation_target) { OperationTarget.new() }
-  let(:operation) { proc {|buffer| operation_target.receive(buffer) } }
-  subject(:buffer){ LogStash::Outputs::ElasticSearch::Buffer.new(logger, max_size, flush_interval, &operation) }
-
-  after(:each) do
-    buffer.stop(do_flush=false)
-  end
-
-  it "should initialize cleanly" do
-    expect(buffer).to be_a(LogStash::Outputs::ElasticSearch::Buffer)
-  end
-
-  shared_examples("a buffer with two items inside") do
-    it "should add a pushed item to the buffer" do
-      buffer.synchronize do |data|
-        expect(data).to include(item1)
-        expect(data).to include(item2)
-      end
-    end
-
-    describe "interval flushing" do
-      before do
-        sleep flush_interval + 1
-      end
-
-      it "should flush the buffer after the interval has passed" do
-        expect(operation_target.receive_count).to eql(1)
-      end
-
-      it "should clear the buffer after a successful flush" do
-        expect(operation_target.buffer).to eql([])
-      end
-    end
-
-    describe "interval flushing a stopped buffer" do
-      before do
-        buffer.stop(do_flush=false)
-        sleep flush_interval + 1
-      end
-
-      it "should not flush if the buffer is stopped" do
-        expect(operation_target.receive_count).to eql(0)
-      end
-    end
-  end
-
-  describe "with a buffer push" do
-    let(:item1) { "foo" }
-    let(:item2) { "bar" }
-
-    describe "a buffer with two items pushed to it separately" do
-      before do
-        buffer << item1
-        buffer << item2
-      end
-
-      include_examples("a buffer with two items inside")
-    end
-
-    describe "a buffer with two items pushed to it in one operation" do
-      before do
-        buffer.push_multi([item1, item2])
-      end
-
-      include_examples("a buffer with two items inside")
-    end
-  end
-
-  describe "with an empty buffer" do
-    it "should not perform an operation if the buffer is empty" do
-      buffer.flush
-      expect(operation_target.receive_count).to eql(0)
-    end
-  end
-
-  describe "flushing with an operation that raises an error" do
-    class TestError < StandardError; end
-    let(:operation) { proc {|buffer| raise TestError, "A test" } }
-    let(:item) { double("item") }
-
-    before do
-      buffer << item
-    end
-
-    it "should raise an exception" do
-      expect { buffer.flush }.to raise_error(TestError)
-    end
-
-    it "should not clear the buffer" do
-      expect do
-        buffer.flush rescue TestError
-      end.not_to change(buffer, :contents)
-    end
-  end
-end