logstash-output-google_cloud_storage 3.2.0 → 3.2.1

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 3.2.1
+  - Refactoring work to add locks to file rotation and writing.
+    - Fixes [#2](https://github.com/logstash-plugins/logstash-output-google_cloud_storage/issues/2) - Plugin crashes on file rotation.
+    - Fixes [#19](https://github.com/logstash-plugins/logstash-output-google_cloud_storage/issues/19) - Deleted files remain in use by the system eventually filling up disk space.
+
 ## 3.2.0
   - Change uploads to use a job pool for better performance
     - Fixes [#22](https://github.com/logstash-plugins/logstash-output-google_cloud_storage/issues/22) - Refactor Job Queue Architecture

data/lib/logstash/outputs/gcs/log_rotate.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+require 'logstash/outputs/gcs/temp_log_file'
+require 'concurrent'
+
+module LogStash
+  module Outputs
+    module Gcs
+      class LogRotate
+        def initialize(path_factory, max_file_size_bytes, gzip, flush_interval_secs)
+          @path_factory = path_factory
+          @max_file_size_bytes = max_file_size_bytes
+          @gzip = gzip
+          @flush_interval_secs = flush_interval_secs
+
+          @lock = Concurrent::ReentrantReadWriteLock.new
+          @rotate_callback = nil
+
+          rotate_log!
+        end
+
+        # writeln writes a message and carriage-return character to the open
+        # log file, rotating and syncing it if necessary.
+        #
+        # nil messages do not get written, but may cause the log to rotate
+        def writeln(message=nil)
+          @lock.with_write_lock do
+            rotate_log! if should_rotate?
+
+            @temp_file.write(message, "\n") unless message.nil?
+
+            @temp_file.fsync if @temp_file.time_since_sync >= @flush_interval_secs
+          end
+        end
+
+        # rotate_log! closes the current log (if it exists), notifies the
+        # handler, rolls the path over and opens a new log.
+        #
+        # Invariant: the old log will ALWAYS be closed and a new one will
+        # ALWAYS be open at the completion of this function.
+        def rotate_log!
+          @lock.with_write_lock do
+            unless @temp_file.nil?
+              @temp_file.close!
+              @rotate_callback.call(@temp_file.path) unless @rotate_callback.nil?
+            end
+
+            @path_factory.rotate_path!
+
+            path = @path_factory.current_path
+            @temp_file = LogStash::Outputs::Gcs::LogFileFactory.create(path, @gzip)
+          end
+        end
+
+        # on_rotate sets a handler to be called when the log gets rotated.
+        # The handler receives the path to the rotated out log as a string.
+        def on_rotate(&block)
+          @lock.with_write_lock do
+            @rotate_callback = block
+          end
+        end
+
+        private
+
+        def should_rotate?
+          @lock.with_read_lock do
+            path_changed = @path_factory.should_rotate?
+            rotate_on_size = @max_file_size_bytes > 0
+            too_big = @temp_file.size >= @max_file_size_bytes
+
+            path_changed || (rotate_on_size && too_big)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logstash/outputs/gcs/path_factory.rb

@@ -30,13 +30,16 @@ module LogStash
 
         # Rotates the path to the next one in sequence. If the path has a part number
         # and the base path (date/hostname) haven't changed the part number is incremented.
+        # Returns the path that was rotated out
         def rotate_path!
+          last_path = current_path
+
           @path_lock.synchronize {
             @part_number = (next_base == current_base) ? @part_number + 1 : 0
             @current = template_variables
           }
 
-          current_path
+          last_path
         end
 
         # Checks if the file is ready to rotate because the timestamp changed.

data/lib/logstash/outputs/gcs/temp_log_file.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+require 'zlib'
+require 'concurrent'
+require 'time'
+
+module LogStash
+  module Outputs
+    module Gcs
+      # LogFileFactory creates a LogFile according to user specification
+      # optionally gzipping it and creating mutexes around modification
+      # points.
+      class LogFileFactory
+        def self.create(path, gzip, synchronize=true)
+          lf = LogStash::Outputs::Gcs::PlainLogFile.new(path)
+          lf = LogStash::Outputs::Gcs::GzipLogFile.new(lf) if gzip
+          lf = LogStash::Outputs::Gcs::SynchronizedLogFile.new(lf) if synchronize
+
+          lf
+        end
+      end
+
+      # PlainLogFile writes events to a plain text file.
+      class PlainLogFile
+        attr_reader :path, :fd
+
+        def initialize(path)
+          @path = path
+          @fd = ::File.new(path, 'a+')
+          @last_sync = Time.now
+        end
+
+        def write(*contents)
+          contents.each { |c| @fd.write(c) }
+        end
+
+        def fsync
+          @fd.fsync
+          @last_sync = Time.now
+        end
+
+        def close!
+          @fd.fsync
+          @fd.close
+        end
+
+        def size
+          ::File.stat(@path).size
+        end
+
+        def time_since_sync
+          Time.now - @last_sync
+        end
+      end
+
+      # GzipLogFile wraps another log file and writes events through it.
+      class GzipLogFile
+        attr_reader :fd
+
+        def initialize(child)
+          @child = child
+          @fd = Zlib::GzipWriter.new(child.fd)
+        end
+
+        def write(*contents)
+          contents.each { |c| @fd.write(c) }
+        end
+
+        def fsync
+          @fd.flush
+          @child.fsync
+        end
+
+        def close!
+          fsync
+          # The Gzip writer closes the underlying IO after
+          # appending the Gzip footer.
+          @fd.close
+        end
+
+        def method_missing(method_name, *args, &block)
+          @child.send(method_name, *args, &block)
+        end
+      end
+
+      # SynchronizedLogFile wraps another log file and uses reentrant locks
+      # around its methods to prevent concurrent modification.
+      class SynchronizedLogFile
+        def initialize(child)
+          @child = child
+          @lock = Concurrent::ReentrantReadWriteLock.new
+        end
+
+        def time_since_sync
+          @lock.with_read_lock { @child.time_since_sync }
+        end
+
+        def path
+          @lock.with_read_lock { @child.path }
+        end
+
+        def method_missing(method_name, *args, &block)
+          # unless otherwise specified, get a write lock
+          @lock.with_write_lock do
+            @child.send(method_name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logstash/outputs/google_cloud_storage.rb

@@ -21,6 +21,7 @@
 require "logstash/outputs/base"
 require "logstash/outputs/gcs/path_factory"
 require "logstash/outputs/gcs/worker_pool"
+require "logstash/outputs/gcs/log_rotate"
 require "logstash/namespace"
 require "logstash/json"
 require "stud/interval"
@@ -142,107 +143,62 @@ class LogStash::Outputs::GoogleCloudStorage < LogStash::Outputs::Base
 
   public
   def register
-    require "fileutils"
-    @logger.debug("GCS: register plugin")
-    @last_flush_cycle = Time.now
+    @logger.debug('Registering Google Cloud Storage plugin')
 
     @workers = LogStash::Outputs::Gcs::WorkerPool.new(@max_concurrent_uploads, @upload_synchronous)
-    initialize_temp_directory()
+    initialize_temp_directory
     initialize_path_factory
-    open_current_file
+    initialize_log_rotater
 
-    initialize_google_client()
+    initialize_google_client
 
     start_uploader
 
-    if @gzip
-      @content_type = 'application/gzip'
-    else
-      @content_type = 'text/plain'
-    end
+    @content_type = @gzip ? 'application/gzip' : 'text/plain'
   end
 
   # Method called for each log event. It writes the event to the current output
   # file, flushing depending on flush interval configuration.
   public
   def receive(event)
-    @logger.debug("GCS: receive method called", :event => event)
+    @logger.debug('Received event', :event => event)
 
-    if (@output_format == "json")
+    if @output_format == 'json'
       message = LogStash::Json.dump(event.to_hash)
     else
       message = event.to_s
     end
 
-    # Time to roll file based on the date pattern? Or is it over the size limit?
-    initialize_next_log if ready_to_rotate?
-
-    @temp_file.write(message)
-    @temp_file.write("\n")
-
-    sync_log_file()
-
-    @logger.debug("GCS: event appended to log file",
-                  :filename => File.basename(@temp_file.to_path))
+    @log_rotater.writeln(message)
   end
 
   public
   def close
     @logger.debug('Stopping the plugin, uploading the remaining files.')
-
     Stud.stop!(@registration_thread) unless @registration_thread.nil?
 
-    close_and_upload_current
+    # Force rotate the log. If it contains data it will be submitted
+    # to the work pool and will be uploaded before the plugin stops.
+    @log_rotater.rotate_log!
     @workers.stop!
   end
 
   private
 
-
-  def ready_to_rotate?
-    path_changed = @path_factory.should_rotate?
-    too_big = @max_file_size_kbytes > 0 && @temp_file.size >= @max_file_size_kbytes * 1024
-
-    path_changed || too_big
-  end
-
-  ##
-  # Flushes temporary log file every flush_interval_secs seconds or so.
-  # This is triggered by events, but if there are no events there's no point
-  # flushing files anyway.
-  #
-  # Inspired by lib/logstash/outputs/file.rb (flush(fd), flush_pending_files)
-  def sync_log_file
-    if flush_interval_secs <= 0
-      @temp_file.fsync()
-      return
-    end
-
-    return unless Time.now - @last_flush_cycle >= flush_interval_secs
-    @temp_file.fsync()
-    @logger.debug("GCS: flushing file",
-                  :path => @temp_file.to_path,
-                  :fd => @temp_file)
-    @last_flush_cycle = Time.now
-  end
-
   ##
   # Creates temporary directory, if it does not exist.
   #
   # A random suffix is appended to the temporary directory
   def initialize_temp_directory
     require "stud/temporary"
+
     if @temp_directory.empty?
-      @temp_directory = Stud::Temporary.directory("logstash-gcs")
-      @logger.info("GCS: temporary directory generated",
-                   :directory => @temp_directory)
+      @temp_directory = Stud::Temporary.directory('logstash-gcs')
     end
 
-    if !(File.directory? @temp_directory)
-      @logger.debug("GCS: directory doesn't exist. Creating it.",
-                    :directory => @temp_directory)
-      FileUtils.mkdir_p(@temp_directory)
-    end
+    FileUtils.mkdir_p(@temp_directory) unless File.directory?(@temp_directory)
+
+    @logger.info("Using temporary directory: #{@temp_directory}")
   end
 
   def initialize_path_factory
@@ -257,44 +213,16 @@ class LogStash::Outputs::GoogleCloudStorage < LogStash::Outputs::Base
     end
   end
 
+  # start_uploader periodically sends flush events through the log rotater
   def start_uploader
     Thread.new do
       @registration_thread = Thread.current
       Stud.interval(@uploader_interval_secs) do
-        initialize_next_log if ready_to_rotate?
+        @log_rotater.writeln(nil)
       end
     end
   end
 
-  ##
-  # Opens current log file and updates @temp_file with an instance of IOWriter.
-  # This method also adds file to the upload queue.
-  def open_current_file
-    path = @path_factory.current_path
-
-    stat = File.stat(path) rescue nil
-    if stat and stat.ftype == "fifo" and RUBY_PLATFORM == "java"
-      fd = java.io.FileWriter.new(java.io.File.new(path))
-    else
-      fd = File.new(path, "a")
-    end
-    if @gzip
-      fd = Zlib::GzipWriter.new(fd)
-    end
-    @temp_file = GCSIOWriter.new(fd)
-  end
-
-  ##
-  # Generates new log file name based on configuration options and opens log
-  # file. If max file size is enabled, part number if incremented in case the
-  # the base log file name is the same (e.g. log file was not rolled given the
-  # date pattern).
-  def initialize_next_log
-    close_and_upload_current
-    @path_factory.rotate_path!
-    open_current_file()
-  end
-
   ##
   # Initializes Google Client instantiating client and authorizing access.
   def initialize_google_client
@@ -340,19 +268,6 @@ class LogStash::Outputs::GoogleCloudStorage < LogStash::Outputs::Base
     end
   end
 
-  def close_and_upload_current
-    return if @temp_file.nil?
-
-    filename = @temp_file.to_path
-    @temp_file.fsync
-    @temp_file.close
-    @logger.info("Uploading file: #{filename}")
-
-    @workers.post do
-      upload_and_delete(filename)
-    end
-  end
-
   def upload_and_delete(filename)
     file_size = File.stat(filename).size
 
@@ -365,38 +280,16 @@ class LogStash::Outputs::GoogleCloudStorage < LogStash::Outputs::Base
     @logger.debug('Delete local temporary file', :filename => filename)
     File.delete(filename)
   end
-end
 
-##
-# Wrapper class that abstracts which IO being used (for instance, regular
-# files or GzipWriter.
-#
-# Inspired by lib/logstash/outputs/file.rb.
-class GCSIOWriter
-  def initialize(io)
-    @io = io
-  end
-  def write(*args)
-    @io.write(*args)
-  end
-  def fsync
-    if @io.class == Zlib::GzipWriter
-      @io.flush
-      @io.to_io.fsync
-    else
-      @io.fsync
-    end
-  end
-  def method_missing(method_name, *args, &block)
-    if @io.respond_to?(method_name)
-      @io.send(method_name, *args, &block)
-    else
-      if @io.class == Zlib::GzipWriter && @io.to_io.respond_to?(method_name)
-        @io.to_io.send(method_name, *args, &block)
-      else
-        super
+  def initialize_log_rotater
+    max_file_size = @max_file_size_kbytes * 1024
+    @log_rotater = LogStash::Outputs::Gcs::LogRotate.new(@path_factory, max_file_size, @gzip, @flush_interval_secs)
+
+    @log_rotater.on_rotate do |filename|
+      @logger.info("Rotated out file: #{filename}")
+      @workers.post do
+        upload_and_delete(filename)
       end
     end
   end
-  attr_accessor :active
 end

data/logstash-output-google_cloud_storage.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-output-google_cloud_storage'
-  s.version         = '3.2.0'
+  s.version         = '3.2.1'
   s.licenses        = ['Apache-2.0']
   s.summary         = "plugin to upload log events to Google Cloud Storage (GCS)"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"

data/spec/outputs/gcs/log_rotate_spec.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+require 'logstash/outputs/gcs/log_rotate'
+require 'logstash/outputs/gcs/path_factory'
+require 'logstash/outputs/gcs/temp_log_file'
+
+describe LogStash::Outputs::Gcs::LogRotate do
+  let(:tempdir){ Stud::Temporary.directory }
+  let(:path_factory) do
+    LogStash::Outputs::Gcs::PathFactoryBuilder.build do |builder|
+      builder.set_directory tempdir
+      builder.set_prefix 'prefix'
+      builder.set_include_host true
+      builder.set_date_pattern ''
+      builder.set_include_part true
+      builder.set_include_uuid true
+      builder.set_is_gzipped true
+    end
+  end
+  let(:open_file_1) { double('open-temp-1', :size => 5, :path => 'one', :close! => true, :time_since_sync => 10, :fsync => true)}
+  let(:open_file_2) { double('open-temp-2', :size => 5, :path => 'two', :close! => true, :time_since_sync => 60, :fsync => true)}
+
+  describe '#initialize' do
+    it 'opens the first file' do
+      expect(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_1)
+
+      LogStash::Outputs::Gcs::LogRotate.new(path_factory, 10, false, 30)
+    end
+  end
+
+  describe '#writeln' do
+    subject { LogStash::Outputs::Gcs::LogRotate.new(path_factory, 10, false, 30) }
+
+    it 'does not rotate if size is small and path is the same' do
+      expect(path_factory).to receive(:should_rotate?).and_return(false)
+      # once for init
+      expect(path_factory).to receive(:rotate_path!).once
+
+      subject.writeln('foo')
+    end
+
+    it 'rotates the file if the size is too big' do
+      # once for init, once for writeln
+      expect(path_factory).to receive(:rotate_path!).twice
+
+      subject.writeln('this line is longer than ten characters' * 1000)
+      subject.writeln('flush')
+    end
+
+    it 'rotates the file if the path changed' do
+      expect(path_factory).to receive(:should_rotate?).and_return(true)
+      # once for init, once for writeln
+      expect(path_factory).to receive(:rotate_path!).twice
+
+      subject.writeln('foo')
+    end
+
+    it 'writes the message' do
+      expect(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_1)
+      expect(open_file_1).to receive(:write).with('foo', "\n")
+
+      subject.writeln('foo')
+    end
+
+    it 'does not write nil messages' do
+      expect(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_1)
+      expect(open_file_1).not_to receive(:write)
+
+      subject.writeln(nil)
+    end
+
+    it 'does not fsync if delta less than limit' do
+      expect(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_1)
+      expect(open_file_1).not_to receive(:fsync)
+
+      subject.writeln(nil)
+    end
+
+    it 'fsyncs if delta greater than limit' do
+      expect(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_2)
+      expect(open_file_2).to receive(:fsync)
+
+      subject.writeln(nil)
+    end
+  end
+
+  describe '#rotate_log!' do
+    subject { LogStash::Outputs::Gcs::LogRotate.new(path_factory, 10, false, 30) }
+
+    before :each do
+      allow(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_1, open_file_2)
+    end
+
+    it 'closes the old file' do
+      expect(open_file_1).to receive(:close!)
+
+      subject.rotate_log!
+    end
+
+    it 'calls the callback with the old file name' do
+      value = nil
+      subject.on_rotate { |old_path| value = old_path }
+
+      subject.rotate_log!
+      expect(value).to eq(open_file_1.path)
+    end
+
+    it 'opens a new file based on the new path' do
+      expect(LogStash::Outputs::Gcs::LogFileFactory).to receive(:create).and_return(open_file_1, open_file_2)
+      expect(open_file_2).to receive(:write).with('foo', "\n")
+
+      subject.rotate_log!
+      subject.writeln('foo')
+    end
+  end
+
+  describe '#on_rotate' do
+    subject { LogStash::Outputs::Gcs::LogRotate.new(path_factory, 10, false, 30) }
+
+    it 'replaces an existing callback' do
+      value = :none
+
+      subject.on_rotate { value = :first }
+      subject.on_rotate { value = :second }
+
+      subject.rotate_log!
+      expect(value).to eq(:second)
+    end
+  end
+end

data/spec/outputs/gcs/path_factory_spec.rb

@@ -125,7 +125,7 @@ describe LogStash::Outputs::Gcs::PathFactory do
       expect(pf.current_path).to include('part000')
     end
 
-    it 'returns the current_path' do
+    it 'returns the path being rotated out' do
       pf = LogStash::Outputs::Gcs::PathFactoryBuilder.build do |builder|
         builder.set_directory 'dir'
         builder.set_prefix 'pre'
@@ -135,8 +135,9 @@ describe LogStash::Outputs::Gcs::PathFactory do
         builder.set_include_uuid false
         builder.set_is_gzipped false
       end
+      last = pf.current_path
       after = pf.rotate_path!
-      expect(after).to eq(File.join('dir', 'pre_date.part001.log'))
+      expect(after).to eq(last)
     end
   end
 
@@ -151,7 +152,7 @@ describe LogStash::Outputs::Gcs::PathFactory do
         builder.set_include_uuid false
         builder.set_is_gzipped false
       end
-      sleep 0.1
+      sleep 1.0
       expect(pf.should_rotate?).to eq(false)
     end
 
@@ -165,7 +166,7 @@ describe LogStash::Outputs::Gcs::PathFactory do
         builder.set_include_uuid false
         builder.set_is_gzipped false
       end
-      sleep 0.1
+      sleep 1.0
       expect(pf.should_rotate?).to eq(true)
     end
   end

data/spec/outputs/gcs/temp_log_file_spec.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+require 'logstash/outputs/gcs/temp_log_file'
+require 'stud/temporary'
+require 'zlib'
+
+shared_examples 'a log file' do
+  describe '#initialize' do
+    it 'opens a file' do
+      expect{subject.fd}.to_not raise_error
+      expect(subject.fd).to_not be_nil
+    end
+
+    it 'sets the path' do
+      expect{subject.path}.to_not raise_error
+      expect(subject.path).to_not be_nil
+    end
+
+    it 'sets last sync' do
+      expect{subject.time_since_sync}.to_not raise_error
+    end
+  end
+
+  describe '#write' do
+    it 'writes the content' do
+      expect(subject.fd).to receive(:write).with('foo')
+      expect(subject.fd).to receive(:write).with("\n")
+
+      subject.write('foo', "\n")
+    end
+
+    it 'fails if the file is closed' do
+      subject.close!
+
+      expect{ subject.write('foo') }.to raise_error(IOError)
+    end
+  end
+
+  describe '#fsync' do
+    it 'fails if the file is closed' do
+      subject.close!
+
+      expect{ subject.fsync }.to raise_error(IOError)
+    end
+  end
+
+  describe '#close!' do
+    it 'fails if the file is closed' do
+      subject.close!
+
+      expect{ subject.close! }.to raise_error(IOError)
+    end
+  end
+
+  describe '#size' do
+    it 'gets the size of the file on disk' do
+      subject.write('hello, world!')
+      subject.fsync
+
+      expect(subject.size).to eq(File.stat(subject.path).size)
+    end
+
+    it 'does not fail if the file is closed' do
+      subject.close!
+
+      expect{ subject.size }.to_not raise_error
+    end
+  end
+
+  describe '#time_since_sync' do
+    it 'returns a delta' do
+      expect(Time).to receive(:now).and_return(30, 40, 50)
+
+      subject.fsync
+
+      expect(subject.time_since_sync).to eq(10)
+    end
+  end
+end
+
+describe LogStash::Outputs::Gcs::PlainLogFile do
+  let(:tempdir) { Stud::Temporary.directory }
+  let(:path) { ::File.join(tempdir, 'logfile.log') }
+  subject { LogStash::Outputs::Gcs::LogFileFactory.create(path, false, false) }
+
+  it_behaves_like 'a log file'
+
+  it 'creates a valid plain text file' do
+    subject.write('Hello, world!')
+    subject.close!
+    data = File.read(path)
+
+    expect(data).to eq('Hello, world!')
+  end
+end
+
+describe LogStash::Outputs::Gcs::GzipLogFile do
+  let(:tempdir) { Stud::Temporary.directory }
+  let(:path) { ::File.join(tempdir, 'logfile.log') }
+  subject { LogStash::Outputs::Gcs::LogFileFactory.create(path, true, false) }
+
+  it_behaves_like 'a log file'
+
+  it 'creates a valid gzip' do
+    subject.write('Hello, world!')
+    subject.close!
+
+    Zlib::GzipReader.open(path) do |gz|
+      expect(gz.read).to eq('Hello, world!')
+    end
+  end
+end
+
+describe LogStash::Outputs::Gcs::SynchronizedLogFile do
+  let(:tempdir) { Stud::Temporary.directory }
+  let(:path) { ::File.join(tempdir, 'logfile.log') }
+  subject { LogStash::Outputs::Gcs::LogFileFactory.create(path, false, true) }
+
+  it_behaves_like 'a log file'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-google_cloud_storage
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-06-04 00:00:00.000000000 Z
+date: 2018-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -129,11 +129,15 @@ files:
 - NOTICE.TXT
 - README.md
 - docs/index.asciidoc
+- lib/logstash/outputs/gcs/log_rotate.rb
 - lib/logstash/outputs/gcs/path_factory.rb
+- lib/logstash/outputs/gcs/temp_log_file.rb
 - lib/logstash/outputs/gcs/worker_pool.rb
 - lib/logstash/outputs/google_cloud_storage.rb
 - logstash-output-google_cloud_storage.gemspec
+- spec/outputs/gcs/log_rotate_spec.rb
 - spec/outputs/gcs/path_factory_spec.rb
+- spec/outputs/gcs/temp_log_file_spec.rb
 - spec/outputs/gcs/worker_pool_spec.rb
 - spec/outputs/google_cloud_storage_spec.rb
 - spec/spec_helper.rb
@@ -164,7 +168,9 @@ signing_key:
 specification_version: 4
 summary: plugin to upload log events to Google Cloud Storage (GCS)
 test_files:
+- spec/outputs/gcs/log_rotate_spec.rb
 - spec/outputs/gcs/path_factory_spec.rb
+- spec/outputs/gcs/temp_log_file_spec.rb
 - spec/outputs/gcs/worker_pool_spec.rb
 - spec/outputs/google_cloud_storage_spec.rb
 - spec/spec_helper.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA256:
-  metadata.gz: ef57485cd166eb205939da40bb4db73428955388af8e5c13d313852eb8c297c7
-  data.tar.gz: 8d3e0f581f611a9c7148ecc9f871b54e8c7ebf356ea3da39a3fa0a187d710184
-SHA512:
-  metadata.gz: 022b0a599c17c5a9dc062093662556f2cfd15c7d2345527b92a4b9bda4fb2fa3756e837bbe471a60bf2034ce2a6b059f76b2ec01c1d27ba6b54575f628e46bc8
-  data.tar.gz: b603dea8edb673e1a1e0c72a5431d5d915ade37d1f6164fb3b40882bdecb936a6959ec16e6724d239ca26e87b651c6a8602cfbd439d82d824bb14781611a8bd0