fluent-plugin-s3 0.5.11 → 0.6.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8fc0cbcb10886649237d443f3c2ca2a78157b26
-  data.tar.gz: 41c079389e44e2f47c8abcfad167b0724060d65d
+  metadata.gz: cd565fde9785110e7b4a202ec2b013c79381cbbf
+  data.tar.gz: 14fc7296e5f8d4dea3605f2affecc4b224da8af8
 SHA512:
-  metadata.gz: 6dece2571ff2d3899f8aa33b87dd8c21762f15eb732bfbf8867dd23760747b88d061113bda9dc060e430fa7d483daa4fd8540d13e2642ca9fd1158ea7c5bc260
-  data.tar.gz: 479759306f6db9351384e1848e5030f134ef4b8e4a3a99bf9afcb5f87a805e49ed97032fc06701c74469fc20100df75be1e6f7c4dad121eea334c91cf4b813aa
+  metadata.gz: 496c9a8350a9ffedc103cea38eeaea77a6bb7dcb7c4fc36c38d1cf927ea95ffd4d4b44d417873b325fbb3816dc958d36e98302efcbdad7b8fdf9d5616c5b6c37
+  data.tar.gz: 845cd5d1f2c79fc890c174cea1f855aa92b1fb4f944712ac1c3a253c886c3d48f072330044788e27144dc0a1bc86c062be04c73f9b30b9e50488db51be64bc7b

data/ChangeLog

@@ -1,3 +1,8 @@
+Release 0.6.0.pre1 - 2015/09/10
+
+  * Use AWS SDK v2
+
+
 Release 0.5.11 - 2015/08/04
 
   * Add acl parameter

data/README.rdoc

@@ -93,6 +93,9 @@ The {fluent-mixin-config-placeholders}[https://github.com/tagomoris/fluent-mixin
 - json
 - text
 - lzo (Need lzop command)
+- lzma2 (Need xz command)
+- gzip_command (Need gzip command)
+  - This compressor uses an external gzip command, hence would result in utilizing CPU cores well compared with `gzip`
 
 See 'Use your compression algorithm' section for adding another format.
 

data/VERSION

@@ -1 +1,2 @@
-0.5.11
+0.6.0.pre1
+

data/fluent-plugin-s3.gemspec

@@ -18,10 +18,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.add_dependency "fluentd", [">= 0.10.49", "< 2"]
-  gem.add_dependency "aws-sdk-v1", "~> 1.38"
+  gem.add_dependency "aws-sdk", "~> 2"
   gem.add_dependency "yajl-ruby", "~> 1.0"
   gem.add_dependency "fluent-mixin-config-placeholders", ">= 0.3.0"
   gem.add_development_dependency "rake", ">= 0.9.2"
-  gem.add_development_dependency "flexmock", ">= 1.2.0"
   gem.add_development_dependency "test-unit", ">= 3.0.8"
+  gem.add_development_dependency "test-unit-rr", ">= 1.0.3"
 end

data/lib/fluent/plugin/out_s3.rb

@@ -6,7 +6,7 @@ module Fluent
 
     def initialize
       super
-      require 'aws-sdk-v1'
+      require 'aws-sdk-resources'
       require 'zlib'
       require 'time'
       require 'tempfile'
@@ -15,13 +15,32 @@ module Fluent
     end
 
     config_param :path, :string, :default => ""
-    config_param :use_ssl, :bool, :default => true
     config_param :use_server_side_encryption, :string, :default => nil
     config_param :aws_key_id, :string, :default => nil, :secret => true
     config_param :aws_sec_key, :string, :default => nil, :secret => true
+    config_section :assume_role_credentials, :multi => false do
+      config_param :role_arn, :string
+      config_param :role_session_name, :string
+      config_param :policy, :string, :default => nil
+      config_param :duration_seconds, :integer, :default => nil
+      config_param :external_id, :string, :default => nil
+    end
+    config_section :instance_profile_credentials, :multi => false do
+      config_param :retries, :integer, :default => nil
+      config_param :ip_address, :string, :default => nil
+      config_param :port, :integer, :default => nil
+      config_param :http_open_timeout, :float, :default => nil
+      config_param :http_read_timeout, :float, :default => nil
+      # config_param :delay, :integer or :proc, :default => nil
+      # config_param :http_degub_output, :io, :default => nil
+    end
+    config_section :shared_credentials, :multi => false do
+      config_param :path, :string, :default => nil
+      config_param :profile_name, :string, :default => nil
+    end
     config_param :aws_iam_retries, :integer, :default => 5
     config_param :s3_bucket, :string
-    config_param :s3_region, :string, :default => nil
+    config_param :s3_region, :string, :default => ENV["AWS_REGION"] || "us-east-1"
     config_param :s3_endpoint, :string, :default => nil
     config_param :s3_object_key_format, :string, :default => "%{path}%{time_slice}_%{index}.%{file_extension}"
     config_param :store_as, :string, :default => "gzip"
@@ -29,6 +48,7 @@ module Fluent
     config_param :check_apikey_on_start, :bool, :default => true
     config_param :proxy_uri, :string, :default => nil
     config_param :reduced_redundancy, :bool, :default => false
+    config_param :storage_class, :string, :default => "STANDARD"
     config_param :format, :string, :default => 'out_file'
     config_param :acl, :string, :default => :private
 
@@ -68,27 +88,55 @@ module Fluent
           Time.now.utc.strftime(path)
         }
       end
+
+      @storage_class = "REDUCED_REDUNDANCY" if @reduced_redundancy
     end
 
     def start
       super
       options = {}
-      if @aws_key_id && @aws_sec_key
+      credentials_options = {}
+      case
+      when @aws_key_id && @aws_sec_key
         options[:access_key_id] = @aws_key_id
         options[:secret_access_key] = @aws_sec_key
-      elsif ENV.key? "AWS_ACCESS_KEY_ID"
-        options[:credential_provider] = AWS::Core::CredentialProviders::ENVProvider.new('AWS')
+      when @assume_role_credentials
+        c = @assume_role_credentials
+        credentials_options[:role_arn] = c.role_arn
+        credentials_options[:role_session_name] = c.role_session_name
+        credentials_options[:policy] = c.policy if c.policy
+        credentials_options[:duration_seconds] = c.duration_seconds if c.duration_seconds
+        credentials_options[:external_id] = c.external_id if c.external_id
+        options[:credentials] = Aws::AssumeRoleCredentials.new(credentials_options)
+      when @instance_profile_credentials
+        c = @instance_profile_credentials
+        credentials_options[:retries] = c.retries if c.retries
+        credentials_options[:ip_address] = c.ip_address if c.ip_address
+        credentials_options[:port] = c.port if c.port
+        credentials_options[:http_open_timeout] = c.http_open_timeout if c.http_open_timeout
+        credentials_options[:http_read_timeout] = c.http_read_timeout if c.http_read_timeout
+        options[:credentials] = Aws::InstanceProfileCredentials.new(credentials_options)
+      when @shared_credentials
+        c = @shared_credentials
+        credentials_options[:path] = c.path if c.path
+        credentials_options[:profile_name] = c.profile_name if c.profile_name
+        options[:credentials] = Aws::SharedCredentials.new(credentials_options)
+      when @aws_iam_retries
+        $log.warn("'aws_iam_retries' parameter is deprecated. Use 'instance_profile_credentials' instead")
+        credentials_options[:retries] = @aws_iam_retries
+        options[:credentials] = Aws::InstanceProfileCredentials.new(credentials_options)
       else
-        options[:credential_provider] = AWS::Core::CredentialProviders::EC2Provider.new({:retries => @aws_iam_retries})
+        # Use default credentials
+        # See http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Client.html
       end
       options[:region] = @s3_region if @s3_region
-      options[:s3_endpoint] = @s3_endpoint if @s3_endpoint
-      options[:proxy_uri] = @proxy_uri if @proxy_uri
-      options[:use_ssl] = @use_ssl
+      options[:endpoint] = @s3_endpoint if @s3_endpoint
+      options[:http_proxy] = @proxy_uri if @proxy_uri
       options[:s3_server_side_encryption] = @use_server_side_encryption.to_sym if @use_server_side_encryption
 
-      @s3 = AWS::S3.new(options)
-      @bucket = @s3.buckets[@s3_bucket]
+      s3_client = Aws::S3::Client.new(options)
+      @s3 = Aws::S3::Resource.new(:client => s3_client)
+      @bucket = @s3.bucket(@s3_bucket)
 
       check_apikeys if @check_apikey_on_start
       ensure_bucket
@@ -120,14 +168,15 @@ module Fluent
 
         i += 1
         previous_path = s3path
-      end while @bucket.objects[s3path].exists?
+      end while @bucket.object(s3path).exists?
 
       tmp = Tempfile.new("s3-")
       begin
         @compressor.compress(chunk, tmp)
-        @bucket.objects[s3path].write(Pathname.new(tmp.path), {:content_type => @compressor.content_type,
-                                                               :reduced_redundancy => @reduced_redundancy,
-                                                               :acl => @acl})
+        tmp.rewind
+        @bucket.object(s3path).put(:body => tmp,
+                                   :content_type => @compressor.content_type,
+                                   :storage_class => @storage_class)
       ensure
         tmp.close(true) rescue nil
       end
@@ -139,7 +188,7 @@ module Fluent
       if !@bucket.exists?
         if @auto_create_bucket
           log.info "Creating bucket #{@s3_bucket} on #{@s3_endpoint}"
-          @s3.buckets.create(@s3_bucket)
+          @s3.create_bucket(:bucket => @s3_bucket)
         else
           raise "The specified bucket does not exist: bucket = #{@s3_bucket}"
         end
@@ -147,8 +196,8 @@ module Fluent
     end
 
     def check_apikeys
-      @bucket.empty?
-    rescue AWS::S3::Errors::NoSuchBucket
+      @bucket.objects.first
+    rescue Aws::S3::Errors::NoSuchBucket
       # ignore NoSuchBucket Error because ensure_bucket checks it.
     rescue => e
       raise "can't call S3 API. Please check your aws_key_id / aws_sec_key or s3_region configuration. error = #{e.inspect}"
@@ -204,9 +253,9 @@ module Fluent
       def compress(chunk, tmp)
         w = Zlib::GzipWriter.new(tmp)
         chunk.write_to(w)
-        w.close
+        w.finish
       ensure
-        w.close rescue nil
+        w.finish rescue nil
       end
     end
 
@@ -221,7 +270,6 @@ module Fluent
 
       def compress(chunk, tmp)
         chunk.write_to(tmp)
-        tmp.close
       end
     end
 

data/test/test_out_s3.rb

@@ -1,12 +1,13 @@
 require 'fluent/test'
 require 'fluent/plugin/out_s3'
 
-require 'flexmock/test_unit'
+require 'test/unit/rr'
 require 'zlib'
+require 'fileutils'
 
 class S3OutputTest < Test::Unit::TestCase
   def setup
-    require 'aws-sdk-v1'
+    require 'aws-sdk-resources'
     Fluent::Test.setup
   end
 
@@ -41,7 +42,6 @@ class S3OutputTest < Test::Unit::TestCase
     assert_equal 'test_sec_key', d.instance.aws_sec_key
     assert_equal 'test_bucket', d.instance.s3_bucket
     assert_equal 'log', d.instance.path
-    assert d.instance.instance_variable_get(:@use_ssl)
     assert_equal 'gz', d.instance.instance_variable_get(:@compressor).ext
     assert_equal 'application/x-gzip', d.instance.instance_variable_get(:@compressor).content_type
   end
@@ -242,39 +242,21 @@ class S3OutputTest < Test::Unit::TestCase
   end
 
   def test_write_with_custom_s3_object_key_format
-    # Assert content of event logs which are being sent to S3
-    s3obj = flexmock(AWS::S3::S3Object)
-    s3obj.should_receive(:exists?).with_any_args.and_return { false }
-    s3obj.should_receive(:write).with(
-      on { |pathname|
-        data = nil
-        # Event logs are compressed in GZip
-        pathname.open { |f|
-          gz = Zlib::GzipReader.new(f)
-          data = gz.read
-          gz.close
-        }
-        assert_equal %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] +
-                     %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n],
-                     data
-
-        pathname.to_s.match(%r|s3-|)
-      },
-      {:content_type => "application/x-gzip", :reduced_redundancy => false, :acl => :private})
-
-    # Assert the key of S3Object, which event logs are stored in
-    s3obj_col = flexmock(AWS::S3::ObjectCollection)
-    s3obj_col.should_receive(:[]).with(
-      on { |key|
-        key == "log/events/ts=20110102-13/events_0-testing.node.local.gz"
-      }).
-      and_return {
-        s3obj
-      }
-
     # Partial mock the S3Bucket, not to make an actual connection to Amazon S3
-    s3bucket, _ = setup_mocks(true)
-    s3bucket.should_receive(:objects).with_any_args.and_return { s3obj_col }
+    setup_mocks(true)
+
+    # Assert content of event logs which are being sent to S3
+    s3obj = stub(Aws::S3::Object.new(:bucket_name => "test_bucket",
+                                     :key => "test",
+                                     :client => @s3_client))
+    s3obj.exists? { false }
+    s3_test_file_path = "/tmp/s3-test.txt"
+    tempfile = File.new(s3_test_file_path, "w")
+    mock(Tempfile).new("s3-") { tempfile }
+    s3obj.put(:body => tempfile,
+              :content_type => "application/x-gzip",
+              :storage_class => "STANDARD")
+    @s3_bucket.object("log/events/ts=20110102-13/events_0-testing.node.local.gz") { s3obj }
 
     # We must use TimeSlicedOutputTestDriver instead of BufferedOutputTestDriver,
     # to make assertions on chunks' keys
@@ -286,46 +268,38 @@ class S3OutputTest < Test::Unit::TestCase
 
     # Finally, the instance of S3Output is initialized and then invoked
     d.run
+    Zlib::GzipReader.open(s3_test_file_path) do |gz|
+      data = gz.read
+      assert_equal %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] +
+                   %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n],
+                   data
+    end
+    FileUtils.rm_f(s3_test_file_path)
   end
 
   def test_write_with_custom_s3_object_key_format_containing_uuid_flush_placeholder
-    # Assert content of event logs which are being sent to S3
-    s3obj = flexmock(AWS::S3::S3Object)
-    s3obj.should_receive(:exists?).with_any_args.and_return { false }
-    s3obj.should_receive(:write).with(
-      on { |pathname|
-        data = nil
-        # Event logs are compressed in GZip
-        pathname.open { |f|
-          gz = Zlib::GzipReader.new(f)
-          data = gz.read
-          gz.close
-        }
-        assert_equal %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] +
-                     %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n],
-                     data
-
-        pathname.to_s.match(%r|s3-|)
-      },
-      {:content_type => "application/x-gzip", :reduced_redundancy => false, :acl => :private})
-
-    # Assert the key of S3Object, which event logs are stored in
-    s3obj_col = flexmock(AWS::S3::ObjectCollection)
-    s3obj_col.should_receive(:[]).with(
-      on { |key|
-        key =~ /.*.[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}.*/
-      }).
-      and_return {
-        s3obj
-      }
-
     # Partial mock the S3Bucket, not to make an actual connection to Amazon S3
-    s3bucket, _ = setup_mocks(true)
-    s3bucket.should_receive(:objects).with_any_args.and_return { s3obj_col }
+    setup_mocks(true)
+
+    uuid = "5755e23f-9b54-42d8-8818-2ea38c6f279e"
+    stub(UUIDTools::UUID).random_create{ uuid }
+
+    # Assert content of event logs which are being sent to S3
+    s3obj = stub(Aws::S3::Object.new(:bucket_name => "test_bucket",
+                                     :key => "test",
+                                     :client => @s3_client))
+    s3obj.exists? { false }
+    s3_test_file_path = "/tmp/s3-test.txt"
+    tempfile = File.new(s3_test_file_path, "w")
+    mock(Tempfile).new("s3-") { tempfile }
+    s3obj.put(:body => tempfile,
+              :content_type => "application/x-gzip",
+              :storage_class => "STANDARD")
+    @s3_bucket.object("log/events/ts=20110102-13/events_0-#{uuid}.gz") { s3obj }
 
     # We must use TimeSlicedOutputTestDriver instead of BufferedOutputTestDriver,
     # to make assertions on chunks' keys
-    config = CONFIG_TIME_SLICE.clone.gsub(/%{hostname}/,"%{uuid_flush}")
+    config = CONFIG_TIME_SLICE.gsub(/%{hostname}/,"%{uuid_flush}")
     d = create_time_sliced_driver(config)
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
@@ -334,22 +308,32 @@ class S3OutputTest < Test::Unit::TestCase
 
     # Finally, the instance of S3Output is initialized and then invoked
     d.run
+    Zlib::GzipReader.open(s3_test_file_path) do |gz|
+      data = gz.read
+      assert_equal %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] +
+                   %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n],
+                   data
+    end
+    FileUtils.rm_f(s3_test_file_path)
   end
 
   def setup_mocks(exists_return = false)
-    s3bucket = flexmock(AWS::S3::Bucket)
-    s3bucket.should_receive(:exists?).with_any_args.and_return { exists_return }
-    s3bucket_col = flexmock(AWS::S3::BucketCollection)
-    s3bucket_col.should_receive(:[]).with_any_args.and_return { s3bucket }
-    flexmock(AWS::S3).new_instances do |bucket|
-      bucket.should_receive(:buckets).with_any_args.and_return { s3bucket_col }
-    end
-
-    return s3bucket, s3bucket_col
+    @s3_client = stub(Aws::S3::Client.new(:stub_responses => true))
+    mock(Aws::S3::Client).new(anything).at_least(0) { @s3_client }
+    @s3_resource = mock(Aws::S3::Resource.new(:client => @s3_client))
+    mock(Aws::S3::Resource).new(:client => @s3_client) { @s3_resource }
+    @s3_bucket = mock(Aws::S3::Bucket.new(:name => "test",
+                                          :client => @s3_client))
+    @s3_bucket.exists? { exists_return }
+    @s3_object = mock(Aws::S3::Object.new(:bucket_name => "test_bucket",
+                                          :key => "test",
+                                          :client => @s3_client))
+    @s3_bucket.object(anything).at_least(0) { @s3_object }
+    @s3_resource.bucket(anything) { @s3_bucket }
   end
 
   def test_auto_create_bucket_false_with_non_existence_bucket
-    s3bucket, s3bucket_col = setup_mocks
+    setup_mocks
 
     config = CONFIG_TIME_SLICE + 'auto_create_bucket false'
     d = create_time_sliced_driver(config)
@@ -359,73 +343,83 @@ class S3OutputTest < Test::Unit::TestCase
   end
 
   def test_auto_create_bucket_true_with_non_existence_bucket
-    s3bucket, s3bucket_col = setup_mocks
-    s3bucket_col.should_receive(:create).with_any_args.and_return { true }
+    setup_mocks
+    @s3_resource.create_bucket(:bucket => "test_bucket")
 
     config = CONFIG_TIME_SLICE + 'auto_create_bucket true'
     d = create_time_sliced_driver(config)
     assert_nothing_raised { d.run }
   end
 
-  def test_aws_credential_provider_default
-    s3bucket, s3bucket_col = setup_mocks
-    s3bucket_col.should_receive(:create).with_any_args.and_return { true }
-
+  def test_credentials
     d = create_time_sliced_driver
-    assert_nothing_raised { d.run }
-    assert_equal "AWS::Core::CredentialProviders::DefaultProvider", d.instance.instance_variable_get(:@s3).config.credential_provider.class.to_s
+    assert_nothing_raised{ d.run }
+    client = d.instance.instance_variable_get(:@s3).client
+    credentials = client.config.credentials
+    assert_instance_of(Aws::Credentials, credentials)
   end
 
-  def test_aws_credential_provider_env
-    s3bucket, s3bucket_col = setup_mocks
-    s3bucket_col.should_receive(:create).with_any_args.and_return { true }
-    key = ENV['AWS_ACCESS_KEY_ID']
-    ENV.replace({'AWS_ACCESS_KEY_ID' => 'my_access_key'})
-
-    config = CONFIG_TIME_SLICE.clone.split("\n").reject{|x| x =~ /.+aws_.+/}.join("\n")
+  def test_assume_role_credentials
+    expected_credentials = Aws::Credentials.new("test_key", "test_secret")
+    mock(Aws::AssumeRoleCredentials).new(:role_arn => "test_arn",
+                                         :role_session_name => "test_session"){
+      expected_credentials
+    }
+    config = CONFIG_TIME_SLICE.split("\n").reject{|x| x =~ /.+aws_.+/}.join("\n")
+    config += %[
+      <assume_role_credentials>
+        role_arn test_arn
+        role_session_name test_session
+      </assume_role_credentials>
+    ]
     d = create_time_sliced_driver(config)
-
-    assert_equal true, ENV.key?('AWS_ACCESS_KEY_ID')
-    assert_nothing_raised { d.run }
-    assert_equal nil, d.instance.aws_key_id
-    assert_equal nil, d.instance.aws_sec_key
-    assert_equal "AWS::Core::CredentialProviders::ENVProvider", d.instance.instance_variable_get(:@s3).config.credential_provider.class.to_s
-
-    ENV.replace({'AWS_ACCESS_KEY_ID' => key}) unless key.nil?
+    assert_nothing_raised{ d.run }
+    client = d.instance.instance_variable_get(:@s3).client
+    credentials = client.config.credentials
+    assert_equal(expected_credentials, credentials)
   end
 
-  def test_aws_credential_provider_ec2
-    s3bucket, s3bucket_col = setup_mocks
-    s3bucket_col.should_receive(:create).with_any_args.and_return { true }
-    key = ENV['AWS_ACCESS_KEY_ID']
-    ENV.delete('AWS_ACCESS_KEY_ID')
-
-    config = CONFIG_TIME_SLICE.clone.split("\n").reject{|x| x =~ /.+aws_.+/}.join("\n")
+  def test_instance_profile_credentials
+    expected_credentials = Aws::Credentials.new("test_key", "test_secret")
+    mock(Aws::InstanceProfileCredentials).new({}).returns(expected_credentials)
+    config = CONFIG_TIME_SLICE.split("\n").reject{|x| x =~ /.+aws_.+/}.join("\n")
+    config += %[
+      <instance_profile_credentials>
+      </instance_profile_credentials>
+    ]
     d = create_time_sliced_driver(config)
-
-    assert_equal false, ENV.key?('AWS_ACCESS_KEY_ID')
-    assert_nothing_raised { d.run }
-    assert_equal nil, d.instance.aws_key_id
-    assert_equal nil, d.instance.aws_sec_key
-    assert_equal "AWS::Core::CredentialProviders::EC2Provider", d.instance.instance_variable_get(:@s3).config.credential_provider.class.to_s
-    assert_equal 5, d.instance.instance_variable_get(:@s3).config.credential_provider.retries
-
-    ENV.replace({'AWS_ACCESS_KEY_ID' => key}) unless key.nil?
+    assert_nothing_raised{ d.run }
+    client = d.instance.instance_variable_get(:@s3).client
+    credentials = client.config.credentials
+    assert_equal(expected_credentials, credentials)
   end
 
-  def test_aws_credential_provider_ec2_with_retries
-    s3bucket, s3bucket_col = setup_mocks
-    s3bucket_col.should_receive(:create).with_any_args.and_return { true }
-    key = ENV['AWS_ACCESS_KEY_ID']
-    ENV.delete('AWS_ACCESS_KEY_ID')
-
-    config = [CONFIG_TIME_SLICE.clone.split("\n").reject{|x| x =~ /.+aws_.+/}, 'aws_iam_retries 7'].join("\n")
+  def test_instance_profile_credentials_aws_iam_retries
+    expected_credentials = Aws::Credentials.new("test_key", "test_secret")
+    mock(Aws::InstanceProfileCredentials).new({}).returns(expected_credentials)
+    config = CONFIG_TIME_SLICE.split("\n").reject{|x| x =~ /.+aws_.+/}.join("\n")
+    config += %[
+      aws_iam_retries 10
+    ]
     d = create_time_sliced_driver(config)
+    assert_nothing_raised{ d.run }
+    client = d.instance.instance_variable_get(:@s3).client
+    credentials = client.config.credentials
+    assert_equal(expected_credentials, credentials)
+  end
 
-    config = [CONFIG, 'include_tag_key true', 'include_time_key true'].join("\n")
-    assert_nothing_raised { d.run }
-    assert_equal 7, d.instance.instance_variable_get(:@s3).config.credential_provider.retries
-
-    ENV.replace({'AWS_ACCESS_KEY_ID' => key}) unless key.nil?
+  def test_shared_credentials
+    expected_credentials = Aws::Credentials.new("test_key", "test_secret")
+    mock(Aws::SharedCredentials).new({}).returns(expected_credentials)
+    config = CONFIG_TIME_SLICE.split("\n").reject{|x| x =~ /.+aws_.+/}.join("\n")
+    config += %[
+      <shared_credentials>
+      </shared_credentials>
+    ]
+    d = create_time_sliced_driver(config)
+    assert_nothing_raised{ d.run }
+    client = d.instance.instance_variable_get(:@s3).client
+    credentials = client.config.credentials
+    assert_equal(expected_credentials, credentials)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-s3
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.6.0.pre1
 platform: ruby
 authors:
 - Sadayuki Furuhashi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-04 00:00:00.000000000 Z
+date: 2015-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -32,19 +32,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-v1
+  name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.38'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.38'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -88,33 +88,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.9.2
 - !ruby/object:Gem::Dependency
-  name: flexmock
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 3.0.8
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 3.0.8
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: test-unit-rr
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.8
+        version: 1.0.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.8
+        version: 1.0.3
 description: Amazon S3 output plugin for Fluentd event collector
 email: frsyuki@gmail.com
 executables: []
@@ -150,9 +150,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.3