fluent-plugin-google-cloud 0.6.12 → 0.6.13.pre.memory.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fbc5121ee932ffffd68d89d4c907f836b82edbc
-  data.tar.gz: d0e361c403ad696830514899b295709f0ef7c99c
+  metadata.gz: b26e153a8191c18cf52ed1efdc552d5323045683
+  data.tar.gz: 3111b02b15f0a930f7cbd0d28b5517ffbe56a0ab
 SHA512:
-  metadata.gz: e5059d786227bd2d15224a359c002a309a6960117eeee63c1e4690e8606b2ac8de64aec1f6cf654847deab41e1fd524c82910361faea29eb2651c8f1167571ed
-  data.tar.gz: 1576bea68999170b5bb78d22190c050cb060baebc5cb2e075f0d58cedad44667efa3a3b0b6b60ebcb78209f005218f1929d2dec08a0ac58d5e64569ce130a9a5
+  metadata.gz: 4e569bbf17acbb4c997c3321bee3d7bac9cdbaa21c5e8b6d6f40bf996906ac3cc41f4ae7e7ae2f8085251369cefa5a0be4261d3529c294a305c7e0bb4aba2d1c
+  data.tar.gz: 28562ed528b840677aca44c5f5982740e0e936a1eb9bb15ed8ca35d36f821fbc0931e8888ffe53a99cc4c73e622b10dbda51b8146c8ec2f1ecec97b6b671d042

data/Gemfile.lock

@@ -1,20 +1,20 @@
 PATH
   remote: .
   specs:
-    fluent-plugin-google-cloud (0.6.12)
+    fluent-plugin-google-cloud (0.6.13.pre.memory.1)
       fluentd (~> 0.10)
       google-api-client (~> 0.14)
       google-cloud-logging (~> 1.2.3)
       googleapis-common-protos (~> 1.3)
       googleauth (~> 0.5)
-      grpc (~> 1.2.5)
+      grpc (~> 1.8)
       json (~> 1.8)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.5.1)
-      public_suffix (~> 2.0, >= 2.0.2)
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
     ast (2.3.0)
     cool.io (1.5.3)
     crack (0.4.3)
@@ -34,7 +34,7 @@ GEM
       tzinfo (~> 1.0)
       tzinfo-data (~> 1.0)
       yajl-ruby (~> 1.0)
-    google-api-client (0.17.4)
+    google-api-client (0.19.3)
       addressable (~> 2.5, >= 2.5.1)
       googleauth (>= 0.5, < 0.7.0)
       httpclient (>= 2.8.1, < 3.0)
@@ -55,7 +55,7 @@ GEM
       googleauth (~> 0.5.1)
       grpc (~> 1.0)
       rly (~> 0.2.3)
-    google-protobuf (3.5.0)
+    google-protobuf (3.5.1)
     googleapis-common-protos (1.3.7)
       google-protobuf (~> 3.0)
       googleapis-common-protos-types (~> 1.0)
@@ -70,10 +70,11 @@ GEM
       multi_json (~> 1.11)
       os (~> 0.9)
       signet (~> 0.7)
-    grpc (1.2.5)
+    grpc (1.8.3)
       google-protobuf (~> 3.1)
-      googleauth (~> 0.5.1)
-    hashdiff (0.3.4)
+      googleapis-common-protos-types (~> 1.0.0)
+      googleauth (>= 0.5.1, < 0.7)
+    hashdiff (0.3.7)
     http_parser.rb (0.6.0)
     httpclient (2.8.3)
     json (1.8.6)
@@ -87,19 +88,19 @@ GEM
     mime-types (3.1)
       mime-types-data (~> 3.2015)
     mime-types-data (3.2016.0521)
-    mocha (1.2.1)
+    mocha (1.3.0)
       metaclass (~> 0.0.1)
-    msgpack (1.2.0)
-    multi_json (1.12.2)
+    msgpack (1.2.2)
+    multi_json (1.13.1)
     multipart-post (2.0.0)
     os (0.9.6)
     parser (2.4.0.2)
       ast (~> 2.3)
-    power_assert (1.0.1)
+    power_assert (1.1.1)
     powerpack (0.1.1)
     prometheus-client (0.7.1)
       quantile (~> 0.2.0)
-    public_suffix (2.0.5)
+    public_suffix (3.0.1)
     quantile (0.2.0)
     rainbow (2.2.2)
       rake
@@ -119,7 +120,7 @@ GEM
     ruby-progressbar (1.9.0)
     ruby_dig (0.0.2)
     safe_yaml (1.0.4)
-    serverengine (2.0.5)
+    serverengine (2.0.6)
       sigdump (~> 0.2.2)
     sigdump (0.2.4)
     signet (0.8.1)
@@ -129,7 +130,7 @@ GEM
       multi_json (~> 1.10)
     stackdriver-core (1.2.0)
     strptime (0.1.9)
-    test-unit (3.2.3)
+    test-unit (3.2.7)
       power_assert
     thread_safe (0.3.6)
     tzinfo (1.2.4)
@@ -157,4 +158,4 @@ DEPENDENCIES
   webmock (~> 2.3.1)
 
 BUNDLED WITH
-   1.16.0
+   1.16.1

data/fluent-plugin-google-cloud.gemspec

@@ -10,7 +10,7 @@ eos
   gem.homepage      =
     'https://github.com/GoogleCloudPlatform/fluent-plugin-google-cloud'
   gem.license       = 'Apache-2.0'
-  gem.version       = '0.6.12'
+  gem.version       = '0.6.13.pre.memory.1'
   gem.authors       = ['Todd Derr', 'Alex Robinson']
   gem.email         = ['salty@google.com']
   gem.required_ruby_version = Gem::Requirement.new('>= 2.0')
@@ -24,7 +24,7 @@ eos
   gem.add_runtime_dependency 'google-api-client', '~> 0.14'
   gem.add_runtime_dependency 'google-cloud-logging', '~> 1.2.3'
   gem.add_runtime_dependency 'googleauth', '~> 0.5'
-  gem.add_runtime_dependency 'grpc', '~> 1.2.5'
+  gem.add_runtime_dependency 'grpc', '~> 1.8'
   gem.add_runtime_dependency 'json', '~> 1.8'
 
   gem.add_development_dependency 'mocha', '~> 1.1'

data/lib/fluent/plugin/out_google_cloud.rb

@@ -195,7 +195,7 @@ module Fluent
     Fluent::Plugin.register_output('google_cloud', self)
 
     PLUGIN_NAME = 'Fluentd Google Cloud Logging plugin'.freeze
-    PLUGIN_VERSION = '0.6.12'.freeze
+    PLUGIN_VERSION = '0.6.13.pre.memory.1'.freeze
 
     # Name of the the Google cloud logging write scope.
     LOGGING_SCOPE = 'https://www.googleapis.com/auth/logging.write'.freeze
@@ -295,13 +295,13 @@ module Fluent
     config_param :labels, :hash, :default => nil
 
     # Whether to use gRPC instead of REST/JSON to communicate to the
-    # Cloud Logging API.
+    # Stackdriver Logging API.
     config_param :use_grpc, :bool, :default => false
 
     # Whether valid entries should be written even if some other entries fail
     # due to INVALID_ARGUMENT or PERMISSION_DENIED errors when communicating to
-    # the Cloud Logging API. This is highly recommended. Right now this only
-    # works with the REST path (use_grpc = false).
+    # the Stackdriver Logging API. This is highly recommended. Right now this
+    # only works with the REST path (use_grpc = false).
     config_param :partial_success, :bool, :default => false
 
     # Whether to allow non-UTF-8 characters in user logs. If set to true, any
@@ -453,6 +453,14 @@ module Fluent
       @resource.labels.freeze
       @common_labels.freeze
 
+      if @use_grpc
+        @construct_log_entry = method(:construct_log_entry_in_grpc_format)
+        @write_request = method(:write_request_via_grpc)
+      else
+        @construct_log_entry = method(:construct_log_entry_in_rest_format)
+        @write_request = method(:write_request_via_rest)
+      end
+
       # Log an informational message containing the Logs viewer URL
       @log.info 'Logs viewer address: https://console.cloud.google.com/logs/',
                 "viewer?project=#{@project_id}&resource=#{@resource.type}/",
@@ -473,6 +481,7 @@ module Fluent
     def write(chunk)
       grouped_entries = group_log_entries_by_tag_and_local_resource_id(chunk)
 
+      requests_to_send = []
       grouped_entries.each do |(tag, local_resource_id), arr|
         entries = []
         group_level_resource, group_level_common_labels =
@@ -517,40 +526,11 @@ module Fluent
           severity = compute_severity(
             entry_level_resource.type, record, entry_level_common_labels)
 
-          if @use_grpc
-            entry = Google::Logging::V2::LogEntry.new(
-              labels: entry_level_common_labels,
-              resource: Google::Api::MonitoredResource.new(
-                type: entry_level_resource.type,
-                labels: entry_level_resource.labels.to_h
-              ),
-              severity: grpc_severity(severity)
-            )
-            # If "seconds" is null or not an integer, we will omit the timestamp
-            # field and defer the decision on how to handle it to the downstream
-            # Logging API. If "nanos" is null or not an integer, it will be set
-            # to 0.
-            if ts_secs.is_a?(Integer)
-              ts_nanos = 0 unless ts_nanos.is_a?(Integer)
-              entry.timestamp = Google::Protobuf::Timestamp.new(
-                seconds: ts_secs,
-                nanos: ts_nanos
-              )
-            end
-          else
-            # Remove the labels if we didn't populate them with anything.
-            entry_level_resource.labels = nil if
-              entry_level_resource.labels.empty?
-            entry = Google::Apis::LoggingV2::LogEntry.new(
-              labels: entry_level_common_labels,
-              resource: entry_level_resource,
-              severity: severity,
-              timestamp: {
-                seconds: ts_secs,
-                nanos: ts_nanos
-              }
-            )
-          end
+          entry = @construct_log_entry.call(entry_level_common_labels,
+                                            entry_level_resource,
+                                            severity,
+                                            ts_secs,
+                                            ts_nanos)
 
           # Get fully-qualified trace id for LogEntry "trace" field.
           fq_trace_id = record.delete(@trace_key)
@@ -567,165 +547,226 @@ module Fluent
         log_name = "projects/#{@project_id}/logs/#{log_name(
           tag, group_level_resource)}"
 
-        # Does the actual write to the cloud logging api.
-        client = api_client
-        if @use_grpc
-          begin
-            labels_utf8_pairs = group_level_common_labels.map do |k, v|
-              [k.encode('utf-8'), convert_to_utf8(v)]
-            end
+        requests_to_send << {
+          entries: entries,
+          log_name: log_name,
+          resource: group_level_resource,
+          labels: group_level_common_labels
+        }
+      end
 
-            entries_count = entries.length
-            client.write_log_entries(
-              entries,
-              log_name: log_name,
-              resource: Google::Api::MonitoredResource.new(
-                type: group_level_resource.type,
-                labels: group_level_resource.labels.to_h
-              ),
-              labels: labels_utf8_pairs.to_h
-            )
-            increment_successful_requests_count
-            increment_ingested_entries_count(entries_count)
-
-            # Let the user explicitly know when the first call succeeded, to aid
-            # with verification and troubleshooting.
-            unless @successful_call
-              @successful_call = true
-              @log.info 'Successfully sent gRPC to Stackdriver Logging API.'
-            end
+      requests_to_send.each do |request|
+        @write_request.call(request)
+      end
+    end
 
-          rescue Google::Gax::GaxError => gax_error
-            # GRPC::BadStatus is wrapped in error.cause.
-            error = gax_error.cause
-
-            # See the mapping between HTTP status and gRPC status code at:
-            # https://github.com/grpc/grpc/blob/master/src/core/lib/transport/status_conversion.cc
-            case error
-            # Server error, so retry via re-raising the error.
-            when \
-                # HTTP status 500 (Internal Server Error).
-                GRPC::Internal,
-                # HTTP status 501 (Not Implemented).
-                GRPC::Unimplemented,
-                # HTTP status 503 (Service Unavailable).
-                GRPC::Unavailable,
-                # HTTP status 504 (Gateway Timeout).
-                GRPC::DeadlineExceeded
-              increment_retried_entries_count(entries_count, error.code)
-              @log.debug "Retrying #{entries_count} log message(s) later.",
-                         error: error.to_s, error_code: error.code.to_s
-              raise error
-
-            # Most client errors indicate a problem with the request itself and
-            # should not be retried.
-            when \
-                # HTTP status 400 (Bad Request).
-                GRPC::InvalidArgument,
-                # HTTP status 401 (Unauthorized).
-                # These are usually solved via a `gcloud auth` call, or by
-                # modifying the permissions on the Google Cloud project.
-                GRPC::Unauthenticated,
-                # HTTP status 403 (Forbidden).
-                GRPC::PermissionDenied,
-                # HTTP status 404 (Not Found).
-                GRPC::NotFound,
-                # HTTP status 409 (Conflict).
-                GRPC::Aborted,
-                # HTTP status 412 (Precondition Failed).
-                GRPC::FailedPrecondition,
-                # HTTP status 429 (Too Many Requests).
-                GRPC::ResourceExhausted,
-                # HTTP status 499 (Client Closed Request).
-                GRPC::Cancelled,
-                # the remaining http codes in both 4xx and 5xx category.
-                # It's debatable whether to retry or drop these log entries.
-                # This decision is made to avoid retrying forever due to client
-                # errors.
-                GRPC::Unknown
-              increment_failed_requests_count(error.code)
-              increment_dropped_entries_count(entries_count, error.code)
-              @log.warn "Dropping #{entries_count} log message(s)",
-                        error: error.to_s, error_code: error.code.to_s
-
-            else
-              # Assume it is a problem with the request itself and don't retry.
-              increment_failed_requests_count(error.code)
-              increment_dropped_entries_count(entries_count, error.code)
-              @log.error "Unknown response code #{error.code} from the "\
-                         "server, dropping #{entries_count} log message(s)",
-                         error: error.to_s, error_code: error.code.to_s
-            end
-          end
-        else
-          begin
-            write_request =
-              Google::Apis::LoggingV2::WriteLogEntriesRequest.new(
-                log_name: log_name,
-                resource: group_level_resource,
-                labels: group_level_common_labels,
-                partial_success: @partial_success,
-                entries: entries)
-            entries_count = entries.length
-            client.write_entry_log_entries(
-              write_request,
-              options: { api_format_version: '2' }
-            )
-
-            increment_successful_requests_count
-            increment_ingested_entries_count(entries_count)
-
-            # Let the user explicitly know when the first call succeeded, to aid
-            # with verification and troubleshooting.
-            unless @successful_call
-              @successful_call = true
-              @log.info 'Successfully sent to Stackdriver Logging API.'
-            end
+    private
 
-          rescue Google::Apis::ServerError => error
-            # 5xx server errors. Retry via re-raising the error.
-            increment_retried_entries_count(entries_count, error.status_code)
-            @log.debug "Retrying #{entries_count} log message(s) later.",
-                       error: error.to_s, error_code: error.status_code.to_s
-            raise error
-
-          rescue Google::Apis::AuthorizationError => error
-            # 401 authorization error.
-            # These are usually solved via a `gcloud auth` call, or by modifying
-            # the permissions on the Google Cloud project.
-            increment_failed_requests_count(error.status_code)
-            increment_dropped_entries_count(entries_count, error.status_code)
-            @log.warn "Dropping #{entries_count} log message(s)",
-                      error_class: error.class.to_s, error: error.to_s
-
-          rescue Google::Apis::ClientError => error
-            # 4xx client errors. Most client errors indicate a problem with the
-            # request itself and should not be retried.
-            error_details_map = construct_error_details_map(error)
-            if error_details_map.empty?
-              increment_failed_requests_count(error.status_code)
-              increment_dropped_entries_count(entries_count, error.status_code)
-              @log.warn "Dropping #{entries_count} log message(s)",
-                        error_class: error.class.to_s, error: error.to_s
-            else
-              error_details_map.each do |(error_code, error_message), indexes|
-                partial_error_count = indexes.length
-                increment_dropped_entries_count(partial_error_count, error_code)
-                entries_count -= partial_error_count
-                @log.warn "Dropping #{partial_error_count} log message(s)",
-                          error_code: "google.rpc.Code[#{error_code}]",
-                          error: error_message
-              end
-              # Consider partially successful requests successful.
-              increment_successful_requests_count
-              increment_ingested_entries_count(entries_count)
-            end
-          end
-        end
+    def construct_log_entry_in_grpc_format(labels,
+                                           resource,
+                                           severity,
+                                           ts_secs,
+                                           ts_nanos)
+      entry = Google::Logging::V2::LogEntry.new(
+        labels: labels,
+        resource: Google::Api::MonitoredResource.new(
+          type: resource.type,
+          labels: resource.labels.to_h
+        ),
+        severity: grpc_severity(severity)
+      )
+      # If "seconds" is null or not an integer, we will omit the timestamp
+      # field and defer the decision on how to handle it to the downstream
+      # Logging API. If "nanos" is null or not an integer, it will be set
+      # to 0.
+      if ts_secs.is_a?(Integer)
+        ts_nanos = 0 unless ts_nanos.is_a?(Integer)
+        entry.timestamp = Google::Protobuf::Timestamp.new(
+          seconds: ts_secs,
+          nanos: ts_nanos
+        )
       end
+      entry
     end
 
-    private
+    def construct_log_entry_in_rest_format(labels,
+                                           resource,
+                                           severity,
+                                           ts_secs,
+                                           ts_nanos)
+      # Remove the labels if we didn't populate them with anything.
+      resource.labels = nil if resource.labels.empty?
+      Google::Apis::LoggingV2::LogEntry.new(
+        labels: labels,
+        resource: resource,
+        severity: severity,
+        timestamp: {
+          seconds: ts_secs,
+          nanos: ts_nanos
+        }
+      )
+    end
+
+    def write_request_via_grpc(entries:, log_name:, resource:, labels:)
+      client = api_client
+      entries_count = entries.length
+      client.write_log_entries(
+        # Ignore partial_success for gRPC path.
+        entries,
+        log_name: log_name,
+        resource: Google::Api::MonitoredResource.new(
+          type: resource.type,
+          labels: resource.labels.to_h
+        ),
+        labels: labels.map do |k, v|
+          [k.encode('utf-8'), convert_to_utf8(v)]
+        end.to_h
+      )
+      increment_successful_requests_count
+      increment_ingested_entries_count(entries_count)
+
+      # Let the user explicitly know when the first call succeeded, to
+      # aid with verification and troubleshooting.
+      unless @successful_call
+        @successful_call = true
+        @log.info 'Successfully sent gRPC to Stackdriver Logging API.'
+      end
+
+    rescue Google::Gax::GaxError => gax_error
+      # GRPC::BadStatus is wrapped in error.cause.
+      error = gax_error.cause
+
+      # See the mapping between HTTP status and gRPC status code at:
+      # https://github.com/grpc/grpc/blob/master/src/core/lib/transport/status_conversion.cc
+      case error
+      # Server error, so retry via re-raising the error.
+      when \
+          # HTTP status 500 (Internal Server Error).
+          GRPC::Internal,
+          # HTTP status 501 (Not Implemented).
+          GRPC::Unimplemented,
+          # HTTP status 503 (Service Unavailable).
+          GRPC::Unavailable,
+          # HTTP status 504 (Gateway Timeout).
+          GRPC::DeadlineExceeded
+        increment_retried_entries_count(entries_count, error.code)
+        @log.debug "Retrying #{entries_count} log message(s) later.",
+                   error: error.to_s, error_code: error.code.to_s
+        raise error
+
+      # Most client errors indicate a problem with the request itself and
+      # should not be retried.
+      when \
+          # HTTP status 400 (Bad Request).
+          GRPC::InvalidArgument,
+          # HTTP status 401 (Unauthorized).
+          # These are usually solved via a `gcloud auth` call, or by
+          # modifying the permissions on the Google Cloud project.
+          GRPC::Unauthenticated,
+          # HTTP status 403 (Forbidden).
+          GRPC::PermissionDenied,
+          # HTTP status 404 (Not Found).
+          GRPC::NotFound,
+          # HTTP status 409 (Conflict).
+          GRPC::Aborted,
+          # HTTP status 412 (Precondition Failed).
+          GRPC::FailedPrecondition,
+          # HTTP status 429 (Too Many Requests).
+          GRPC::ResourceExhausted,
+          # HTTP status 499 (Client Closed Request).
+          GRPC::Cancelled,
+          # the remaining http codes in both 4xx and 5xx category.
+          # It's debatable whether to retry or drop these log entries.
+          # This decision is made to avoid retrying forever due to
+          # client errors.
+          GRPC::Unknown
+        increment_failed_requests_count(error.code)
+        increment_dropped_entries_count(entries_count, error.code)
+        @log.warn "Dropping #{entries_count} log message(s)",
+                  error: error.to_s, error_code: error.code.to_s
+
+      else
+        # Assume it's a problem with the request itself and don't retry.
+        increment_failed_requests_count(error.code)
+        increment_dropped_entries_count(entries_count, error.code)
+        @log.error "Unknown response code #{error.code} from the server," \
+                   " dropping #{entries_count} log message(s)",
+                   error: error.to_s, error_code: error.code.to_s
+      end
+
+    # Got an unexpected error (not Google::Gax::GaxError) from the
+    # google-cloud-logging lib.
+    rescue StandardError => error
+      increment_failed_requests_count(GRPC::Core::StatusCodes::UNKNOWN)
+      increment_dropped_entries_count(entries_count,
+                                      GRPC::Core::StatusCodes::UNKNOWN)
+      @log.error "Unexpected error type #{error.class.name} from the client" \
+                 " library, dropping #{entries_count} log message(s)",
+                 error: error.to_s
+    end
+
+    def write_request_via_rest(entries:, log_name:, resource:, labels:)
+      client = api_client
+      entries_count = entries.length
+      client.write_entry_log_entries(
+        Google::Apis::LoggingV2::WriteLogEntriesRequest.new(
+          entries: entries,
+          log_name: log_name,
+          resource: resource,
+          labels: labels,
+          partial_success: @partial_success
+        ),
+        options: { api_format_version: '2' }
+      )
+      increment_successful_requests_count
+      increment_ingested_entries_count(entries_count)
+
+      # Let the user explicitly know when the first call succeeded, to aid
+      # with verification and troubleshooting.
+      unless @successful_call
+        @successful_call = true
+        @log.info 'Successfully sent to Stackdriver Logging API.'
+      end
+
+    rescue Google::Apis::ServerError => error
+      # 5xx server errors. Retry via re-raising the error.
+      increment_retried_entries_count(entries_count, error.status_code)
+      @log.debug "Retrying #{entries_count} log message(s) later.",
+                 error: error.to_s, error_code: error.status_code.to_s
+      raise error
+
+    rescue Google::Apis::AuthorizationError => error
+      # 401 authorization error.
+      # These are usually solved via a `gcloud auth` call, or by modifying
+      # the permissions on the Google Cloud project.
+      increment_failed_requests_count(error.status_code)
+      increment_dropped_entries_count(entries_count, error.status_code)
+      @log.warn "Dropping #{entries_count} log message(s)",
+                error_class: error.class.to_s, error: error.to_s
+
+    rescue Google::Apis::ClientError => error
+      # 4xx client errors. Most client errors indicate a problem with the
+      # request itself and should not be retried.
+      error_details_map = construct_error_details_map(error)
+      if error_details_map.empty?
+        increment_failed_requests_count(error.status_code)
+        increment_dropped_entries_count(entries_count, error.status_code)
+        @log.warn "Dropping #{entries_count} log message(s)",
+                  error_class: error.class.to_s, error: error.to_s
+      else
+        error_details_map.each do |(error_code, error_message), indexes|
+          partial_error_count = indexes.length
+          increment_dropped_entries_count(partial_error_count, error_code)
+          entries_count -= partial_error_count
+          @log.warn "Dropping #{partial_error_count} log message(s)",
+                    error_code: "google.rpc.Code[#{error_code}]",
+                    error: error_message
+        end
+        # Consider partially successful requests successful.
+        increment_successful_requests_count
+        increment_ingested_entries_count(entries_count)
+      end
+    end
 
     def parse_json_or_nil(input)
       # Only here to please rubocop...

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-google-cloud
 version: !ruby/object:Gem::Version
-  version: 0.6.12
+  version: 0.6.13.pre.memory.1
 platform: ruby
 authors:
 - Todd Derr
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-07 00:00:00.000000000 Z
+date: 2018-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -87,14 +87,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.5
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.5
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -237,12 +237,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: fluentd output plugin for the Stackdriver Logging API