logstash-output-qingstor 0.1.0

data/lib/logstash/outputs/qingstor/time_rotation_policy.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module LogStash
+  module Outputs
+    class Qingstor
+      class TimeRotationPolicy
+        attr_reader :time_file
+
+        def initialize(time_file)
+          if time_file <= 0
+            raise LogStash::ConfigurationError, "'time_file' need to be greater then 0"
+          end 
+
+          @time_file = time_file * 60
+        end 
+
+        def rotate?(file)
+          file.size > 0 && (Time.now - file.ctime) >= time_file
+        end 
+
+        def needs_periodic?
+          true 
+        end 
+      end 
+    end 
+  end 
+end 

data/lib/logstash/outputs/qingstor/uploader.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require "qingstor/sdk"
+require "concurrent"
+require "digest/md5"
+require "base64"
+module LogStash
+  module Outputs
+    class Qingstor
+      class Uploader 
+        TIME_BEFORE_RETRYING_SECONDS = 1
+        DEFAULT_THREADPOOL = Concurrent::ThreadPoolExecutor.new({ :min_thread => 1,
+                                                                  :max_thread => 8,
+                                                                  :max_queue => 1,
+                                                                  :fallback_policy => :caller_runs
+                                                                })
+        attr_reader :bucket, :upload_options, :logger 
+
+        def initialize(bucket, logger, threadpool = DEFAULT_THREADPOOL)
+          @bucket = bucket
+          @logger = logger
+          @workers_pool = threadpool
+        end 
+
+        def upload_async(file, options = {})
+          @workers_pool.post do
+            upload(file, options)
+          end 
+        end 
+
+        def upload(file, options = {})
+          upload_options = options.fetch(:upload_options, {})
+
+          file_md5 = Digest::MD5.file(file.path).to_s
+    
+          upload_headers = {
+            "content_md5" => file_md5,
+            "body" => ::File.open(file.path)
+          }
+
+          if !upload_options[:server_side_encryption_algorithm].nil?
+            base64_key = Base64.strict_encode64 upload_options[:customer_key]
+            key_md5 = Digest::MD5.hexdigest upload_options[:customer_key]
+            base64_key_md5 = Base64.strict_encode64 key_md5
+            upload_headers.merge!({
+              "x_qs_encryption_customer_algorithm" => upload_options[:server_side_encryption_algorithm],
+              "x_qs_encryption_customer_key" => base64_key,
+              "x_qs_encryption_customer_key_md5" => base64_key_md5,
+            })
+          end 
+          @logger.debug("uploading file", :file => file.key)
+          bucket.put_object(file.key, upload_headers)
+
+          options[:on_complete].call(file) unless options[:on_complete].nil?
+        end 
+
+        def stop 
+          @workers_pool.shutdown
+          @workers_pool.wait_for_termination(nil)
+        end 
+      end 
+    end 
+  end 
+end 
+          

data/lib/logstash/outputs/qingstor.rb

@@ -0,0 +1,253 @@
+# encoding: utf-8
+require "logstash-core"
+require "logstash/outputs/base"
+require "logstash/namespace"
+require "tmpdir"
+require "qingstor/sdk"
+require "concurrent"
+
+class LogStash::Outputs::Qingstor < LogStash::Outputs::Base
+  require "logstash/outputs/qingstor/temporary_file"
+  require "logstash/outputs/qingstor/temporary_file_factory"
+  require "logstash/outputs/qingstor/file_repository"
+  require "logstash/outputs/qingstor/size_rotation_policy"
+  require "logstash/outputs/qingstor/time_rotation_policy"
+  require "logstash/outputs/qingstor/size_and_time_rotation_policy"
+  require "logstash/outputs/qingstor/uploader"
+  require "logstash/outputs/qingstor/qingstor_validator"
+
+  PERIODIC_CHECK_INTERVAL_IN_SECONDS = 15
+  CRASH_RECOVERY_THREADPOOL = Concurrent::ThreadPoolExecutor.new({
+                                                                  :min_threads => 1,
+                                                                  :max_threads => 2,
+                                                                  :fallback_policy => :caller_runs
+                                                                })
+  config_name "qingstor"
+
+  # When configured as :single a single instance of the Output will be shared among the
+  # pipeline worker threads. Access to the `#multi_receive/#multi_receive_encoded/#receive` method will be synchronized
+  # i.e. only one thread will be active at a time making threadsafety much simpler.
+  #
+  # You can set this to :shared if your output is threadsafe. This will maximize
+  # concurrency but you will need to make appropriate uses of mutexes in `#multi_receive/#receive`.
+  #
+  # Only the `#multi_receive/#multi_receive_encoded` methods need to actually be threadsafe, the other methods
+  # will only be executed in a single thread
+  concurrency :shared
+
+  # The key id to access your QingStor
+  config :access_key_id, :validate => :string, :required => true
+
+  # The key to access your QingStor
+  config :secret_access_key, :validate => :string, :required => true
+
+  # The name of the qingstor bucket
+  config :bucket, :validate => :string, :required => true
+
+  # The region of the QingStor bucket
+  config :region, :validate => ["pek3a", "sh1a"], :default => "pek3a"
+
+  # The prefix of filenames which will work as directory in qingstor 
+  config :prefix, :validate => :string, :default => ''
+
+  # Set the directory where logstash store the tmp files before 
+  # sending it to qingstor, default directory in linux /tmp/logstash2qingstor
+  config :tmpdir, :validate => :string, :default => File.join(Dir.tmpdir, "logstash2qingstor")
+
+  # Define tags to append to the file on the qingstor bucket
+  config :tags, :validate => :array, :default => []
+
+  # Specify the content encoding. Supports ("gzip"), defaults to "none"
+  config :encoding, :validate => ["gzip", "none"], :default => "none"
+
+  # Define the strategy to use to decide when we need to rotate the file and push it to S3,
+  # The default strategy is to check for both size and time, the first one to match will rotate the file.
+  config :rotation_strategy, :validate => ["size_and_time", "size", "time"], :default => "size_and_time"
+
+  # Define the size requirement for each file to upload to qingstor. In byte.
+  config :size_file, :validate => :number, :default => 1024 * 1024 * 5
+
+  # Define the time interval for each file to upload to qingstor. In minutes.
+  config :time_file, :validate => :number, :default => 15 
+
+  # Specify maximum number of workers to use to upload the files to Qingstor
+  config :upload_workers_count, :validate => :number, :default => (Concurrent.processor_count * 0.5).ceil
+
+  # Number of items we can keep in the local queue before uploading them
+  config :upload_queue_size, :validate => :number, :default => 2 * (Concurrent.processor_count * 0.25).ceil
+
+  # Specifies what type of encryption to use when SSE is enabled.
+  config :server_side_encryption_algorithm, :validate => ["AES256", "none"], :default => "none"
+
+  # Specifies the encryption customer key that would be used in server side   
+  config :customer_key, :validate => :string
+
+  # Specifies if set to true, it would upload existing file in targeting folder at the beginning.
+  config :restore, :validate => :boolean, :default => false  
+
+  public
+  def register
+    QingstorValidator.prefix_valid?(@prefix) unless @prefix.nil?
+
+    if !directory_valid?(@tmpdir)
+      raise LogStash::ConfigurationError, "Logstash must have the permissions to write to the temporary directory: #{@tmpdir}"
+    end
+    
+    @file_repository = FileRepository.new(@tags, @encoding, @tmpdir)
+
+    @rotation = rotation_strategy
+
+    executor = Concurrent::ThreadPoolExecutor.new({ 
+      :min_threads => 1,
+      :max_threads => @upload_workers_count,
+      :max_queue => @upload_queue_size,
+      :fallback_policy => :caller_runs 
+    })
+
+    @qs_bucket = get_bucket
+    QingstorValidator.bucket_valid?(@qs_bucket)
+
+    @uploader = Uploader.new(@qs_bucket, @logger, executor)
+
+    start_periodic_check if @rotation.needs_periodic?
+
+    restore_from_crash if @restore 
+  end # def register
+
+  public
+  def multi_receive_encoded(events_and_encoded)
+    prefix_written_to = Set.new
+
+    events_and_encoded.each do |event, encoded|
+      prefix_key = event.sprintf(@prefix)
+      prefix_written_to << prefix_key
+
+      begin
+        @file_repository.get_file(prefix_key) { |file| file.write(encoded) }
+      rescue Errno::ENOSPC => e
+        @logger.error("QingStor: Nospace left in temporary directory", :tmpdir => @tmpdir)
+        raise e 
+      end 
+    end # end of each method  
+
+    # check the file after file writing 
+    # Groups IO calls to optimize fstat checks 
+    rotate_if_needed(prefix_written_to)
+  end  # def multi_receive_encoded
+  
+  def rotation_strategy 
+    case @rotation_strategy
+    when "size"
+      SizeRotationPolicy.new(@size_file)
+    when "time"
+      TimeRotationPolicy.new(@time_file)
+    when "size_and_time"
+      SizeAndTimeRotationPolicy.new(@size_file, @time_file)
+    end 
+  end 
+
+  def rotate_if_needed(prefixs)
+    prefixs.each do |prefix|
+      @file_repository.get_factory(prefix) do |factory|
+        tmp_file = factory.current
+
+        if @rotation.rotate?(tmp_file)
+          @logger.debug("Rotate file", 
+                        :strategy => tmp_file.key,
+                        :path => tmp_file.path)
+          upload_file(tmp_file)
+          factory.rotate!
+        end 
+      end 
+    end 
+  end # def rotate_if_needed
+
+  def upload_file(file)
+    @logger.debug("Add file to uploading queue", :key => file.key)
+    file.close 
+    @logger.debug("upload options", :upload_options => upload_options)
+    @uploader.upload_async(file,
+                          :on_complete => method(:clean_temporary_file),
+                          :upload_options => upload_options)
+  end 
+
+  def get_bucket
+    @qs_config = QingStor::SDK::Config.init @access_key_id, @secret_access_key
+    @qs_service = QingStor::SDK::Service.new @qs_config
+    @qs_service.bucket @bucket, @region
+  end 
+
+  def close 
+    stop_periodic_check if @rotation.needs_periodic?
+
+    @logger.debug("uploading current workspace")
+    @file_repository.each_files do |file|
+      upload_file(file)
+    end 
+
+    @file_repository.shutdown
+
+    @uploader.stop 
+
+    @crash_uploader.stop if @restore
+  end 
+
+  def upload_options
+    options = {
+      :content_encoding => @encoding == "gzip" ? "gzip" : nil 
+    }
+
+    if  @server_side_encryption_algorithm == "AES256" && !@customer_key.nil?
+      options.merge!({
+        :server_side_encryption_algorithm => @server_side_encryption_algorithm,
+        :customer_key => @customer_key
+      })
+    end 
+    
+    options 
+  end 
+
+  def clean_temporary_file(file)
+    @logger.debug("Removing temporary file", :file => file.path)
+    file.delete!
+  end 
+
+  def start_periodic_check
+    @logger.debug("Start periodic rotation check")
+
+    @periodic_check = Concurrent::TimerTask.new(:execution_interval => PERIODIC_CHECK_INTERVAL_IN_SECONDS) do
+      @logger.debug("Periodic check for stale files")
+
+      rotate_if_needed(@file_repository.keys)
+    end
+
+    @periodic_check.execute 
+  end 
+
+  def stop_periodic_check 
+    @periodic_check.shutdown 
+  end 
+
+  def directory_valid?(path)
+    begin 
+      FileUtils.mkdir_p(path) unless Dir.exist?(path)
+      ::File.writable?(path)
+    rescue 
+      false 
+    end 
+  end 
+
+  def restore_from_crash 
+    @crash_uploader = Uploader.new(@qs_bucket, @logger, CRASH_RECOVERY_THREADPOOL)
+
+    temp_folder_path = Pathname.new(@tmpdir)
+    Dir.glob(::File.join(@tmpdir, "**/*"))
+      .select { |file| ::File.file?(file) }
+      .each do |file| 
+      temp_file = TemporaryFile.create_from_existing_file(file, temp_folder_path)
+      @logger.debug("Recoving from crash and uploading", :file => temp_file.path)
+      @crash_uploader.upload_async(temp_file, :on_complete => method(:clean_temporary_file),
+                                              :upload_options => upload_options)
+    end 
+  end 
+end # class LogStash::Outputs::Qingstor

data/logstash-output-qingstor.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name          = 'logstash-output-qingstor'
+  s.version       = '0.1.0'
+  s.licenses      = ['Apache License (2.0)']
+  s.summary       = 'logstash output plugin for qingstor'
+  s.description   = 'Put the outcomes of logstash into qingstor'
+  s.homepage      = 'https://github.com/tacinight/logstash-output-qingstor'
+  s.authors       = ['Evan Zhao']
+  s.email         = 'tacingiht@gmail.com'
+  s.require_paths = ['lib']
+
+  # Files
+  s.files = Dir['lib/**/*','spec/**/*','vendor/**/*','*.gemspec','*.md','CONTRIBUTORS','Gemfile','LICENSE','NOTICE.TXT']
+   # Tests
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Special flag to let us know this is actually a logstash plugin
+  s.metadata = { "logstash_plugin" => "true", "logstash_group" => "output" }
+
+  # Gem dependencies
+  s.add_runtime_dependency "logstash-core-plugin-api", "~> 2.0"
+  s.add_runtime_dependency "logstash-codec-plain"
+  s.add_runtime_dependency "qingstor-sdk", "=1.9.2"
+  s.add_runtime_dependency "concurrent-ruby"
+  
+  s.add_development_dependency "stud", "~> 0.0.22"
+  s.add_development_dependency "logstash-devutils"
+end

data/spec/outputs/qingstor/file_repository_spec.rb

@@ -0,0 +1,26 @@
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/temporary_file"
+require "logstash/outputs/qingstor/temporary_file_factory"
+require "logstash/outputs/qingstor/file_repository"
+require "tmpdir"
+
+describe LogStash::Outputs::Qingstor::FileRepository do 
+  let(:tags) { ["tag1", "tag2", "tag3"]}
+  let(:encoding) { "none" }
+  let(:tmpdir) { File.join(Dir.tmpdir, "lg2qs") }
+  let(:prefix) { "aprefix" }
+
+  subject { described_class.new(tags, encoding, tmpdir) }
+
+  it "can get current file io" do 
+    subject.get_file(prefix) do |file| 
+       expect(file).to be_kind_of(LogStash::Outputs::Qingstor::TemporaryFile)
+    end 
+  end 
+
+  it "can get current file factory" do 
+    subject.get_factory(prefix) do |factory| 
+      expect(factory).to be_kind_of(LogStash::Outputs::Qingstor::TemporaryFileFactory)
+    end 
+  end 
+end 

data/spec/outputs/qingstor/qingstor_validator_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/qingstor_validator"
+require_relative "../qs_access_helper"
+
+describe LogStash::Outputs::Qingstor::QingstorValidator do
+  let(:normal_prefix) { "super/bucket" }
+  let(:wrong_prefix1) { "/wrong/prefix" }
+  let(:wrong_prefix2) { normal_prefix * 100 }
+  let(:bucket) { qs_bucket_init }
+
+  it "raise error if the prefix is not valid" do 
+    expect{ described_class.prefix_valid?(wrong_prefix1) }.to raise_error(LogStash::ConfigurationError)
+    expect{ described_class.prefix_valid?(wrong_prefix2) }.to raise_error(LogStash::ConfigurationError)
+  end
+
+  it "return true if the prefix is valid" do 
+    expect(described_class.prefix_valid?(normal_prefix)).to be_truthy
+  end 
+
+end 

data/spec/outputs/qingstor/size_and_time_rotation_policy_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/temporary_file"
+require "logstash/outputs/qingstor/size_and_time_rotation_policy"
+
+describe LogStash::Outputs::Qingstor::SizeAndTimeRotationPolicy do
+  let(:size_file) { 1024 * 2 }
+  let(:time_file) { 2 }
+  let(:name) { "foobar" }
+  let(:tmp_file) { Stud::Temporary.file }
+  let(:tmp_dir) { tmp_file.path }
+  let(:file) { LogStash::Outputs::Qingstor::TemporaryFile.new(name, tmp_file, tmp_dir) }
+  let(:content) { "May the code be with you" * 100 }
+  subject { described_class.new(size_file, time_file) }
+
+  it "raise error if time_file is no grater then 0" do 
+    expect{ described_class.new(0, 0) }.to raise_error(LogStash::ConfigurationError)
+    expect{ described_class.new(-1, 0) }.to raise_error(LogStash::ConfigurationError)
+    expect{ described_class.new(0, -1) }.to raise_error(LogStash::ConfigurationError)
+    expect{ described_class.new(-1, -1) }.to raise_error(LogStash::ConfigurationError)
+  
+  end 
+
+  it "return false if the file is not old enough" do 
+    expect(subject.rotate?(file)).to be_falsey
+  end
+
+  it "return false if the file is old enough with file size 0" do
+    allow(file).to receive(:ctime).and_return(Time.now - (time_file * 2 * 60))
+    expect(subject.rotate?(file)).to be_falsey
+  end
+
+  it "return truth if the file is old enough and non-empty" do 
+    file.write(content)
+    file.fsync
+    allow(file).to receive(:ctime).and_return(Time.now - (time_file * 2 * 60))
+    expect(subject.rotate?(file)).to be_truthy
+  end
+end 

data/spec/outputs/qingstor/size_rotation_policy_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/temporary_file"
+require "logstash/outputs/qingstor/size_rotation_policy"
+
+describe LogStash::Outputs::Qingstor::SizeRotationPolicy do
+  let(:size_file) { 1024 * 2 }
+  let(:name) { "foobar" }
+  let(:tmp_file) { Stud::Temporary.file }
+  let(:tmp_dir) { tmp_file.path }
+  let(:file) { LogStash::Outputs::Qingstor::TemporaryFile.new(name, tmp_file, tmp_dir) }
+  let(:content) { "May the code be with you" * 100 }
+  subject { described_class.new(size_file) }
+
+  it "raise error if size_file is no grater then 0" do 
+    expect{described_class.new(0)}.to raise_error(LogStash::ConfigurationError)
+    expect{described_class.new(-1)}.to raise_error(LogStash::ConfigurationError)
+  end 
+
+  it "return true if the file has a bigger size value then 'size_file'" do 
+    file.write(content)
+    file.fsync
+    expect(subject.rotate?(file)).to be_truthy
+  end
+end 

data/spec/outputs/qingstor/temporary_file_factory_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/temporary_file"
+require "logstash/outputs/qingstor/temporary_file_factory"
+require "fileutils"
+require "tmpdir"
+
+describe LogStash::Outputs::Qingstor::TemporaryFileFactory do
+  let(:prefix) { "lg2qs" }
+  let(:tags) { [ ] }
+  let(:tmpdir) { File.join(Dir.tmpdir, "logstash-qs") }
+
+  subject { described_class.new(prefix, tags, encoding, tmpdir) }
+
+  shared_examples "file factory" do
+    it "creates the file on disk" do
+      expect(File.exist?(subject.current.path)).to be_truthy
+    end
+
+    it "create a temporary file when initialized" do
+      expect(subject.current).to be_kind_of(LogStash::Outputs::Qingstor::TemporaryFile)
+    end
+
+    it "create a file in the right format" do
+      expect(subject.current.path).to match(extension)
+    end
+
+    it "allow to rotate the file" do
+      file_path = subject.current.path
+      expect(subject.rotate!.path).not_to eq(file_path)
+    end
+
+    it "increments the part name on rotation" do
+      expect(subject.current.path).to match(/part0/)
+      expect(subject.rotate!.path).to match(/part1/)
+    end
+
+    it "includes the date" do
+      n = Time.now
+      expect(subject.current.path).to include(n.strftime("%Y-%m-%dT"))
+    end
+
+    it "include the file key in the path"  do
+      file = subject.current
+      expect(file.path).to match(/#{file.key}/)
+    end
+
+    it "create a unique directory in the temporary directory for each file" do
+      uuid = "hola"
+      expect(SecureRandom).to receive(:uuid).and_return(uuid).twice
+      expect(subject.current.path).to include(uuid)
+    end
+
+    context "with tags supplied" do
+      let(:tags) { ["secret", "service"] }
+
+      it "adds tags to the filename" do
+        expect(subject.current.path).to match(/tag_#{tags.join('.')}.part/)
+      end
+    end
+
+    context "without tags" do
+      it "doesn't add tags to the filename" do
+        expect(subject.current.path).not_to match(/tag_/)
+      end
+    end
+  end
+
+  context "when gzip" do
+    let(:encoding) { "gzip" }
+    let(:extension) { /\.log.gz$/ }
+
+    include_examples "file factory"
+  end
+
+  context "when encoding set to `none`" do
+    let(:encoding) { "none" }
+    let(:extension) { /\.log$/ }
+
+    include_examples "file factory"
+  end
+end 

data/spec/outputs/qingstor/temporary_file_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/temporary_file"
+require "fileutils"
+require "tmpdir"
+
+describe LogStash::Outputs::Qingstor::TemporaryFile do
+  let(:key) { "foo.log" }
+  let(:content) { "May the code be with you!" }
+  let(:tmp_path) { File.join(Dir.tmpdir, key) }
+  let(:file_mode) { "w+" }
+  let(:io){ ::File.open(tmp_path, file_mode)}
+
+  after(:all) do 
+    FileUtils.rm_r("/tmp/foo.log") if File.exist?("/tmp/foo.log")
+  end 
+
+  subject { described_class.new(key, io, tmp_path) }
+
+  it "return the key of the file" do 
+    expect(subject.key).to eq(key) 
+  end 
+
+  it "is writable and readable" do 
+    subject.write(content)
+    subject.close 
+    expect(File.read(subject.path).strip).to eq(content)
+  end 
+
+  it "can return the correct file size" do 
+    subject.write(content)
+    subject.close 
+    expect(subject.size).to eq(File.size(tmp_path))
+  end 
+
+  it "return the tmp_path of the file" do 
+    expect(subject.tmp_path).to eq(tmp_path)
+  end 
+
+  it "return the creation time" do 
+    expect(subject.ctime).to be < Time.now + 1.0
+  end 
+
+  it "can delete file correctly" do
+    expect(File.exist?(subject.tmp_path)).to be_truthy
+    subject.delete!
+    expect(File.exist?(subject.tmp_path)).to be_falsey
+  end
+
+  it "return if the file is empty" do 
+    expect(subject.empty?).to be_truthy
+    subject.write(content)
+    expect(subject.empty?).to be_falsey
+  end 
+end 

data/spec/outputs/qingstor/time_rotation_policy_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/qingstor/temporary_file"
+require "logstash/outputs/qingstor/time_rotation_policy"
+
+describe LogStash::Outputs::Qingstor::TimeRotationPolicy do
+  let(:time_file) { 2 }
+  let(:name) { "foobar" }
+  let(:tmp_file) { Stud::Temporary.file }
+  let(:tmp_dir) { tmp_file.path }
+  let(:file) { LogStash::Outputs::Qingstor::TemporaryFile.new(name, tmp_file, tmp_dir) }
+  let(:content) { "May the code be with you" * 100 }
+  subject { described_class.new(time_file) }
+
+  it "raise error if time_file is no grater then 0" do 
+    expect{described_class.new(0)}.to raise_error(LogStash::ConfigurationError)
+    expect{described_class.new(-1)}.to raise_error(LogStash::ConfigurationError)
+  end 
+
+  it "return false if the file is not old enough" do 
+    expect(subject.rotate?(file)).to be_falsey
+  end
+
+  it "return false if the file is old enough with file size 0" do
+    allow(file).to receive(:ctime).and_return(Time.now - (time_file * 2 * 60))
+    expect(subject.rotate?(file)).to be_falsey
+  end
+
+  it "return truth if the file is old enough and non-empty" do 
+    file.write(content)
+    file.fsync
+    allow(file).to receive(:ctime).and_return(Time.now - (time_file * 2 * 60))
+    expect(subject.rotate?(file)).to be_truthy
+  end
+end