fluent-plugin-sqs 1.8.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f51886fc46c9dff3450a0cd2adb6c3315961ff4f
-  data.tar.gz: a2f22f1ffec81f241b9cfa572401ce7a8e956cd4
+  metadata.gz: c7d738c77ff00141662a60dbe4db65109c7c873b
+  data.tar.gz: f399c2e1ee216a6f84cc7c172e22950a4a3e8b0c
 SHA512:
-  metadata.gz: fddc35298bdcd515cb3161821804f415dc28a6c4f9eb26ca5696649ea92baf338cce5101d2f6a9fc6fcb3cfe1858b5d00fde640792bf339d3f3ed59a0105d9a2
-  data.tar.gz: e8b6c5413fd3675cc9b7bffc3febb454287c69cdf1e046eb04aa6efdb144d9b41cade14434deafcd7e12e9674c7ee9ee7b59f077f14a62da5df452ee86454a3d
+  metadata.gz: 6d55dc8fe951b822e8b047fcf29f8dbf1ab07775292afa0b1d9dc621e82e2c8b489a8397488a894a22ef90c78210d1de9506483e9a92b2878616ac7da50a2717
+  data.tar.gz: af34dacba968a84f73422c7fd0c94bf1eb924466cfdba99d1f3c06030cae047ce8739424c1470b94045f157d8053facc701ad3f17700163896ea5d4d4d1ac318

data/README.rdoc

@@ -35,16 +35,16 @@ Read events from from amazon SQS.
       # following attibutes are optional
     　
       create_queue {boolean}
-      sqs_endpoint {endpointURL}
+      region {your_region}
 
-      ### endpoint list ###
-      # Asia Pacific (Tokyo) [Default] : sqs.ap-northeast-1.amazonaws.com
-      # Asia Pacific (Singapore)       : sqs.ap-southeast-1.amazonaws.com
-      # US-East (Virginia)             : sqs.us-east-1.amazonaws.com
-      # US-West (Oregon)               : sqs.us-west-2.amazonaws.com
-      # US-West (N.California)         : sqs.us-west-1.amazonaws.com
-      # EU-West (Ireland)              : sqs.eu-west-1.amazonaws.com
-      # South America (São Paulo)      : sns.sa-east-1.amazonaws.com
+      ### region list ###
+      # Asia Pacific (Tokyo) [Default] : ap-northeast-1
+      # Asia Pacific (Singapore)       : ap-southeast-1
+      # US-East (Virginia)             : us-east-1
+      # US-West (Oregon)               : us-west-2
+      # US-West (N.California)         : us-west-1
+      # EU-West (Ireland)              : eu-west-1
+      # South America (São Paulo)      : sa-east-1
 
       delay_seconds {delivery_delay_seconds}
 
@@ -71,16 +71,16 @@ Read events from from amazon SQS.
 
       # following attibutes are optional
     　
-      sqs_endpoint {endpointURL}
+      region {your_region}
 
-      ### endpoint list ###
-      # Asia Pacific (Tokyo) [Default] : sqs.ap-northeast-1.amazonaws.com
-      # Asia Pacific (Singapore)       : sqs.ap-southeast-1.amazonaws.com
-      # US-East (Virginia)             : sqs.us-east-1.amazonaws.com
-      # US-West (Oregon)               : sqs.us-west-2.amazonaws.com
-      # US-West (N.California)         : sqs.us-west-1.amazonaws.com
-      # EU-West (Ireland)              : sqs.eu-west-1.amazonaws.com
-      # South America (São Paulo)      : sns.sa-east-1.amazonaws.com
+      ### region list ###
+      # Asia Pacific (Tokyo) [Default] : ap-northeast-1
+      # Asia Pacific (Singapore)       : ap-southeast-1
+      # US-East (Virginia)             : us-east-1
+      # US-West (Oregon)               : us-west-2
+      # US-West (N.California)         : us-west-1
+      # EU-West (Ireland)              : eu-west-1
+      # South America (São Paulo)      : sa-east-1
 
       receive_interval {receive_interval_seconds}
 
@@ -88,6 +88,8 @@ Read events from from amazon SQS.
 
       wait_time_seconds {receive_message_wait_time_seconds}
 
+      delete_message {delete_message_after_receiving}
+
     </source>
 
 == Tool

data/Rakefile

@@ -1,9 +1,9 @@
 require 'rake'
 require 'rake/testtask'
 require 'rake/clean'
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new("spec")
+RSpec::Core::RakeTask.new('spec')
 
-task :default => [:build]
+task default: [:build]

data/VERSION

@@ -1 +1 @@
-1.8.0
+2.0.0

data/lib/fluent/plugin/in_sqs.rb

@@ -1,46 +1,49 @@
-module Fluent
-
-  require 'aws-sdk-v1'
+require 'fluent/input'
+require 'aws-sdk'
 
+module Fluent
   class SQSInput < Input
     Plugin.register_input('sqs', self)
 
-    unless method_defined?(:router)
-      define_method("router") { Fluent::Engine }
-    end
+    define_method('router') { Fluent::Engine } unless method_defined?(:router)
 
-    def initialize
-      super
-    end
-
-    config_param :aws_key_id, :string, :default => nil, :secret => true
-    config_param :aws_sec_key, :string, :default => nil, :secret => true
+    config_param :aws_key_id, :string, default: nil, secret: true
+    config_param :aws_sec_key, :string, default: nil, secret: true
     config_param :tag, :string
-    config_param :sqs_endpoint, :string, :default => 'sqs.ap-northeast-1.amazonaws.com'
-    config_param :sqs_url, :string
-    config_param :receive_interval, :time, :default => 0.1
-    config_param :max_number_of_messages, :integer, :default => 10
-    config_param :wait_time_seconds, :integer, :default => 10
+    config_param :region, :string, default: 'ap-northeast-1'
+    config_param :sqs_url, :string, default: nil
+    config_param :receive_interval, :time, default: 0.1
+    config_param :max_number_of_messages, :integer, default: 10
+    config_param :wait_time_seconds, :integer, default: 10
+    config_param :visibility_timeout, :integer, default: nil
+    config_param :delete_message, :bool, default: false
+    config_param :stub_responses, :bool, default: false
 
     def configure(conf)
       super
 
+      Aws.config = {
+        access_key_id: @aws_key_id,
+        secret_access_key: @aws_sec_key,
+        region: @region
+      }
     end
 
     def start
       super
 
-      AWS.config(
-        :access_key_id => @aws_key_id,
-        :secret_access_key => @aws_sec_key
-        )
-
-      @queue = AWS::SQS.new(:sqs_endpoint => @sqs_endpoint).queues[@sqs_url]
-
       @finished = false
       @thread = Thread.new(&method(:run_periodic))
     end
 
+    def client
+      @client ||= Aws::SQS::Client.new(stub_responses: @stub_responses)
+    end
+
+    def queue
+      @queue ||= Aws::SQS::Resource.new(client: client).queue(@sqs_url)
+    end
+
     def shutdown
       super
 
@@ -50,27 +53,39 @@ module Fluent
 
     def run_periodic
       until @finished
-        begin
-          sleep @receive_interval
-          @queue.receive_message(
-            :limit => @max_number_of_messages,
-            :wait_time_seconds => @wait_time_seconds
-          ) do |message|
-            record = {}
-            record['body'] = message.body.to_s
-            record['handle'] = message.handle.to_s
-            record['id'] = message.id.to_s
-            record['md5'] = message.md5.to_s
-            record['url'] = message.queue.url.to_s
-            record['sender_id'] = message.sender_id.to_s
-
-            router.emit(@tag, Time.now.to_i, record)
-          end
-        rescue
-          $log.error "failed to emit or receive", :error => $!.to_s, :error_class => $!.class.to_s
-          $log.warn_backtrace $!.backtrace
-        end
+        sleep @receive_interval
+        run
+      end
+    end
+
+    def run
+      queue.receive_messages(
+        max_number_of_messages: @max_number_of_messages,
+        wait_time_seconds: @wait_time_seconds,
+        visibility_timeout: @visibility_timeout
+      ).each do |message|
+        record = parse_message(message)
+
+        message.delete if @delete_message
+
+        router.emit(@tag, Time.now.to_i, record)
       end
+    rescue
+      $log.error 'failed to emit or receive', error: $ERROR_INFO.to_s, error_class: $ERROR_INFO.class.to_s
+      $log.warn_backtrace $ERROR_INFO.backtrace
+    end
+
+    private
+
+    def parse_message(message)
+      {
+        'body' => message.body.to_s,
+        'receipt_handle' => message.receipt_handle.to_s,
+        'message_id' => message.message_id.to_s,
+        'md5_of_body' => message.md5_of_body.to_s,
+        'queue_url' => message.queue_url.to_s,
+        'sender_id' => message.attributes['SenderId'].to_s
+      }
     end
   end
 end

data/lib/fluent/plugin/out_sqs.rb

@@ -1,98 +1,104 @@
-module Fluent
-
-    require 'aws-sdk-v1'
+require 'fluent/output'
+require 'aws-sdk'
 
-    SQS_BATCH_SEND_MAX_MSGS = 10
-    SQS_BATCH_SEND_MAX_SIZE = 262144
+module Fluent
+  SQS_BATCH_SEND_MAX_MSGS = 10
+  SQS_BATCH_SEND_MAX_SIZE = 262_144
+
+  class SQSOutput < BufferedOutput
+    Fluent::Plugin.register_output('sqs', self)
+
+    include SetTagKeyMixin
+    config_set_default :include_tag_key, false
+
+    include SetTimeKeyMixin
+    config_set_default :include_time_key, true
+
+    config_param :aws_key_id, :string, default: nil, secret: true
+    config_param :aws_sec_key, :string, default: nil, secret: true
+    config_param :queue_name, :string, default: nil
+    config_param :sqs_url, :string, default: nil
+    config_param :create_queue, :bool, default: true
+    config_param :region, :string, default: 'ap-northeast-1'
+    config_param :delay_seconds, :integer, default: 0
+    config_param :include_tag, :bool, default: true
+    config_param :tag_property_name, :string, default: '__tag'
+
+    def configure(conf)
+      super
+
+      Aws.config = {
+        access_key_id: @aws_key_id,
+        secret_access_key: @aws_sec_key,
+        region: @region
+      }
+    end
 
-    class SQSOutput < BufferedOutput
-        Fluent::Plugin.register_output('sqs', self)
+    def client
+      @client ||= Aws::SQS::Client.new
+    end
 
-        include SetTagKeyMixin
-        config_set_default :include_tag_key, false
+    def resource
+      @resource ||= Aws::SQS::Resource.new(client: client)
+    end
 
-        include SetTimeKeyMixin
-        config_set_default :include_time_key, true
+    def queue
+      return @queue if @queue
 
-        config_param :aws_key_id, :string, :default => nil, :secret => true
-        config_param :aws_sec_key, :string, :default => nil, :secret => true
-        config_param :queue_name, :string, :default => nil
-        config_param :sqs_url, :string, :default => nil
-        config_param :create_queue, :bool, :default => true
-        config_param :sqs_endpoint, :string, :default => 'sqs.ap-northeast-1.amazonaws.com'
-        config_param :delay_seconds, :integer, :default => 0
-        config_param :include_tag, :bool, :default => true
-        config_param :tag_property_name, :string, :default => '__tag'
+      @queue = if @create_queue && @queue_name
+                 resource.create_queue(queue_name: @queue_name)
+               else
+                 @queue = if @sqs_url
+                            resource.queue(@sqs_url)
+                          else
+                            resource.get_queue_by_name(queue_name: @queue_name)
+                          end
+               end
 
-        def configure(conf)
-            super
-        end
+      @queue
+    end
 
-        def start
-            super
+    def format(tag, _time, record)
+      record[@tag_property_name] = tag if @include_tag
 
-            AWS.config(
-                :access_key_id => @aws_key_id,
-                :secret_access_key => @aws_sec_key)
+      record.to_msgpack
+    end
 
-            @sqs_endpoint = @sqs_url.gsub(/https:\/\/(.*?)\/.*/, '\1') if @sqs_url and not @sqs_endpoint
+    def write(chunk)
+      batch_records = []
+      batch_size = 0
+      send_batches = [batch_records]
 
-            @sqs = AWS::SQS.new(
-                :sqs_endpoint => @sqs_endpoint)
+      chunk.msgpack_each do |record|
+        body = Yajl.dump(record)
+        batch_size += body.bytesize
 
-            if @create_queue and @queue_name then
-                @queue = @sqs.queues.create(@queue_name)
-            else
-                if @sqs_url # retrive queue by url
-                  @queue = @sqs.queues[@sqs_url]
-                else
-                  @queue = @sqs.queues.named(@queue_name)
-                end
-            end
+        if batch_size > SQS_BATCH_SEND_MAX_SIZE ||
+           batch_records.length >= SQS_BATCH_SEND_MAX_MSGS
+          batch_records = []
+          batch_size = body.bytesize
+          send_batches << batch_records
         end
 
-        def shutdown
-            super
+        if batch_size > SQS_BATCH_SEND_MAX_SIZE
+          log.warn 'Could not push message to SQS, payload exceeds ' \
+                   "#{SQS_BATCH_SEND_MAX_SIZE} bytes.  " \
+                   "(Truncated message: #{body[0..200]})"
+        else
+          batch_records << { id: generate_id, message_body: body, delay_seconds: @delay_seconds }
         end
+      end
 
-        def format(tag, time, record)
-            if @include_tag then
-                record[@tag_property_name] = tag
-            end
-
-            record.to_msgpack
+      until send_batches.length <= 0
+        records = send_batches.shift
+        until records.length <= 0
+          queue.send_messages(entries: records.slice!(0..9))
         end
+      end
+    end
 
-        def write(chunk)
-            batch_records = []
-            batch_size = 0
-            send_batches = [batch_records]
-
-            chunk.msgpack_each do |record|
-                body = Yajl.dump(record)
-                batch_size += body.bytesize
-                if batch_size > SQS_BATCH_SEND_MAX_SIZE ||
-                        batch_records.length >= SQS_BATCH_SEND_MAX_MSGS then
-                    batch_records = []
-                    batch_size = body.bytesize
-                    send_batches << batch_records
-                end
-
-                if batch_size > SQS_BATCH_SEND_MAX_SIZE then
-                    log.warn "Could not push message to SQS, payload exceeds "\
-                        "#{SQS_BATCH_SEND_MAX_SIZE} bytes.  "\
-                        "(Truncated message: #{body[0..200]})"
-                else
-                    batch_records << { :message_body => body, :delay_seconds => @delay_seconds }
-                end
-            end
-
-            until send_batches.length <= 0 do
-                records = send_batches.shift
-                until records.length <= 0 do
-                    @queue.batch_send(records.slice!(0..9))
-                end
-            end
-        end
+    def generate_id
+      @tag_property_name + Time.now.to_i.to_s
     end
+  end
 end

data/spec/lib/fluent/plugin/in_sqs_spec.rb

@@ -1,113 +1,120 @@
 require 'spec_helper'
+require 'fluent/plugin/in_sqs'
 
-describe do
-  let(:driver) {
-    AWS.stub!
+describe Fluent::SQSInput do
+  let(:driver) do
     Fluent::Test.setup
     Fluent::Test::InputTestDriver.new(Fluent::SQSInput).configure(config)
-  }
-  let(:instance) {driver.instance}
+  end
+  subject { driver.instance }
 
-  describe 'config' do
-    let(:config) {
-      %[
+  describe '#configure' do
+    let(:config) do
+      %(
          aws_key_id AWS_KEY_ID
          aws_sec_key AWS_SEC_KEY
-         tag     TAG
-         sqs_url SQS_URL
+         tag TAG
+         region REGION
+         sqs_url http://SQS_URL
+         receive_interval 1
          max_number_of_messages 10
          wait_time_seconds 10
-      ]
-    }
-    
-    context do
-      subject {instance.aws_key_id}
-      it{should == 'AWS_KEY_ID'}
-    end
-
-    context do
-      subject {instance.aws_sec_key}
-      it{should == 'AWS_SEC_KEY'}
+         visibility_timeout 1
+         delete_message true
+         stub_responses true
+      )
     end
 
-    context do
-      subject {instance.tag}
-      it{should == 'TAG'}
+    context 'fluentd input configuration settings' do
+      it { expect(subject.aws_key_id).to eq('AWS_KEY_ID') }
+      it { expect(subject.aws_sec_key).to eq('AWS_SEC_KEY') }
+      it { expect(subject.tag).to eq('TAG') }
+      it { expect(subject.region).to eq('REGION') }
+      it { expect(subject.sqs_url).to eq('http://SQS_URL') }
+      it { expect(subject.receive_interval).to eq(1) }
+      it { expect(subject.max_number_of_messages).to eq(10) }
+      it { expect(subject.wait_time_seconds).to eq(10) }
+      it { expect(subject.visibility_timeout).to eq(1) }
+      it { expect(subject.delete_message).to eq(true) }
+      it { expect(subject.stub_responses).to eq(true) }
     end
 
-    context do
-      subject {instance.sqs_url}
-      it{should == 'SQS_URL'}
-    end
-
-    context do
-      subject {instance.receive_interval}
-      it{should == 0.1}
-    end
+    context 'AWS configuration settings' do
+      subject { Aws.config }
 
-    context do
-      subject {instance.max_number_of_messages}
-      it{should == 10}
-    end
+      before { driver.instance }
 
-    context do
-      subject {instance.wait_time_seconds}
-      it{should == 10}
+      it { expect(subject[:access_key_id]).to eq('AWS_KEY_ID') }
+      it { expect(subject[:secret_access_key]).to eq('AWS_SEC_KEY') }
+      it { expect(subject[:region]).to eq('REGION') }
     end
   end
-  
-  describe 'emit' do
-    let(:message) do
-      { 'body' => 'body',
-        'handle' => 'handle',
-        'id' => 'id',
-        'md5' => 'md5',
-        'url' => 'url',
-        'sender_id' => 'sender_id'
+
+  describe '#run' do
+    let(:message_attributes) do
+      {
+        body: 'body',
+        receipt_handle: 'receipt_handle',
+        message_id: 'message_id',
+        md5_of_body: 'md5_of_body',
+        queue_url: 'queue_url',
+        attributes: { 'SenderId' => 'sender_id' }
       }
     end
-    let(:emmits) {
-      allow(Time).to receive(:now).and_return(0)
+    let(:queue) { double(:queue, receive_messages: true) }
+    let(:message) { double(:message, **message_attributes.merge(delete: nil)) }
+    let(:messages) { [message] }
 
-      class AWS::SQS::Queue
-        def receive_message(opts)
-          yield OpenStruct.new(
-            { 'body' => 'body',
-              'handle' => 'handle',
-              'id' => 'id',
-              'md5' => 'md5',
-              'queue' => OpenStruct.new(:url => 'url'),
-              'sender_id' => 'sender_id',
-              'sent_at' => 0
-            })
-        end
+    context 'with no delete messages param' do
+      let(:config) do
+        %(
+         tag TAG
+         max_number_of_messages 10
+         wait_time_seconds 10
+         visibility_timeout 1
+         delete_message false
+      )
       end
-      expect_any_instance_of(AWS::SQS::Queue).to receive(:receive_message).with({:limit => 10, :wait_time_seconds=>10}).at_least(:once).and_call_original
 
-      d = driver
-      d.run do
-        sleep 2
+      before do
+        allow(subject).to receive(:queue) { queue }
       end
 
-      d.emits
-    }
-
-    context do
-      let(:config) {
-        %[
-           aws_key_id AWS_KEY_ID
-           aws_sec_key AWS_SEC_KEY
-           tag     TAG
-           sqs_url SQS_URL
-           max_number_of_messages 10
-           wait_time_seconds 10
-        ]
-      }
+      it 'parse through messages and emit it' do
+        expect(queue).to receive(:receive_messages)
+          .with(max_number_of_messages: 10, wait_time_seconds: 10, visibility_timeout: 1) { messages }
+        expect(subject).to receive(:parse_message).with(message) { message_attributes }
+        expect(message).not_to receive(:delete)
+        expect(subject.router).to receive(:emit).with('TAG', kind_of(Integer), message_attributes)
 
-      subject {emmits.first}
-      it{should ==  ['TAG', 0, message]}
+        subject.run
+      end
     end
 
-  end
+    context 'with no delete messages param' do
+      let(:config) do
+        %(
+         tag TAG
+         max_number_of_messages 10
+         wait_time_seconds 10
+         visibility_timeout 1
+         delete_message true
+      )
+      end
 
+      before do
+        allow(subject).to receive(:queue) { queue }
+      end
+
+      it 'parse through messages and emit it' do
+        expect(queue).to receive(:receive_messages)
+          .with(max_number_of_messages: 10, wait_time_seconds: 10, visibility_timeout: 1) { messages }
+        expect(subject).to receive(:parse_message).with(message) { message_attributes }
+        expect(message).to receive(:delete)
+        expect(subject.router).to receive(:emit).with('TAG', kind_of(Integer), message_attributes)
+
+        subject.run
+      end
+    end
+  end
 end

data/spec/lib/fluent/plugin/out_sqs_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+require 'fluent/plugin/out_sqs'
+
+describe Fluent::SQSOutput do
+  let(:driver) { Fluent::Test::BufferedOutputTestDriver.new(Fluent::SQSOutput) }
+  subject { driver.instance }
+
+  before do
+    Fluent::Test.setup
+    driver.configure(config)
+  end
+
+  describe '#configure' do
+    let(:config) do
+      %(
+         aws_key_id AWS_KEY_ID
+         aws_sec_key AWS_SEC_KEY
+         queue_name QUEUE_NAME
+         sqs_url http://SQS_URL
+         create_queue false
+         region REGION
+         delay_seconds 1
+         include_tag false
+         tag_property_name TAG_PROPERTY_NAME
+      )
+    end
+
+    context 'fluentd output configuration settings' do
+      it { expect(subject.aws_key_id).to eq('AWS_KEY_ID') }
+      it { expect(subject.aws_sec_key).to eq('AWS_SEC_KEY') }
+      it { expect(subject.queue_name).to eq('QUEUE_NAME') }
+      it { expect(subject.sqs_url).to eq('http://SQS_URL') }
+      it { expect(subject.create_queue).to eq(false) }
+      it { expect(subject.region).to eq('REGION') }
+      it { expect(subject.delay_seconds).to eq(1) }
+      it { expect(subject.include_tag).to eq(false) }
+      it { expect(subject.tag_property_name).to eq('TAG_PROPERTY_NAME') }
+    end
+
+    context 'AWS configuration settings' do
+      subject { Aws.config }
+
+      before { driver.instance }
+
+      it { expect(subject[:access_key_id]).to eq('AWS_KEY_ID') }
+      it { expect(subject[:secret_access_key]).to eq('AWS_SEC_KEY') }
+      it { expect(subject[:region]).to eq('REGION') }
+    end
+  end
+
+  describe '#queue' do
+    context 'when create_queue and queue_name are set' do
+      let(:config) do
+        %(
+         queue_name QUEUE_NAME
+         create_queue true
+        )
+      end
+      let(:resource_instance) { double(:resource_instance) }
+      let(:queue) { double(:queue) }
+
+      before { allow(subject).to receive(:resource) { resource_instance } }
+
+      it 'calls on create_queue with queue_name' do
+        expect(resource_instance).to receive(:create_queue).with(queue_name: 'QUEUE_NAME') { queue }
+
+        expect(subject.queue).to eq(queue)
+      end
+    end
+
+    context 'when create_queue is not set but a sqs_url is' do
+      let(:config) do
+        %(
+         queue_name QUEUE_NAME
+         create_queue false
+         sqs_url SQS_URL
+        )
+      end
+      let(:resource_instance) { double(:resource_instance) }
+      let(:queue) { double(:queue) }
+
+      before { allow(subject).to receive(:resource) { resource_instance } }
+
+      it 'gets queue from sqs_url' do
+        expect(resource_instance).to receive(:queue).with('SQS_URL') { queue }
+
+        expect(subject.queue).to eq(queue)
+      end
+    end
+
+    context 'when create_queue is not set nor sqs_url' do
+      let(:config) do
+        %(
+         queue_name QUEUE_NAME
+         create_queue false
+        )
+      end
+      let(:resource_instance) { double(:resource_instance) }
+      let(:queue) { double(:queue) }
+
+      before { allow(subject).to receive(:resource) { resource_instance } }
+
+      it 'gets queue from queue_name' do
+        expect(resource_instance).to receive(:get_queue_by_name).with(queue_name: 'QUEUE_NAME') { queue }
+
+        expect(subject.queue).to eq(queue)
+      end
+    end
+  end
+
+  describe '#write' do
+    let(:config) do
+      %(
+       queue_name QUEUE_NAME
+      )
+    end
+
+    let(:record) { {} }
+    let(:body) { double(:body, bytesize: 1) }
+
+    it 'send_messages to queue' do
+      allow(Yajl).to receive(:dump).with(record) { body }
+
+      expect(subject.queue).to receive(:send_messages).with(entries: [{ id: kind_of(String), message_body: body, delay_seconds: 0 }])
+
+      driver.emit(record).run
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
@@ -18,7 +17,6 @@ RSpec.configure do |config|
   require 'fluent/load'
   require 'fluent/test'
 
-  require 'fluent/plugin/in_sqs'
   require 'ostruct'
   require 'pry'
   require 'rr'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-sqs
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Yuri Odagiri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-09 00:00:00.000000000 Z
+date: 2016-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -31,19 +31,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: '0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -170,6 +170,7 @@ files:
 - lib/fluent/plugin/in_sqs.rb
 - lib/fluent/plugin/out_sqs.rb
 - spec/lib/fluent/plugin/in_sqs_spec.rb
+- spec/lib/fluent/plugin/out_sqs_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ixixi/fluent-plugin-sqs
 licenses:
@@ -191,10 +192,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 3
 summary: Amazon SQS input/output plugin for Fluent event collector
 test_files:
 - spec/lib/fluent/plugin/in_sqs_spec.rb
+- spec/lib/fluent/plugin/out_sqs_spec.rb
 - spec/spec_helper.rb