fluent-plugin-google-cloud 0.10.0 → 0.10.5

data/test/plugin/test_out_google_cloud.rb

@@ -86,13 +86,21 @@ class GoogleCloudOutputTest < Test::Unit::TestCase
     end
     d.run
     assert_prometheus_metric_value(
-      :stackdriver_successful_requests_count, 1, grpc: false, code: 200)
+      :stackdriver_successful_requests_count, 1,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 200)
     assert_prometheus_metric_value(
-      :stackdriver_ingested_entries_count, 1, grpc: false, code: 200)
+      :stackdriver_ingested_entries_count, 1,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 200)
     assert_prometheus_metric_value(
-      :stackdriver_dropped_entries_count, 2, grpc: false, code: 3)
+      :stackdriver_dropped_entries_count, 2,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 3)
     assert_prometheus_metric_value(
-      :stackdriver_dropped_entries_count, 1, grpc: false, code: 7)
+      :stackdriver_dropped_entries_count, 1,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 7)
     assert_requested(:post, WRITE_LOG_ENTRIES_URI, times: 1)
   end
 
@@ -109,13 +117,21 @@ class GoogleCloudOutputTest < Test::Unit::TestCase
     d.emit('message' => log_entry(0))
     d.run
     assert_prometheus_metric_value(
-      :stackdriver_successful_requests_count, 0, grpc: false, code: 200)
+      :stackdriver_successful_requests_count, 0,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 200)
     assert_prometheus_metric_value(
-      :stackdriver_failed_requests_count, 1, grpc: false, code: 400)
+      :stackdriver_failed_requests_count, 1,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 400)
     assert_prometheus_metric_value(
-      :stackdriver_ingested_entries_count, 0, grpc: false, code: 200)
+      :stackdriver_ingested_entries_count, 0,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 200)
     assert_prometheus_metric_value(
-      :stackdriver_dropped_entries_count, 1, grpc: false, code: 400)
+      :stackdriver_dropped_entries_count, 1,
+      'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+      grpc: false, code: 400)
     assert_requested(:post, WRITE_LOG_ENTRIES_URI, times: 1)
   end
 
@@ -138,71 +154,6 @@ class GoogleCloudOutputTest < Test::Unit::TestCase
     assert_equal 1, exception_count
   end
 
-  # TODO: The code in the non-gRPC and gRPC tests is nearly identical.
-  # Refactor and remove duplication.
-  # TODO: Use status codes instead of int literals.
-  def test_metrics
-    setup_gce_metadata_stubs
-    [
-      [ENABLE_PROMETHEUS_CONFIG, method(:assert_prometheus_metric_value)],
-      [ENABLE_OPENCENSUS_CONFIG, method(:assert_opencensus_metric_value)]
-    ].each do |config, assert_metric_value|
-      [
-        # Single successful request.
-        [200, 1, 1, [1, 0, 1, 0, 0]],
-        # Several successful requests.
-        [200, 2, 1, [2, 0, 2, 0, 0]],
-        # Single successful request with several entries.
-        [200, 1, 2, [1, 0, 2, 0, 0]],
-        # Single failed request that causes logs to be dropped.
-        [401, 1, 1, [0, 1, 0, 1, 0]],
-        # Single failed request that escalates without logs being dropped with
-        # several entries.
-        [500, 1, 2, [0, 0, 0, 0, 2]]
-      ].each do |code, request_count, entry_count, metric_values|
-        clear_metrics
-        # TODO: Do this as part of setup_logging_stubs.
-        stub_request(:post, WRITE_LOG_ENTRIES_URI)
-          .to_return(status: code, body: 'Some Message')
-        (1..request_count).each do
-          d = create_driver(config)
-          (1..entry_count).each do |i|
-            d.emit('message' => log_entry(i.to_s))
-          end
-          # rubocop:disable Lint/HandleExceptions
-          begin
-            d.run
-          rescue Google::Apis::AuthorizationError
-          rescue Google::Apis::ServerError
-          end
-          # rubocop:enable Lint/HandleExceptions
-        end
-        successful_requests_count, failed_requests_count,
-        ingested_entries_count, dropped_entries_count,
-        retried_entries_count = metric_values
-        assert_metric_value.call(:stackdriver_successful_requests_count,
-                                 successful_requests_count,
-                                 grpc: false, code: 200)
-        assert_metric_value.call(:stackdriver_ingested_entries_count,
-                                 ingested_entries_count,
-                                 grpc: false, code: 200)
-        assert_metric_value.call(:stackdriver_retried_entries_count,
-                                 retried_entries_count,
-                                 grpc: false, code: code)
-        # Skip failure assertions when code indicates success, because the
-        # assertion will fail in the case when a single metric contains time
-        # series with success and failure events.
-        next if code == 200
-        assert_metric_value.call(:stackdriver_failed_requests_count,
-                                 failed_requests_count,
-                                 grpc: false, code: code)
-        assert_metric_value.call(:stackdriver_dropped_entries_count,
-                                 dropped_entries_count,
-                                 grpc: false, code: code)
-      end
-    end
-  end
-
   # This test looks similar between the grpc and non-grpc paths except that when
   # parsing "105", the grpc path responds with "DEBUG", while the non-grpc path
   # responds with "100".
@@ -400,14 +351,39 @@ class GoogleCloudOutputTest < Test::Unit::TestCase
   end
 
   # Set up http stubs to mock the external calls.
-  def setup_logging_stubs
+  def setup_logging_stubs(_error = nil, code = nil, message = 'some message')
     stub_request(:post, WRITE_LOG_ENTRIES_URI).to_return do |request|
       @logs_sent << JSON.parse(request.body)
-      { body: '' }
+      { status: code, body: message }
     end
     yield
   end
 
+  # Whether this is the grpc path
+  def use_grpc
+    false
+  end
+
+  # The OK status code for the grpc path.
+  def ok_status_code
+    200
+  end
+
+  # A client side error status code for the grpc path.
+  def client_error_status_code
+    401
+  end
+
+  # A server side error status code for the grpc path.
+  def server_error_status_code
+    500
+  end
+
+  # The parent error type to expect in the mock
+  def mock_error_type
+    Google::Apis::Error
+  end
+
   # The conversions from user input to output.
   def latency_conversion
     {

data/test/plugin/test_out_google_cloud_grpc.rb

@@ -60,8 +60,7 @@ class GoogleCloudOutputGRPCTest < Test::Unit::TestCase
       GRPC::Core::StatusCodes::ABORTED => 'Aborted',
       GRPC::Core::StatusCodes::UNAUTHENTICATED => 'Unauthenticated'
     }.each_with_index do |(code, message), index|
-      setup_logging_stubs(
-        GRPC::BadStatus.new_status_exception(code, message)) do
+      setup_logging_stubs(nil, code, message) do
         d = create_driver(USE_GRPC_CONFIG, 'test')
         # The API Client should not retry this and the plugin should consume the
         # exception.
@@ -99,19 +98,24 @@ class GoogleCloudOutputGRPCTest < Test::Unit::TestCase
       d.run
       assert_prometheus_metric_value(
         :stackdriver_successful_requests_count, 1,
-        grpc: true, code: GRPC::Core::StatusCodes::OK)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::OK)
       assert_prometheus_metric_value(
         :stackdriver_failed_requests_count, 0,
-        grpc: true, code: GRPC::Core::StatusCodes::PERMISSION_DENIED)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::PERMISSION_DENIED)
       assert_prometheus_metric_value(
         :stackdriver_ingested_entries_count, 1,
-        grpc: true, code: GRPC::Core::StatusCodes::OK)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::OK)
       assert_prometheus_metric_value(
         :stackdriver_dropped_entries_count, 2,
-        grpc: true, code: GRPC::Core::StatusCodes::INVALID_ARGUMENT)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::INVALID_ARGUMENT)
       assert_prometheus_metric_value(
         :stackdriver_dropped_entries_count, 1,
-        grpc: true, code: GRPC::Core::StatusCodes::PERMISSION_DENIED)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::PERMISSION_DENIED)
     end
   end
 
@@ -128,16 +132,20 @@ class GoogleCloudOutputGRPCTest < Test::Unit::TestCase
       d.run
       assert_prometheus_metric_value(
         :stackdriver_successful_requests_count, 0,
-        grpc: true, code: GRPC::Core::StatusCodes::OK)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::OK)
       assert_prometheus_metric_value(
         :stackdriver_failed_requests_count, 1,
-        grpc: true, code: GRPC::Core::StatusCodes::INVALID_ARGUMENT)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::INVALID_ARGUMENT)
       assert_prometheus_metric_value(
         :stackdriver_ingested_entries_count, 0,
-        grpc: true, code: GRPC::Core::StatusCodes::OK)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::OK)
       assert_prometheus_metric_value(
         :stackdriver_dropped_entries_count, 1,
-        grpc: true, code: GRPC::Core::StatusCodes::INVALID_ARGUMENT)
+        'agent.googleapis.com/agent', OpenCensus::Stats::Aggregation::Sum, d,
+        grpc: use_grpc, code: GRPC::Core::StatusCodes::INVALID_ARGUMENT)
     end
   end
 
@@ -150,8 +158,7 @@ class GoogleCloudOutputGRPCTest < Test::Unit::TestCase
       GRPC::Core::StatusCodes::UNAVAILABLE => 'Unavailable'
     }.each_with_index do |(code, message), index|
       exception_count = 0
-      setup_logging_stubs(
-        GRPC::BadStatus.new_status_exception(code, message)) do
+      setup_logging_stubs(nil, code, message) do
         d = create_driver(USE_GRPC_CONFIG, 'test')
         # The API client should retry this once, then throw an exception which
         # gets propagated through the plugin
@@ -168,72 +175,6 @@ class GoogleCloudOutputGRPCTest < Test::Unit::TestCase
     end
   end
 
-  # TODO: The code in the non-gRPC and gRPC tests is nearly identical.
-  # Refactor and remove duplication.
-  # TODO: Use status codes instead of int literals.
-  def test_metrics
-    setup_gce_metadata_stubs
-    [
-      [ENABLE_PROMETHEUS_CONFIG, method(:assert_prometheus_metric_value)],
-      [ENABLE_OPENCENSUS_CONFIG, method(:assert_opencensus_metric_value)]
-    ].each do |config, assert_metric_value|
-      [
-        # Single successful request.
-        [false, 0, 1, 1, [1, 0, 1, 0, 0]],
-        # Several successful requests.
-        [false, 0, 2, 1, [2, 0, 2, 0, 0]],
-        # Single successful request with several entries.
-        [false, 0, 1, 2, [1, 0, 2, 0, 0]],
-        # Single failed request that causes logs to be dropped.
-        [true, 16, 1, 1, [0, 1, 0, 1, 0]],
-        # Single failed request that escalates without logs being dropped with
-        # several entries.
-        [true, 13, 1, 2, [0, 0, 0, 0, 2]]
-      ].each do |should_fail, code, request_count, entry_count, metric_values|
-        clear_metrics
-        (1..request_count).each do
-          setup_logging_stubs(
-            if should_fail
-              GRPC::BadStatus.new_status_exception(code, 'SomeMessage')
-            end) do
-            d = create_driver(USE_GRPC_CONFIG + config, 'test')
-            (1..entry_count).each do |i|
-              d.emit('message' => log_entry(i.to_s))
-            end
-            # rubocop:disable Lint/HandleExceptions
-            begin
-              d.run
-            rescue GRPC::BadStatus
-            end
-            # rubocop:enable Lint/HandleExceptions
-          end
-        end
-        successful_requests_count, failed_requests_count,
-        ingested_entries_count, dropped_entries_count,
-        retried_entries_count = metric_values
-        assert_metric_value.call(:stackdriver_successful_requests_count,
-                                 successful_requests_count,
-                                 grpc: true, code: 0)
-        assert_metric_value.call(:stackdriver_ingested_entries_count,
-                                 ingested_entries_count,
-                                 grpc: true, code: 0)
-        assert_metric_value.call(:stackdriver_retried_entries_count,
-                                 retried_entries_count,
-                                 grpc: true, code: code)
-        # Skip failure assertions when code indicates success, because the
-        # assertion will fail in the case when a single metric contains time
-        # series with success and failure events.
-        next if code == 0
-        assert_metric_value.call(:stackdriver_failed_requests_count,
-                                 failed_requests_count,
-                                 grpc: true, code: code)
-        assert_metric_value.call(:stackdriver_dropped_entries_count,
-                                 dropped_entries_count,
-                                 grpc: true, code: code)
-      end
-    end
-  end
-
   # This test looks similar between the grpc and non-grpc paths except that when
   # parsing "105", the grpc path responds with "DEBUG", while the non-grpc path
   # responds with "100".
@@ -428,17 +369,45 @@ class GoogleCloudOutputGRPCTest < Test::Unit::TestCase
   end
 
   # Set up grpc stubs to mock the external calls.
-  def setup_logging_stubs(error = nil)
-    if error.nil?
+  def setup_logging_stubs(error = nil, code = nil, message = 'some message')
+    if error.nil? && (code.nil? || code == 0)
       @requests_sent = []
       @grpc_stub = GRPCLoggingMockService.new(@requests_sent)
     else
       @failed_attempts = []
+      # Only fall back to constructing an error with code and message if no
+      # error is passed in.
+      error ||= GRPC::BadStatus.new_status_exception(code, message)
       @grpc_stub = GRPCLoggingMockFailingService.new(error, @failed_attempts)
     end
     yield
   end
 
+  # Whether this is the grpc path
+  def use_grpc
+    true
+  end
+
+  # The OK status code for the grpc path.
+  def ok_status_code
+    0
+  end
+
+  # A client side error status code for the grpc path.
+  def client_error_status_code
+    16
+  end
+
+  # A server side error status code for the grpc path.
+  def server_error_status_code
+    13
+  end
+
+  # The parent error type to expect in the mock
+  def mock_error_type
+    GRPC::BadStatus
+  end
+
   # Verify the number and the content of the log entries match the expectation.
   # The caller can optionally provide a block which is called for each entry.
   def verify_log_entries(n, params, payload_type = 'textPayload',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-google-cloud
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.5
 platform: ruby
 authors:
 - Stackdriver Agents Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-13 00:00:00.000000000 Z
+date: 2021-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.30.2
+        version: 1.31.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.30.2
+        version: 1.31.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement