fluent-plugin-cloudwatch-logs 0.7.3 → 0.7.4

data/test/plugin/test_out_cloudwatch_logs.rb

@@ -3,6 +3,7 @@ require 'test_helper'
 require 'fileutils'
 require 'fluent/test/driver/output'
 require 'fluent/test/helpers'
+require 'fluent/plugin/out_cloudwatch_logs'
 
 class CloudwatchLogsOutputTest < Test::Unit::TestCase
   include CloudwatchLogsTestHelper
@@ -10,698 +11,705 @@ class CloudwatchLogsOutputTest < Test::Unit::TestCase
 
   def setup
     Fluent::Test.setup
-    require 'fluent/plugin/out_cloudwatch_logs'
   end
 
-  def teardown
-    clear_log_group
+  sub_test_case "configure" do
+    def test_configure
+      d = create_driver(<<-EOC)
+        @type cloudwatch_logs
+        aws_key_id test_id
+        aws_sec_key test_key
+        region us-east-1
+        log_group_name test_group
+        log_stream_name test_stream
+        auto_create_stream false
+        log_group_aws_tags { "tagkey": "tagvalue", "tagkey_2": "tagvalue_2"}
+        retention_in_days 5
+        message_keys fluentd, aws, cloudwatch
+      EOC
+
+      assert_equal('test_id', d.instance.aws_key_id)
+      assert_equal('test_key', d.instance.aws_sec_key)
+      assert_equal('us-east-1', d.instance.region)
+      assert_equal('test_group', d.instance.log_group_name)
+      assert_equal('test_stream', d.instance.log_stream_name)
+      assert_equal(false, d.instance.auto_create_stream)
+      assert_equal("tagvalue", d.instance.log_group_aws_tags.fetch("tagkey"))
+      assert_equal("tagvalue_2", d.instance.log_group_aws_tags.fetch("tagkey_2"))
+      assert_equal(5, d.instance.retention_in_days)
+      assert_equal(:yajl, d.instance.json_handler)
+      assert_equal(["fluentd","aws","cloudwatch"], d.instance.message_keys)
+    end
   end
 
+  sub_test_case "real world" do
+    def setup
+      omit if ENV["CI"] == "true"
+    end
+
+    def teardown
+      return if ENV["CI"] == "true"
+      clear_log_group
+    end
 
-  def test_configure
-    d = create_driver(<<-EOC)
-      @type cloudwatch_logs
-      aws_key_id test_id
-      aws_sec_key test_key
-      region us-east-1
-      log_group_name test_group
-      log_stream_name test_stream
-      auto_create_stream false
-      log_group_aws_tags { "tagkey": "tagvalue", "tagkey_2": "tagvalue_2"}
-      retention_in_days 5
-      message_keys fluentd, aws, cloudwatch
-    EOC
+    def test_write
+      new_log_stream
 
-    assert_equal('test_id', d.instance.aws_key_id)
-    assert_equal('test_key', d.instance.aws_sec_key)
-    assert_equal('us-east-1', d.instance.region)
-    assert_equal('test_group', d.instance.log_group_name)
-    assert_equal('test_stream', d.instance.log_stream_name)
-    assert_equal(false, d.instance.auto_create_stream)
-    assert_equal("tagvalue", d.instance.log_group_aws_tags.fetch("tagkey"))
-    assert_equal("tagvalue_2", d.instance.log_group_aws_tags.fetch("tagkey_2"))
-    assert_equal(5, d.instance.retention_in_days)
-    assert_equal(:yajl, d.instance.json_handler)
-    assert_equal(["fluentd","aws","cloudwatch"], d.instance.message_keys)
-  end
+      d = create_driver
+      time = event_time
+      d.run(default_tag: fluentd_tag, flush: true) do
+        d.feed(time, {'cloudwatch' => 'logs1'})
+        # Addition converts EventTime to seconds
+        d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      end
 
-  def test_write
-    new_log_stream
+      sleep 10
 
-    d = create_driver
-    time = event_time
-    d.run(default_tag: fluentd_tag, flush: true) do
-      d.feed(time, {'cloudwatch' => 'logs1'})
-      # Addition converts EventTime to seconds
-      d.feed(time + 1, {'cloudwatch' => 'logs2'})
-    end
+      logs = d.logs
+      events = get_log_events
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('{"cloudwatch":"logs1"}', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('{"cloudwatch":"logs2"}', events[1].message)
 
-    sleep 10
+      assert(logs.any?{|log| log.include?("Called PutLogEvents API") })
+    end
 
-    logs = d.logs
-    events = get_log_events
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('{"cloudwatch":"logs1"}', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('{"cloudwatch":"logs2"}', events[1].message)
+    def test_write_utf8
+      new_log_stream
 
-    assert(logs.any?{|log| log.include?("Called PutLogEvents API") })
-  end
+      d = create_driver
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, { 'cloudwatch' => 'これは日本語です'.force_encoding('UTF-8')})
+      end
 
-  def test_write_utf8
-    new_log_stream
+      sleep 10
 
-    d = create_driver
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, { 'cloudwatch' => 'これは日本語です'.force_encoding('UTF-8')})
+      events = get_log_events
+      assert_equal(1, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('{"cloudwatch":"これは日本語です"}', events[0].message)
     end
 
-    sleep 10
+    def test_write_24h_apart
+      new_log_stream
 
-    events = get_log_events
-    assert_equal(1, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('{"cloudwatch":"これは日本語です"}', events[0].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+        utc
+      EOC
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time - 60 * 60 * 25, {'cloudwatch' => 'logs0'})
+        d.feed(time, {'cloudwatch' => 'logs1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      end
 
-  def test_write_24h_apart
-    new_log_stream
+      sleep 10
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    log_group_name #{log_group_name}
-    log_stream_name #{log_stream_name}
-    utc
-    EOC
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time - 60 * 60 * 25, {'cloudwatch' => 'logs0'})
-      d.feed(time, {'cloudwatch' => 'logs1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      events = get_log_events
+      assert_equal(3, events.size)
+      assert_equal((time.to_i - 60 * 60 * 25) * 1000, events[0].timestamp)
+      assert_equal('{"cloudwatch":"logs0"}', events[0].message)
+      assert_equal((time.to_f * 1000).floor, events[1].timestamp)
+      assert_equal('{"cloudwatch":"logs1"}', events[1].message)
+      assert_equal((time.to_i + 1) * 1000, events[2].timestamp)
+      assert_equal('{"cloudwatch":"logs2"}', events[2].message)
     end
 
-    sleep 10
+    def test_write_with_message_keys
+      new_log_stream
 
-    events = get_log_events
-    assert_equal(3, events.size)
-    assert_equal((time.to_i - 60 * 60 * 25) * 1000, events[0].timestamp)
-    assert_equal('{"cloudwatch":"logs0"}', events[0].message)
-    assert_equal((time.to_f * 1000).floor, events[1].timestamp)
-    assert_equal('{"cloudwatch":"logs1"}', events[1].message)
-    assert_equal((time.to_i + 1) * 1000, events[2].timestamp)
-    assert_equal('{"cloudwatch":"logs2"}', events[2].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        message_keys message,cloudwatch
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+      EOC
 
-  def test_write_with_message_keys
-    new_log_stream
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    message_keys message,cloudwatch
-    log_group_name #{log_group_name}
-    log_stream_name #{log_stream_name}
-    EOC
+      sleep 10
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 logs1', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 logs2', events[1].message)
     end
 
-    sleep 10
+    def test_write_with_max_message_length
+      new_log_stream
 
-    events = get_log_events
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 logs1', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 logs2', events[1].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        message_keys message,cloudwatch
+        max_message_length 10
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+      EOC
 
-  def test_write_with_max_message_length
-    new_log_stream
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    message_keys message,cloudwatch
-    max_message_length 10
-    log_group_name #{log_group_name}
-    log_stream_name #{log_stream_name}
-    EOC
+      sleep 10
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 l', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 l', events[1].message)
     end
 
-    sleep 10
+    def test_write_use_tag_as_group
+      new_log_stream
 
-    events = get_log_events
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 l', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 l', events[1].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        message_keys message,cloudwatch
+        use_tag_as_group true
+        log_stream_name #{log_stream_name}
+      EOC
 
-  def test_write_use_tag_as_group
-    new_log_stream
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    message_keys message,cloudwatch
-    use_tag_as_group true
-    log_stream_name #{log_stream_name}
-    EOC
+      sleep 10
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events(fluentd_tag)
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 logs1', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 logs2', events[1].message)
     end
 
-    sleep 10
+    def test_write_use_tag_as_stream
+      new_log_stream
 
-    events = get_log_events(fluentd_tag)
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 logs1', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 logs2', events[1].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        message_keys message,cloudwatch
+        use_tag_as_stream true
+        log_group_name #{log_group_name}
+      EOC
 
-  def test_write_use_tag_as_stream
-    new_log_stream
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    message_keys message,cloudwatch
-    use_tag_as_stream true
-    log_group_name #{log_group_name}
-    EOC
+      sleep 10
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events(log_group_name, fluentd_tag)
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 logs1', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 logs2', events[1].message)
     end
 
-    sleep 10
+    def test_write_use_placeholders
+      new_log_stream
+
+      config = {'@type' => 'cloudwatch_logs',
+        'auto_create_stream' => true,
+        'message_keys' => ["message","cloudwatch"],
+        'log_stream_name' => "${tag}",
+        'log_group_name' => log_group_name}
+      config.merge!(config_elementify(aws_key_id)) if aws_key_id
+      config.merge!(config_elementify(aws_sec_key)) if aws_sec_key
+      config.merge!(config_elementify(region)) if region
+      config.merge!(config_elementify(endpoint)) if endpoint
+
+      d = create_driver(
+        Fluent::Config::Element.new('ROOT', '', config,[
+          Fluent::Config::Element.new('buffer', 'tag, time', {
+            '@type' => 'memory',
+            'timekey' => 3600
+          }, [])
+        ])
+      )
+
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    events = get_log_events(log_group_name, fluentd_tag)
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 logs1', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 logs2', events[1].message)
-  end
+      sleep 10
 
-  def test_write_use_placeholders
-    new_log_stream
-
-    config = {'@type' => 'cloudwatch_logs',
-              'auto_create_stream' => true,
-              'message_keys' => ["message","cloudwatch"],
-              'log_stream_name' => "${tag}",
-              'log_group_name' => log_group_name}
-    config.merge!(config_elementify(aws_key_id)) if aws_key_id
-    config.merge!(config_elementify(aws_sec_key)) if aws_sec_key
-    config.merge!(config_elementify(region)) if region
-    config.merge!(config_elementify(endpoint)) if endpoint
-
-    d = create_driver(
-      Fluent::Config::Element.new('ROOT', '', config,[
-                                    Fluent::Config::Element.new('buffer', 'tag, time', {
-                                                                  '@type' => 'memory',
-                                                                  'timekey' => 3600
-                                                                }, [])
-                                  ])
-    )
-
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events(log_group_name, fluentd_tag)
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 logs1', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 logs2', events[1].message)
     end
 
-    sleep 10
+    def test_write_use_placeholders_parts
+      new_log_stream
+
+      config = {'@type' => 'cloudwatch_logs',
+        'auto_create_stream' => true,
+        'message_keys' => ["message","cloudwatch"],
+        'log_stream_name' => "${tag[0]}-${tag[1]}-${tag[2]}-${tag[3]}",
+        'log_group_name' => log_group_name}
+      config.merge!(config_elementify(aws_key_id)) if aws_key_id
+      config.merge!(config_elementify(aws_sec_key)) if aws_sec_key
+      config.merge!(config_elementify(region)) if region
+      config.merge!(config_elementify(endpoint)) if endpoint
+
+      d = create_driver(
+        Fluent::Config::Element.new('ROOT', '', config, [
+          Fluent::Config::Element.new('buffer', 'tag, time', {
+            '@type' => 'memory',
+            'timekey' => 3600
+          }, [])
+        ])
+      )
+
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    events = get_log_events(log_group_name, fluentd_tag)
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 logs1', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 logs2', events[1].message)
-  end
+      sleep 10
 
-  def test_write_use_placeholders_parts
-    new_log_stream
-
-    config = {'@type' => 'cloudwatch_logs',
-              'auto_create_stream' => true,
-              'message_keys' => ["message","cloudwatch"],
-              'log_stream_name' => "${tag[0]}-${tag[1]}-${tag[2]}-${tag[3]}",
-              'log_group_name' => log_group_name}
-    config.merge!(config_elementify(aws_key_id)) if aws_key_id
-    config.merge!(config_elementify(aws_sec_key)) if aws_sec_key
-    config.merge!(config_elementify(region)) if region
-    config.merge!(config_elementify(endpoint)) if endpoint
-
-    d = create_driver(
-      Fluent::Config::Element.new('ROOT', '', config,[
-                                    Fluent::Config::Element.new('buffer', 'tag, time', {
-                                                                  '@type' => 'memory',
-                                                                  'timekey' => 3600
-                                                                }, [])
-                                  ])
-    )
-
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events(log_group_name, 'fluent-plugin-cloudwatch-test')
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 logs1', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 logs2', events[1].message)
     end
 
-    sleep 10
+    def test_write_use_time_placeholders
+      new_log_stream
+
+      config = {'@type' => 'cloudwatch_logs',
+        'auto_create_stream' => true,
+        'message_keys' => ["message","cloudwatch"],
+        'log_stream_name' => "fluent-plugin-cloudwatch-test-%Y%m%d",
+        'log_group_name' => log_group_name}
+      config.merge!(config_elementify(aws_key_id)) if aws_key_id
+      config.merge!(config_elementify(aws_sec_key)) if aws_sec_key
+      config.merge!(config_elementify(region)) if region
+      config.merge!(config_elementify(endpoint)) if endpoint
+
+      d = create_driver(
+        Fluent::Config::Element.new('ROOT', '', config,[
+          Fluent::Config::Element.new('buffer', 'tag, time', {
+            '@type' => 'memory',
+            'timekey' => 3600
+          }, [])
+        ])
+      )
+
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      end
 
-    events = get_log_events(log_group_name, 'fluent-plugin-cloudwatch-test')
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 logs1', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 logs2', events[1].message)
-  end
+      sleep 10
 
-  def test_write_use_time_placeholders
-    new_log_stream
-
-    config = {'@type' => 'cloudwatch_logs',
-              'auto_create_stream' => true,
-              'message_keys' => ["message","cloudwatch"],
-              'log_stream_name' => "fluent-plugin-cloudwatch-test-%Y%m%d",
-              'log_group_name' => log_group_name}
-    config.merge!(config_elementify(aws_key_id)) if aws_key_id
-    config.merge!(config_elementify(aws_sec_key)) if aws_sec_key
-    config.merge!(config_elementify(region)) if region
-    config.merge!(config_elementify(endpoint)) if endpoint
-
-    d = create_driver(
-      Fluent::Config::Element.new('ROOT', '', config,[
-                                    Fluent::Config::Element.new('buffer', 'tag, time', {
-                                                                  '@type' => 'memory',
-                                                                  'timekey' => 3600
-                                                                }, [])
-                                  ])
-    )
-
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2', 'message' => 'message2'})
+      events = get_log_events(log_group_name, "fluent-plugin-cloudwatch-test-#{Time.at(time).strftime("%Y%m%d")}")
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal('message1 logs1', events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal('message2 logs2', events[1].message)
     end
 
-    sleep 10
+    def test_include_time_key
+      new_log_stream
 
-    events = get_log_events(log_group_name, "fluent-plugin-cloudwatch-test-#{Time.at(time).strftime("%Y%m%d")}")
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal('message1 logs1', events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal('message2 logs2', events[1].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        include_time_key true
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+        utc
+      EOC
 
-  def test_include_time_key
-    new_log_stream
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    include_time_key true
-    log_group_name #{log_group_name}
-    log_stream_name #{log_stream_name}
-    utc
-    EOC
+      sleep 10
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      events = get_log_events
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal("{\"cloudwatch\":\"logs1\",\"time\":\"#{Time.at(time.to_r).utc.strftime("%Y-%m-%dT%H:%M:%SZ")}\"}", events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal("{\"cloudwatch\":\"logs2\",\"time\":\"#{Time.at((time+1).to_r).utc.strftime("%Y-%m-%dT%H:%M:%SZ")}\"}", events[1].message)
     end
 
-    sleep 10
+    def test_include_time_key_localtime
+      new_log_stream
 
-    events = get_log_events
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal("{\"cloudwatch\":\"logs1\",\"time\":\"#{Time.at(time.to_r).utc.strftime("%Y-%m-%dT%H:%M:%SZ")}\"}", events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal("{\"cloudwatch\":\"logs2\",\"time\":\"#{Time.at((time+1).to_r).utc.strftime("%Y-%m-%dT%H:%M:%SZ")}\"}", events[1].message)
-  end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        include_time_key true
+        localtime true
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+      EOC
 
-  def test_include_time_key_localtime
-    new_log_stream
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1'})
+        d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    include_time_key true
-    localtime true
-    log_group_name #{log_group_name}
-    log_stream_name #{log_stream_name}
-    EOC
+      sleep 10
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1'})
-      d.feed(time + 1, {'cloudwatch' => 'logs2'})
+      events = get_log_events
+      assert_equal(2, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal("{\"cloudwatch\":\"logs1\",\"time\":\"#{Time.at(time.to_r).strftime("%Y-%m-%dT%H:%M:%S%:z")}\"}", events[0].message)
+      assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
+      assert_equal("{\"cloudwatch\":\"logs2\",\"time\":\"#{Time.at((time+1).to_r).to_time.strftime("%Y-%m-%dT%H:%M:%S%:z")}\"}", events[1].message)
     end
 
-    sleep 10
-
-    events = get_log_events
-    assert_equal(2, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal("{\"cloudwatch\":\"logs1\",\"time\":\"#{Time.at(time.to_r).strftime("%Y-%m-%dT%H:%M:%S%:z")}\"}", events[0].message)
-    assert_equal((time.to_i + 1) * 1000, events[1].timestamp)
-    assert_equal("{\"cloudwatch\":\"logs2\",\"time\":\"#{Time.at((time+1).to_r).to_time.strftime("%Y-%m-%dT%H:%M:%S%:z")}\"}", events[1].message)
-  end
-
-  def test_log_group_name_key_and_log_stream_name_key
-    new_log_stream
+    def test_log_group_name_key_and_log_stream_name_key
+      new_log_stream
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    log_group_name_key group_name_key
-    log_stream_name_key stream_name_key
-    @log_level debug
-    EOC
+      d = create_driver(<<-EOC)
+        #{default_config}
+        log_group_name_key group_name_key
+        log_stream_name_key stream_name_key
+        @log_level debug
+      EOC
 
-    stream1 = new_log_stream
-    stream2 = new_log_stream
+      stream1 = new_log_stream
+      stream2 = new_log_stream
 
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream1},
-      {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream2},
-      {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream1},
-    ]
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream1},
+        {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream2},
+        {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream1},
+      ]
 
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time + i, record)
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time + i, record)
+        end
       end
-    end
 
-    logs = d.logs
-    # Call API once for each stream
-    assert_equal(2, logs.select {|l| l =~ /Called PutLogEvents API/ }.size)
+      logs = d.logs
+      # Call API once for each stream
+      assert_equal(2, logs.select {|l| l =~ /Called PutLogEvents API/ }.size)
 
-    sleep 10
+      sleep 10
 
-    events = get_log_events(log_group_name, stream1)
-    assert_equal(2, events.size)
-    assert_equal(time.to_i * 1000, events[0].timestamp)
-    assert_equal((time.to_i + 2) * 1000, events[1].timestamp)
-    assert_equal(records[0], JSON.parse(events[0].message))
-    assert_equal(records[2], JSON.parse(events[1].message))
+      events = get_log_events(log_group_name, stream1)
+      assert_equal(2, events.size)
+      assert_equal(time.to_i * 1000, events[0].timestamp)
+      assert_equal((time.to_i + 2) * 1000, events[1].timestamp)
+      assert_equal(records[0], JSON.parse(events[0].message))
+      assert_equal(records[2], JSON.parse(events[1].message))
 
-    events = get_log_events(log_group_name, stream2)
-    assert_equal(1, events.size)
-    assert_equal((time.to_i + 1) * 1000, events[0].timestamp)
-    assert_equal(records[1], JSON.parse(events[0].message))
-  end
+      events = get_log_events(log_group_name, stream2)
+      assert_equal(1, events.size)
+      assert_equal((time.to_i + 1) * 1000, events[0].timestamp)
+      assert_equal(records[1], JSON.parse(events[0].message))
+    end
 
-  def test_remove_log_group_name_key_and_remove_log_stream_name_key
-    new_log_stream
+    def test_remove_log_group_name_key_and_remove_log_stream_name_key
+      new_log_stream
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    log_group_name_key group_name_key
-    log_stream_name_key stream_name_key
-    remove_log_group_name_key true
-    remove_log_stream_name_key true
-    EOC
-
-    time = event_time
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => log_stream_name})
-    end
+      d = create_driver(<<-EOC)
+        #{default_config}
+        log_group_name_key group_name_key
+        log_stream_name_key stream_name_key
+        remove_log_group_name_key true
+        remove_log_stream_name_key true
+      EOC
 
-    sleep 10
+      time = event_time
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => log_stream_name})
+      end
 
-    events = get_log_events(log_group_name, log_stream_name)
-    assert_equal(1, events.size)
-    assert_equal((time.to_f * 1000).floor, events[0].timestamp)
-    assert_equal({'cloudwatch' => 'logs1', 'message' => 'message1'}, JSON.parse(events[0].message))
-  end
+      sleep 10
 
-  def test_log_group_aws_tags
-    clear_log_group
+      events = get_log_events(log_group_name, log_stream_name)
+      assert_equal(1, events.size)
+      assert_equal((time.to_f * 1000).floor, events[0].timestamp)
+      assert_equal({'cloudwatch' => 'logs1', 'message' => 'message1'}, JSON.parse(events[0].message))
+    end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    auto_create_stream true
-    use_tag_as_stream true
-    log_group_name_key group_name_key
-    log_group_aws_tags {"tag1": "value1", "tag2": "value2"}
-    EOC
+    def test_log_group_aws_tags
+      clear_log_group
 
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name},
-      {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name},
-      {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name},
-    ]
+      d = create_driver(<<-EOC)
+        #{default_config}
+        auto_create_stream true
+        use_tag_as_stream true
+        log_group_name_key group_name_key
+        log_group_aws_tags {"tag1": "value1", "tag2": "value2"}
+      EOC
 
-    time = Time.now
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time.to_i + i, record)
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name},
+        {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name},
+        {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name},
+      ]
+
+      time = Time.now
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time.to_i + i, record)
+        end
       end
-    end
-
-    awstags = get_log_group_tags
-    assert_equal("value1", awstags.fetch("tag1"))
-    assert_equal("value2", awstags.fetch("tag2"))
-  end
 
-  def test_retention_in_days
-    clear_log_group
+      awstags = get_log_group_tags
+      assert_equal("value1", awstags.fetch("tag1"))
+      assert_equal("value2", awstags.fetch("tag2"))
+    end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    auto_create_stream true
-    use_tag_as_stream true
-    log_group_name_key group_name_key
-    retention_in_days 7
-    EOC
+    def test_retention_in_days
+      clear_log_group
 
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name},
-      {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name},
-      {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name},
-    ]
+      d = create_driver(<<-EOC)
+        #{default_config}
+        auto_create_stream true
+        use_tag_as_stream true
+        log_group_name_key group_name_key
+        retention_in_days 7
+      EOC
 
-    time = Time.now
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time.to_i + i, record)
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name},
+        {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name},
+        {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name},
+      ]
+
+      time = Time.now
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time.to_i + i, record)
+        end
       end
-    end
 
-    retention = get_log_group_retention_days
-    assert_equal(d.instance.retention_in_days, retention)
-  end
-
-  def test_invalid_retention_in_days
-    clear_log_group
+      retention = get_log_group_retention_days
+      assert_equal(d.instance.retention_in_days, retention)
+    end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    auto_create_stream true
-    use_tag_as_stream true
-    log_group_name_key group_name_key
-    retention_in_days 4
-    EOC
+    def test_invalid_retention_in_days
+      clear_log_group
 
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name},
-      {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name},
-      {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name},
-    ]
+      d = create_driver(<<-EOC)
+        #{default_config}
+        auto_create_stream true
+        use_tag_as_stream true
+        log_group_name_key group_name_key
+        retention_in_days 4
+      EOC
 
-    time = Time.now
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time.to_i + i, record)
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name},
+        {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name},
+        {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name},
+      ]
+
+      time = Time.now
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time.to_i + i, record)
+        end
       end
-    end
-
-    assert_match(/failed to set retention policy for Log group/, d.logs[0])
-  end
 
-  def test_log_group_aws_tags_key
-    clear_log_group
+      assert_match(/failed to set retention policy for Log group/, d.logs[0])
+    end
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    auto_create_stream true
-    use_tag_as_stream true
-    log_group_name_key group_name_key
-    log_group_aws_tags_key aws_tags
-    EOC
+    def test_log_group_aws_tags_key
+      clear_log_group
 
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}},
-      {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}},
-      {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}}
-    ]
+      d = create_driver(<<-EOC)
+        #{default_config}
+        auto_create_stream true
+        use_tag_as_stream true
+        log_group_name_key group_name_key
+        log_group_aws_tags_key aws_tags
+      EOC
 
-    time = Time.now
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time.to_i + i, record)
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}},
+        {'cloudwatch' => 'logs2', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}},
+        {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}}
+      ]
+
+      time = Time.now
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time.to_i + i, record)
+        end
       end
-    end
 
-    awstags = get_log_group_tags
-    assert_equal("value1", awstags.fetch("tag1"))
-    assert_equal("value2", awstags.fetch("tag2"))
-  end
+      awstags = get_log_group_tags
+      assert_equal("value1", awstags.fetch("tag1"))
+      assert_equal("value2", awstags.fetch("tag2"))
+    end
 
-  def test_log_group_aws_tags_key_same_group_diff_tags
-    clear_log_group
+    def test_log_group_aws_tags_key_same_group_diff_tags
+      clear_log_group
 
-    d = create_driver(<<-EOC)
-    #{default_config}
-    auto_create_stream true
-    use_tag_as_stream true
-    log_group_name_key group_name_key
-    log_group_aws_tags_key aws_tags
-    EOC
+      d = create_driver(<<-EOC)
+        #{default_config}
+        auto_create_stream true
+        use_tag_as_stream true
+        log_group_name_key group_name_key
+        log_group_aws_tags_key aws_tags
+      EOC
 
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}},
-      {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag3" => "value3", "tag4" => "value4"}}
-    ]
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag1" => "value1", "tag2" => "value2"}},
+        {'cloudwatch' => 'logs3', 'message' => 'message1', 'group_name_key' => log_group_name, 'aws_tags' => {"tag3" => "value3", "tag4" => "value4"}}
+      ]
 
-    time = Time.now
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time.to_i + i, record)
+      time = Time.now
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time.to_i + i, record)
+        end
       end
-    end
 
-    awstags = get_log_group_tags
-    assert_equal("value1", awstags.fetch("tag1"))
-    assert_equal("value2", awstags.fetch("tag2"))
-    assert_raise KeyError do
-      awstags.fetch("tag3")
-    end
-    assert_raise KeyError do
-      awstags.fetch("tag4")
+      awstags = get_log_group_tags
+      assert_equal("value1", awstags.fetch("tag1"))
+      assert_equal("value2", awstags.fetch("tag2"))
+      assert_raise KeyError do
+        awstags.fetch("tag3")
+      end
+      assert_raise KeyError do
+        awstags.fetch("tag4")
+      end
     end
-  end
-
-  def test_log_group_aws_tags_key_no_tags
-    clear_log_group
-
-    d = create_driver(<<-EOC)
-    #{default_config}
-    auto_create_stream true
-    log_group_name_key group_name_key
-    log_stream_name_key stream_name_key
-    remove_log_group_name_key true
-    remove_log_stream_name_key true
-    log_group_aws_tags_key aws_tags
-    EOC
 
-    stream = log_stream_name
-    records = [
-      {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream},
-      {'cloudwatch' => 'logs2', 'message' => 'message2', 'group_name_key' => log_group_name, 'stream_name_key' => stream}
-    ]
+    def test_log_group_aws_tags_key_no_tags
+      clear_log_group
+
+      d = create_driver(<<-EOC)
+        #{default_config}
+        auto_create_stream true
+        log_group_name_key group_name_key
+        log_stream_name_key stream_name_key
+        remove_log_group_name_key true
+        remove_log_stream_name_key true
+        log_group_aws_tags_key aws_tags
+      EOC
 
-    time = Time.now
-    d.run(default_tag: fluentd_tag) do
-      records.each_with_index do |record, i|
-        d.feed(time.to_i + i, record)
+      stream = log_stream_name
+      records = [
+        {'cloudwatch' => 'logs1', 'message' => 'message1', 'group_name_key' => log_group_name, 'stream_name_key' => stream},
+        {'cloudwatch' => 'logs2', 'message' => 'message2', 'group_name_key' => log_group_name, 'stream_name_key' => stream}
+      ]
+
+      time = Time.now
+      d.run(default_tag: fluentd_tag) do
+        records.each_with_index do |record, i|
+          d.feed(time.to_i + i, record)
+        end
       end
-    end
 
-    sleep 10
+      sleep 10
 
-    awstags = get_log_group_tags
+      awstags = get_log_group_tags
 
-    assert_raise KeyError do
-      awstags.fetch("tag1")
-    end
+      assert_raise KeyError do
+        awstags.fetch("tag1")
+      end
 
-    events = get_log_events(log_group_name, stream)
-    assert_equal(2, events.size)
-    assert_equal(time.to_i * 1000, events[0].timestamp)
-    assert_equal({'cloudwatch' => 'logs1', 'message' => 'message1'}, JSON.parse(events[0].message))
-    assert_equal({'cloudwatch' => 'logs2', 'message' => 'message2'}, JSON.parse(events[1].message))
-  end
+      events = get_log_events(log_group_name, stream)
+      assert_equal(2, events.size)
+      assert_equal(time.to_i * 1000, events[0].timestamp)
+      assert_equal({'cloudwatch' => 'logs1', 'message' => 'message1'}, JSON.parse(events[0].message))
+      assert_equal({'cloudwatch' => 'logs2', 'message' => 'message2'}, JSON.parse(events[1].message))
+    end
 
-  def test_retrying_on_throttling_exception
-    resp = mock()
-    resp.expects(:rejected_log_events_info)
-    resp.expects(:next_sequence_token)
-    client = Aws::CloudWatchLogs::Client.new
-    client.stubs(:put_log_events).
-      raises(Aws::CloudWatchLogs::Errors::ThrottlingException.new(nil, "error")).then.returns(resp)
+    def test_retrying_on_throttling_exception
+      resp = mock()
+      resp.expects(:rejected_log_events_info)
+      resp.expects(:next_sequence_token)
+      client = Aws::CloudWatchLogs::Client.new
+      client.stubs(:put_log_events).
+        raises(Aws::CloudWatchLogs::Errors::ThrottlingException.new(nil, "error")).then.returns(resp)
+
+      d = create_driver
+      time = event_time
+      d.instance.instance_variable_set(:@logs, client)
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'message' => 'message1'})
+      end
 
-    d = create_driver
-    time = event_time
-    d.instance.instance_variable_set(:@logs, client)
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'message' => 'message1'})
+      logs = d.logs
+      assert_equal(1, logs.select {|l| l =~ /Called PutLogEvents API/ }.size)
+      assert_equal(1, logs.select {|l| l =~ /failed to PutLogEvents/ }.size)
+      assert_equal(1, logs.select {|l| l =~ /retry succeeded/ }.size)
     end
 
-    logs = d.logs
-    assert_equal(1, logs.select {|l| l =~ /Called PutLogEvents API/ }.size)
-    assert_equal(1, logs.select {|l| l =~ /failed to PutLogEvents/ }.size)
-    assert_equal(1, logs.select {|l| l =~ /retry succeeded/ }.size)
-  end
+    def test_retrying_on_throttling_exception_and_throw_away
+      client = Aws::CloudWatchLogs::Client.new
+      client.stubs(:put_log_events).
+        raises(Aws::CloudWatchLogs::Errors::ThrottlingException.new(nil, "error"))
+      time = Fluent::Engine.now
+      d = create_driver(<<-EOC)
+        #{default_config}
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+        put_log_events_retry_limit 1
+        @log_level debug
+      EOC
+      d.instance.instance_variable_set(:@logs, client)
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'message' => 'message1'})
+      end
 
-  def test_retrying_on_throttling_exception_and_throw_away
-    client = Aws::CloudWatchLogs::Client.new
-    client.stubs(:put_log_events).
-      raises(Aws::CloudWatchLogs::Errors::ThrottlingException.new(nil, "error"))
-    time = Fluent::Engine.now
-    d = create_driver(<<-EOC)
-#{default_config}
-log_group_name #{log_group_name}
-log_stream_name #{log_stream_name}
-put_log_events_retry_limit 1
-@log_level debug
-    EOC
-    d.instance.instance_variable_set(:@logs, client)
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'message' => 'message1'})
+      logs = d.logs
+      assert_equal(0, logs.select {|l| l =~ /Called PutLogEvents API/ }.size)
+      assert_equal(3, logs.select {|l| l =~ /failed to PutLogEvents/ }.size)
+      assert_equal(1, logs.select {|l| l =~ /failed to PutLogEvents and discard logs/ }.size)
     end
 
-    logs = d.logs
-    assert_equal(0, logs.select {|l| l =~ /Called PutLogEvents API/ }.size)
-    assert_equal(3, logs.select {|l| l =~ /failed to PutLogEvents/ }.size)
-    assert_equal(1, logs.select {|l| l =~ /failed to PutLogEvents and discard logs/ }.size)
-  end
+    def test_too_large_event
+      time = Fluent::Engine.now
+      d = create_driver(<<-EOC)
+        #{default_config}
+        log_group_name #{log_group_name}
+        log_stream_name #{log_stream_name}
+        @log_level debug
+      EOC
+      d.run(default_tag: fluentd_tag) do
+        d.feed(time, {'message' => '*' * 256 * 1024})
+      end
 
-  def test_too_large_event
-    time = Fluent::Engine.now
-    d = create_driver(<<-EOC)
-#{default_config}
-log_group_name #{log_group_name}
-log_stream_name #{log_stream_name}
-@log_level debug
-    EOC
-    d.run(default_tag: fluentd_tag) do
-      d.feed(time, {'message' => '*' * 256 * 1024})
+      logs = d.logs
+      assert(logs.any?{|log| log.include?("Log event is discarded because it is too large: 262184 bytes exceeds limit of 262144")})
     end
-
-    logs = d.logs
-    assert(logs.any?{|log| log.include?("Log event is discarded because it is too large: 262184 bytes exceeds limit of 262144")})
   end
 
   def test_scrub_record