fluent-plugin-elb-log 0.1.4 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 966e83a0c3cce1f14ff40f3a54a4e6c5cc3c88fd
+  data.tar.gz: 0c6319930698bc00048dfd3ebe50f7c0904086b1
+SHA512:
+  metadata.gz: 595c8db95152913481d55f0edd42730dade97d9f5d68c1943ffda3d9d6677360aafff78548c680d0c794e0137013d76a9d1a26ff4d8bfa07162013c0369624e2
+  data.tar.gz: 157c1301e07758ae19abbf742a32c3350a0d39d3c390fb5c7b195330e41665d26d3fbecc63f72b83bcbfd0ee3c5bcc781262fe20b060446915e3ea47cfdfa825

data/README.md

@@ -11,6 +11,32 @@
 - settings see: [Elastic Load Balancing](http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/enable-access-logs.html)
 - developer guide: [](http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/access-log-collection.html)
 
+## Different from version 0.1.x
+- Using version 2 of the AWS SDK for Ruby.
+- add parameter
+ - region (required. see:http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)
+ - tag (optional)
+- remove parameter
+ - s3_endpoint
+- output data change
+ - add items
+     - region (AWS Region name)
+     - key (source S3 object name)
+     - prefix
+     - elb_timestamp_unixtime (converted to unix timestamp)
+     - user_agent
+     - option1, option2, option3
+
+## When SSL certification error
+log:
+```
+SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed
+```
+Do env setting follows:
+```
+SSL_CERT_FILE=/etc/ssl/certs/ca-bundle.crt (If you using amazon linux)
+```
+
 ## Configuration
 
 ```config
@@ -18,12 +44,13 @@
   type elb_log
 
   # following attibutes are required
-  s3_endpoint       <s3_endpoint>
+  region            <region name>
   s3_bucketname     <bucketname>
   s3_prefix         <elb log's prefix>
   timestamp_file    <proc last file timestamp record filename>
-  refresh_interval  <interval number by second>
   buf_file          <buffer file path>
+  refresh_interval  <interval number by second>
+  tag               <tag name(default: elb.access)>
 
   # following attibutes are required if you don't use IAM Role
   access_key_id     <access_key>
@@ -35,14 +62,15 @@
 ```config
 <source>
   type elb_log
-  access_key_id     XXXXXXXXXXXXXXXXXXXX
-  secret_access_key xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-  s3_endpoint       s3.amazonaws.com
-  s3_bucketname     bucketname
-  s3_prefix         prefix
+  region            us-east-1
+  s3_bucketname     my-elblog-bucket
+  s3_prefix         prodcution/web
   timestamp_file    elb_last_at.dat
-  refresh_interval  300
   buf_file          /tmp/fluentd-elblog.tmpfile
+  refresh_interval  300
+  tag               elb.access
+  access_key_id     XXXXXXXXXXXXXXXXXXXX
+  secret_access_key xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 </source>
 
 <match **>
@@ -53,28 +81,36 @@
 ### json output example
 ```
 {
-    "account_id": "999999999999", 
-    "backend": "192.168.30.127", 
-    "backend_port": "80", 
-    "backend_processing_time": "0.000985", 
-    "backend_status_code": "200", 
-    "client": "118.20.x.x", 
-    "client_port": "46171", 
-    "elb": "fluent-test-elb", 
-    "elb_ip_address": "54.250.x.x", 
-    "elb_status_code": "200", 
-    "logfile_date": "2014/03/09", 
-    "logfile_elb_name": "fluent-test-elb", 
-    "logfile_hash": "xyz123ab", 
-    "received_bytes": "0", 
-    "region": "ap-northeast-1", 
-    "request_method": "GET", 
-    "request_processing_time": "0.000072", 
-    "request_protocol": "HTTP/1.1", 
-    "request_uri": "http://logfile_elb_name-00000000.ap-northeast-1.elb.amazonaws.com:80/", 
-    "response_processing_time": "0.00007", 
-    "sent_bytes": "9", 
-    "time": "2014-03-09T04:10:33.785083Z"
+    "account_id":"123456789012",
+    "region":"ap-northeast-1",
+    "logfile_date":"2015/06/15",
+    "logfile_elb_name":"my-elb-name",
+    "elb_ip_address":"52.0.0.0",
+    "logfile_hash":"12squv5w",
+    "elb_timestamp":"20150615T0400Z",
+    "key":"TEST/AWSLogs/123456789012/elasticloadbalancing/ap-northeast-1/2015/06/15/123456789012_elasticloadbalancing_ap-northeast-1_my-elb-name_20150615T0400Z_52.68.215.138_69squv5w.log",
+    "prefix":"TEST",
+    "elb_timestamp_unixtime":1434340800,
+    "time":"2015-06-15T03:47:12.728427+0000",
+    "elb":"my-elb-name",
+    "client":"54.1.1.1",
+    "client_port":"43759",
+    "backend":"10.0.0.1",
+    "backend_port":"80",
+    "request_processing_time":4.0e-05,
+    "backend_processing_time":0.105048,
+    "response_processing_time":2.4e-05,
+    "elb_status_code":"200",
+    "backend_status_code":"200",
+    "received_bytes":0,
+    "sent_bytes":4622,
+    "request_method":"GET",
+    "request_uri":"https://my-elb-test.example.com/",
+    "request_protocol":"HTTP/1.1",
+    "user_agent":"Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)",
+    "option1":"DHE-RSA-AES128-SHA",
+    "option2":"TLSv1.2",
+    "option3":null
 }
 ```
 

data/fluent-plugin-elb-log.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "fluent-plugin-elb-log"
-  spec.version       = "0.1.4"
+  spec.version       = "0.2.0"
   spec.authors       = ["shinsaka"]
   spec.email         = ["shinx1265@gmail.com"]
   spec.summary       = "Amazon ELB log input plugin"
@@ -17,10 +17,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "fluentd"
-  spec.add_dependency "aws-sdk", "~> 1.38"
+  spec.add_dependency "fluentd", "~> 0"
+  spec.add_dependency "aws-sdk", "~> 2"
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "bundler", "~> 1.7"
 end

data/lib/fluent/plugin/in_elb_log.rb

@@ -2,13 +2,14 @@ class Fluent::Elb_LogInput < Fluent::Input
   Fluent::Plugin.register_input('elb_log', self)
 
   LOGFILE_REGEXP = /^((?<prefix>.+?)\/|)AWSLogs\/(?<account_id>[0-9]{12})\/elasticloadbalancing\/(?<region>.+?)\/(?<logfile_date>[0-9]{4}\/[0-9]{2}\/[0-9]{2})\/[0-9]{12}_elasticloadbalancing_.+?_(?<logfile_elb_name>[^_]+)_(?<elb_timestamp>[0-9]{8}T[0-9]{4}Z)_(?<elb_ip_address>.+?)_(?<logfile_hash>.+)\.log$/
-  ACCESSLOG_REGEXP = /^(?<time>\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{6}Z) (?<elb>.+?) (?<client>.+)\:(?<client_port>.+) (?<backend>.+)\:(?<backend_port>.+) (?<request_processing_time>.+?) (?<backend_processing_time>.+?) (?<response_processing_time>.+?) (?<elb_status_code>.+?) (?<backend_status_code>.+?) (?<received_bytes>.+?) (?<sent_bytes>.+?) \"(?<request_method>.+?) (?<request_uri>.+?) (?<request_protocol>.+?)\"$/
+  ACCESSLOG_REGEXP = /^(?<time>\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{6}Z) (?<elb>.+?) (?<client>.+?)\:(?<client_port>.+?) (?<backend>.+?)\:(?<backend_port>.+?) (?<request_processing_time>.+?) (?<backend_processing_time>.+?) (?<response_processing_time>.+?) (?<elb_status_code>.+?) (?<backend_status_code>.+?) (?<received_bytes>.+?) (?<sent_bytes>.+?) \"(?<request_method>.+?) (?<request_uri>.+?) (?<request_protocol>.+?)\" \"(?<user_agent>.*?)\" (?<option1>.+?) (?<option2>.+)(| (?<option3>.*))/
 
   config_param :access_key_id, :string, :default => nil
   config_param :secret_access_key, :string, :default => nil
+  config_param :region, :string, :default => nil
   config_param :s3_bucketname, :string, :default => nil
   config_param :s3_prefix, :string, :default => nil
-  config_param :s3_endpoint, :string, :default => 's3.amazon.com'
+  config_param :tag, :string, :default => 'elb.access'
   config_param :timestamp_file, :string, :default => nil
   config_param :refresh_interval, :integer, :default => 300
   config_param :buf_file, :string, :default => './fluentd_elb_log_buf_file'
@@ -18,24 +19,23 @@ class Fluent::Elb_LogInput < Fluent::Input
     super
     require 'aws-sdk'
 
-    if @access_key_id.nil? and has_not_iam_role?
-      raise Fluent::ConfigError.new("access_key_id is required")
+    raise Fluent::ConfigError.new("region is required") unless @region
+    if !has_iam_role?
+      raise Fluent::ConfigError.new("access_key_id is required") if @access_key_id.nil?
+      raise Fluent::ConfigError.new("secret_access_key is required") if @secret_access_key.nil?
     end
-    if @secret_access_key.nil? and has_not_iam_role?
-      raise Fluent::ConfigError.new("secret_access_key is required")
-    end
-
     raise Fluent::ConfigError.new("s3_bucketname is required") unless @s3_bucketname
     raise Fluent::ConfigError.new("timestamp_file is required") unless @timestamp_file
-    raise Fluent::ConfigError.new("s3 bucket fetch error #{@s3_bucketname}") if init_s3bucket.nil?
-    FileUtils.touch(@buf_file)
   end
 
   def start
     super
 
-    @timestamp_file = File.open(@timestamp_file, File::RDWR|File::CREAT)
-    @timestamp_file.sync = true
+    # files touch
+    File.open(@timestamp_file, File::RDWR|File::CREAT).close
+    File.open(@buf_file, File::RDWR|File::CREAT).close
+
+    raise StandardError.new("s3 bucket not found #{@s3_bucketname}") unless s3bucket_is_ok()
 
     @loop = Coolio::Loop.new
     timer_trigger = TimerWatcher.new(@refresh_interval, true, &method(:input))
@@ -47,142 +47,223 @@ class Fluent::Elb_LogInput < Fluent::Input
     super
     @loop.stop
     @thread.join
-    @timestamp_file.close
   end
 
   private
 
-  def init_s3bucket
-    options = {}
-    if @access_key_id && @secret_access_key
-      options[:access_key_id] = @access_key_id
-      options[:secret_access_key] = @secret_access_key
-    end
-    options[:s3_endpoint] = @s3_endpoint if @s3_endpoint
-    if @proxy_uri
-      options[:proxy_uri] = @proxy_uri
+  def has_iam_role?
+    begin
+      ec2 = Aws::EC2::Client.new(region: @region)
+      !ec2.config.credentials.nil?
+    rescue => e
+      $log.warn "EC2 Client error occurred: #{e.message}"
     end
+  end
 
+  def get_timestamp_file
     begin
-      @bucket = AWS::S3.new(options).buckets[@s3_bucketname]
-      @bucket.objects.count
+      # get timestamp last proc
+      timestamp = 0
+      $log.debug "timestamp file #{@timestamp_file} read"
+      File.open(@timestamp_file, File::RDONLY) do |file|
+        timestamp = file.read.to_i
+      end
+      $log.debug "timestamp start at:" + Time.at(timestamp).to_s
+      return timestamp
     rescue => e
-      $log.warn "fluent-plugin-elb-log: s3 bucket fetch error: #{e.message}"
-      nil
+      $log.warn "timestamp file get and parse error occurred: #{e.message}"
     end
   end
 
-  def run
-    @loop.run
+  def put_timestamp_file(timestamp)
+    begin
+      $log.debug "timestamp file #{@timestamp_file} write"
+      File.open(@timestamp_file, File::WRONLY|File::CREAT|File::TRUNC) do |file|
+        file.puts timestamp.to_s
+      end
+    rescue => e
+      $log.warn "timestamp file get and parse error occurred: #{e.message}"
+    end
   end
 
-  def input
-    $log.info "fluent-plugin-elb-log: input start"
-
-    # get timestamp last proc
-    @timestamp_file.rewind
-    timestamp = @timestamp_file.read.to_i
-    timestamp = 0 unless timestamp
-    $log.info "fluent-plugin-elb-log: timestamp at start: " + Time.at(timestamp).to_s
-
-    log_objects = []
-    @bucket.objects.each do |obj|
-      next if obj.last_modified.to_i <= timestamp
-      matches = LOGFILE_REGEXP.match(obj.key)
-      next unless matches
-      next if !@s3_prefix.nil? && matches[:prefix] != @s3_prefix
-      log_objects.push obj
+  def s3_client
+    begin
+      options = {
+        :region => @region,
+      }
+      if @access_key_id && @secret_access_key
+        options[:access_key_id] = @access_key_id
+        options[:secret_access_key] = @secret_access_key
+      end
+      $log.debug "S3 client connect"
+      Aws::S3::Client.new(options)
+    rescue => e
+      $log.warn "S3 Client error occurred: #{e.message}"
     end
+  end
+
+  def s3bucket_is_ok
+    begin
+      $log.debug "search bucket #{@s3_bucketname}"
 
-    # sort by timestamp
-    log_objects.sort! do |a,b|
-      LOGFILE_REGEXP.match(a.key)[:elb_timestamp] <=> LOGFILE_REGEXP.match(b.key)[:elb_timestamp]
+      s3_client.list_buckets.buckets.any? do |bucket|
+        bucket.name == @s3_bucketname
+      end
+    rescue => e
+      $log.warn "S3 Client error occurred: #{e.message}"
     end
+  end
+
+  def input
+    $log.debug "start"
+
+    timestamp = get_timestamp_file()
+
+    object_keys = get_object_keys(timestamp)
+    object_keys = sort_object_key(object_keys)
+
+    $log.info "processing #{object_keys.count} object(s)."
 
-    log_objects.each do |obj|
-      matches = LOGFILE_REGEXP.match(obj.key)
-      timestamp = matches[:elb_timestamp].to_i
+    object_keys.each do |object_key|
       record_common = {
-        "account_id" => matches[:account_id],
-        "region" => matches[:region],
-        "logfile_date" => matches[:logfile_date],
-        "logfile_elb_name" => matches[:logfile_elb_name],
-        "elb_ip_address" => matches[:elb_ip_address],
-        "logfile_hash" => matches[:logfile_hash],
-        "elb_timestamp" => matches[:elb_timestamp],
+        "account_id" => object_key[:account_id],
+        "region" => object_key[:region],
+        "logfile_date" => object_key[:logfile_date],
+        "logfile_elb_name" => object_key[:logfile_elb_name],
+        "elb_ip_address" => object_key[:elb_ip_address],
+        "logfile_hash" => object_key[:logfile_hash],
+        "elb_timestamp" => object_key[:elb_timestamp],
+        "key" => object_key[:key],
+        "prefix" => object_key[:prefix],
+        "elb_timestamp_unixtime" => object_key[:elb_timestamp_unixtime],
       }
 
-      # read an object from S3 to a file and write buffer file
-      File.open(@buf_file, File::WRONLY) do |file|
-        obj.read do |chunk|
-          file.write(chunk)
-        end
-      end
+      get_file_from_s3(object_key[:key])
+      emit_lines_from_buffer_file(record_common)
+
+      put_timestamp_file(object_key[:elb_timestamp_unixtime])
+    end
+  end
+
+  def get_object_keys(timestamp)
+    # get values from object file name
+    begin
+      object_keys = []
+
+      objects = s3_client.list_objects(
+        bucket: @s3_bucketname,
+        max_keys: 100,
+        prefix: @s3_prefix,
+      )
+  
+      objects.each do |object|
+        object.contents.each do |content|
+          matches = LOGFILE_REGEXP.match(content.key)
+          next unless matches
 
-      emit_lines_from_buffer_file record_common
+          # snip old items
+          elb_timestamp_unixtime = Time.parse(matches[:elb_timestamp]).to_i
+          next if elb_timestamp_unixtime <= timestamp
 
-      # timestamp save
-      @timestamp_file.rewind
-      @timestamp_file.write(obj.last_modified.to_i)
-      @timestamp_file.truncate(@timestamp_file.tell)
-      $log.info "fluent-plugin-elb-log: timestamp save: " + obj.last_modified.to_s
+          $log.debug content.key
+          object_keys << {
+            key: content.key,
+            prefix: matches[:prefix],
+            account_id: matches[:account_id],
+            region: matches[:region],
+            logfile_date: matches[:logfile_date],
+            logfile_elb_name: matches[:logfile_elb_name],
+            elb_timestamp: matches[:elb_timestamp],
+            elb_ip_address: matches[:elb_ip_address],
+            logfile_hash: matches[:logfile_hash],
+            elb_timestamp_unixtime: elb_timestamp_unixtime,
+          }
+        end
+      end
+      return object_keys
+    rescue => e
+      $log.warn "error occurred: #{e.message}"
     end
   end
 
-  def emit_lines_from_buffer_file(record_common)
-    # emit per line
-    File.open(@buf_file, File::RDONLY) do |file|
-      file.each_line do |line|
-        line_match = ACCESSLOG_REGEXP.match(line)
-        next unless line_match
-
-        record = {
-          "time" => line_match[:time].gsub(/Z/, "+0000"),
-          "elb" => line_match[:elb],
-          "client" => line_match[:client],
-          "client_port" => line_match[:client_port],
-          "backend" => line_match[:backend],
-          "backend_port" => line_match[:backend_port],
-          "request_processing_time" => line_match[:request_processing_time].to_f,
-          "backend_processing_time" => line_match[:backend_processing_time].to_f,
-          "response_processing_time" => line_match[:response_processing_time].to_f,
-          "elb_status_code" => line_match[:elb_status_code],
-          "backend_status_code" => line_match[:backend_status_code],
-          "received_bytes" => line_match[:received_bytes].to_i,
-          "sent_bytes" => line_match[:sent_bytes].to_i,
-          "request_method" => line_match[:request_method],
-          "request_uri" => line_match[:request_uri],
-          "request_protocol" => line_match[:request_protocol],
-        }
-
-        Fluent::Engine.emit("elb.access", Fluent::Engine.now, record_common.merge(record))
+  def sort_object_key(src_object_keys)
+    begin
+      src_object_keys.sort do |a, b|
+        a[:elb_timestamp_unixtime] <=> b[:elb_timestamp_unixtime]
       end
+    rescue => e
+      $log.warn "error occurred: #{e.message}"
     end
   end
 
-  def has_iam_role?
-    return @has_iam_role unless @has_iam_role.nil?
+  def get_file_from_s3(object_name)
+    begin
+      $log.debug "getting object from s3 name is #{object_name}"
 
-    require 'net/http'
-    @has_iam_role  = false
+      # read an object from S3 to a file and write buffer file
+      File.open(@buf_file, File::WRONLY|File::CREAT|File::TRUNC) do |file|
+        s3_client.get_object(
+          bucket: @s3_bucketname,
+          key: object_name
+        ) do |chunk|
+          file.write(chunk)
+        end
+      end
+    rescue => e
+      $log.warn "error occurred: #{e.message}"
+    end
+  end
+
+  def emit_lines_from_buffer_file(record_common)
     begin
-      http = Net::HTTP.new('169.254.169.254', '80')
-      http.open_timeout = 5 # sec
-      response = http.request(Net::HTTP::Get.new('/latest/meta-data/iam/info'))
-      @has_iam_role = true if response.code == '200'
+      # emit per line
+      File.open(@buf_file, File::RDONLY) do |file|
+        file.each_line do |line|
+          line_match = ACCESSLOG_REGEXP.match(line)
+          unless line_match
+            $log.info "nomatch log found: #{line} in #{record_common['key']}"
+            next
+          end
+  
+          record = {
+            "time" => line_match[:time].gsub(/Z/, "+0000"),
+            "elb" => line_match[:elb],
+            "client" => line_match[:client],
+            "client_port" => line_match[:client_port],
+            "backend" => line_match[:backend],
+            "backend_port" => line_match[:backend_port],
+            "request_processing_time" => line_match[:request_processing_time].to_f,
+            "backend_processing_time" => line_match[:backend_processing_time].to_f,
+            "response_processing_time" => line_match[:response_processing_time].to_f,
+            "elb_status_code" => line_match[:elb_status_code],
+            "backend_status_code" => line_match[:backend_status_code],
+            "received_bytes" => line_match[:received_bytes].to_i,
+            "sent_bytes" => line_match[:sent_bytes].to_i,
+            "request_method" => line_match[:request_method],
+            "request_uri" => line_match[:request_uri],
+            "request_protocol" => line_match[:request_protocol],
+            "user_agent" => line_match[:user_agent],
+            "option1" => line_match[:option1],
+            "option2" => line_match[:option2],
+            "option3" => line_match[:option3],
+          }
+  
+          Fluent::Engine.emit(@tag, Fluent::Engine.now, record_common.merge(record))
+        end
+      end
     rescue => e
-      $log.warn "fluent-plugin-elb-log: #{e.message}"
+      $log.warn "error occurred: #{e.message}"
     end
-    @has_iam_role
   end
 
-  def has_not_iam_role?
-    !has_iam_role?
+  def run
+    @loop.run
   end
 
   class TimerWatcher < Coolio::TimerWatcher
     def initialize(interval, repeat, &callback)
       @callback = callback
+      on_timer # first call
       super(interval, repeat)
     end
 

metadata

@@ -1,96 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-elb-log
 version: !ruby/object:Gem::Version
-  version: 0.1.4
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - shinsaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2015-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.38'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.38'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
 description: Amazon ELB log input plugin for fluentd
 email:
 - shinx1265@gmail.com
@@ -98,8 +59,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -112,27 +73,26 @@ files:
 homepage: https://github.com/shinsaka/fluent-plugin-elb-log
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Amazon ELB log input plugin
 test_files:
 - test/helper.rb