gapic-common 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2024379257fb476ddc9d24c767c78625a18e00ea07ddeabafa58130d1fa2185
-  data.tar.gz: cb1daa2c812ca07c9ba5dd8e4a8985b1f770538ef4051ef52ff2b9ce513d9527
+  metadata.gz: dcd83f8068cc42ed2b87bab10ef10ce8f3b3ac6cabc5980c1b52ae1279a9a7b8
+  data.tar.gz: 80137d53ab13ad21af6a083f3f72405952ff844b3b3a49ca71f3ee7339518587
 SHA512:
-  metadata.gz: aaf2ce7ebb30a22733a7e75124439d3bda7c07e06865f812f69881ff90206103325ed853c6853f70befbaa89c2de288f6ad1b642ff73ac72d59fe9917cc745a9
-  data.tar.gz: a4bf7f9d40eb38a5891701ffcb0d6779c72ca970908ad5fe3b3c312f091fd504c9ec865fdff01a81576e57a1b725197645e8a535351a17221a0e046508e8baca
+  metadata.gz: 1ff6fac4cf4699bfc105c27a179c3d733c657ea555ed5e35213f34da1a4ea20dd069b947f017b0d3da52f491f55d7a9433cd00e33fe81bb659f7b2015a77cbd9
+  data.tar.gz: 047d76f0a9627aedcc4cfe5658b21fbf9ba7371ea9fb18ec39af4bc84e1fc3e4252853ca5108850dcda681f0a4fb66aafe5cd240f527e72afde6f1709795d45f

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Release History
 
+### 0.24.0 (2024-12-05)
+
+#### Features
+
+* Log requests and responses ([#1112](https://github.com/googleapis/gapic-generator-ruby/issues/1112)) 
+#### Bug Fixes
+
+* Hardened deadline determination against Time.now hacking ([#942](https://github.com/googleapis/gapic-generator-ruby/issues/942)) 
+
 ### 0.23.0 (2024-10-15)
 
 #### Features

data/lib/gapic/common/version.rb

@@ -14,6 +14,6 @@
 
 module Gapic
   module Common
-    VERSION = "0.23.0".freeze
+    VERSION = "0.24.0".freeze
   end
 end

data/lib/gapic/grpc/service_stub/channel.rb

@@ -32,12 +32,13 @@ module Gapic
       # Creates a new Channel instance
       #
       def initialize grpc_stub_class, endpoint:, credentials:, channel_args: nil, interceptors: nil,
-                     on_channel_create: nil
+                     on_channel_create: nil, stub_logger: nil
         @grpc_stub_class = grpc_stub_class
         @endpoint = endpoint
         @credentials = credentials
         @channel_args = Hash channel_args
         @interceptors = Array interceptors
+        @stub_logger = stub_logger
         @concurrent_streams = 0
         @mutex = Mutex.new
         setup_grpc_stub
@@ -88,7 +89,8 @@ module Gapic
       def call_rpc method_name, request, options: nil, &block
         @mutex.synchronize { @concurrent_streams += 1 }
         begin
-          rpc_call = RpcCall.new @grpc_stub.method method_name
+          meth = @grpc_stub.method method_name
+          rpc_call = RpcCall.new meth, stub_logger: @stub_logger, method_name: method_name
           response = rpc_call.call request, options: options, &block
           response
         ensure

data/lib/gapic/grpc/service_stub/channel_pool.rb

@@ -30,7 +30,12 @@ module Gapic
       ##
       # Initialize an instance of ServiceStub::ChannelPool
       #
-      def initialize grpc_stub_class, endpoint:, credentials:, channel_args: nil, interceptors: nil, config: nil
+      def initialize grpc_stub_class,
+                     endpoint:, credentials:,
+                     channel_args: nil,
+                     interceptors: nil,
+                     config: nil,
+                     stub_logger: nil
         if credentials.is_a? ::GRPC::Core::Channel
           raise ArgumentError, "Can't create a channel pool with GRPC::Core::Channel as credentials"
         end
@@ -41,6 +46,7 @@ module Gapic
         @channel_args = channel_args
         @interceptors = interceptors
         @config = config || Configuration.new
+        @stub_logger = stub_logger
 
         @channels = (1..@config.channel_count).map { create_channel }
       end
@@ -49,7 +55,8 @@ module Gapic
       # Creates a new channel.
       def create_channel
         Channel.new @grpc_stub_class, endpoint: @endpoint, credentials: @credentials, channel_args: @channel_args,
-                    interceptors: @interceptors, on_channel_create: @config.on_channel_create
+                    interceptors: @interceptors, on_channel_create: @config.on_channel_create,
+                    stub_logger: @stub_logger
       end
 
       ##

data/lib/gapic/grpc/service_stub/rpc_call.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 require "gapic/call_options"
+require "gapic/logging_concerns"
 require "grpc/errors"
 
 module Gapic
@@ -32,8 +33,11 @@ module Gapic
       #
       # @param stub_method [Proc] Used to make a bare rpc call.
       #
-      def initialize stub_method
+      def initialize stub_method, stub_logger: nil, method_name: nil
         @stub_method = stub_method
+        @stub_logger = stub_logger
+        @method_name = method_name
+        @request_id = LoggingConcerns.random_uuid4
       end
 
       ##
@@ -44,7 +48,8 @@ module Gapic
       #   customize the options object, using keys that match the arguments for {Gapic::CallOptions.new}. This object
       #   should only be used once.
       #
-      # @yield [response, operation] Access the response along with the RPC operation.
+      # @yield [response, operation] Access the response along with the RPC operation. Additionally, throwing
+      #   `:response, obj` within the block will change the return value to `obj`.
       # @yieldparam response [Object] The response object.
       # @yieldparam operation [::GRPC::ActiveCall::Operation] The RPC operation for the response.
       #
@@ -91,7 +96,7 @@ module Gapic
       #   )
       #   response = echo_call.call request, options: options
       #
-      # @example Accessing the response and RPC operation using a block:
+      # @example Accessing the RPC operation using a block:
       #   require "google/showcase/v1beta1/echo_pb"
       #   require "google/showcase/v1beta1/echo_services_pb"
       #   require "gapic"
@@ -107,8 +112,8 @@ module Gapic
       #   echo_call = Gapic::ServiceStub::RpcCall.new echo_stub.method :echo
       #
       #   request = Google::Showcase::V1beta1::EchoRequest.new
-      #   echo_call.call request do |response, operation|
-      #     operation.trailing_metadata
+      #   metadata = echo_call.call request do |_response, operation|
+      #     throw :response, operation.trailing_metadata
       #   end
       #
       def call request, options: nil
@@ -117,21 +122,27 @@ module Gapic
         deadline = calculate_deadline options
         metadata = options.metadata
 
+        try_number = 1
         retried_exception = nil
         begin
+          request = log_request request, metadata, try_number
           operation = stub_method.call request, deadline: deadline, metadata: metadata, return_op: true
           response = operation.execute
-          yield response, operation if block_given?
-          response
+          catch :response do
+            response = log_response response, try_number
+            yield response, operation if block_given?
+            response
+          end
         rescue ::GRPC::DeadlineExceeded => e
+          log_response e, try_number
           raise Gapic::GRPC::DeadlineExceededError.new e.message, root_cause: retried_exception
         rescue StandardError => e
-          if e.is_a?(::GRPC::Unavailable) && /Signet::AuthorizationError/ =~ e.message
-            e = Gapic::GRPC::AuthorizationError.new e.message.gsub(%r{^\d+:}, "")
-          end
+          e = normalize_exception e
+          log_response e, try_number
 
           if check_retry?(deadline) && options.retry_policy.call(e)
             retried_exception = e
+            try_number += 1
             retry
           end
 
@@ -145,13 +156,110 @@ module Gapic
         return if options.timeout.nil?
         return if options.timeout.negative?
 
-        Time.now + options.timeout
+        current_time + options.timeout
       end
 
       def check_retry? deadline
         return true if deadline.nil?
 
-        deadline > Time.now
+        deadline > current_time
+      end
+
+      def current_time
+        # An alternative way of saying Time.now without actually calling
+        # Time.now. This allows clients that replace Time.now (e.g. via the
+        # timecop gem) to do so without interfering with the deadline.
+        nanos = Process.clock_gettime Process::CLOCK_REALTIME, :nanosecond
+        secs_part = nanos / 1_000_000_000
+        nsecs_part = nanos % 1_000_000_000
+        Time.at secs_part, nsecs_part, :nanosecond
+      end
+
+      def normalize_exception exception
+        if exception.is_a?(::GRPC::Unavailable) && /Signet::AuthorizationError/ =~ exception.message
+          exception = Gapic::GRPC::AuthorizationError.new exception.message.gsub(%r{^\d+:}, "")
+        end
+        exception
+      end
+
+      def log_request request, metadata, try_number
+        return request unless @stub_logger
+        @stub_logger.info do |entry|
+          entry.set_system_name
+          entry.set_service
+          entry.set "rpcName", @method_name
+          entry.set "retryAttempt", try_number
+          entry.set "requestId", @request_id
+          entry.message =
+            if request.is_a? Enumerable
+              "Sending stream to #{entry.service}.#{@method_name} (try #{try_number})"
+            else
+              "Sending request to #{entry.service}.#{@method_name} (try #{try_number})"
+            end
+        end
+        loggable_metadata = metadata.to_h rescue {}
+        if request.is_a? Enumerable
+          request.lazy.map do |req|
+            log_single_request req, loggable_metadata
+          end
+        else
+          log_single_request request, loggable_metadata
+        end
+      end
+
+      def log_single_request request, metadata
+        request_content = request.respond_to?(:to_h) ? (request.to_h rescue {}) : request.to_s
+        if !request_content.empty? || !metadata.empty?
+          @stub_logger.debug do |entry|
+            entry.set "requestId", @request_id
+            entry.set "request", request_content
+            entry.set "headers", metadata
+            entry.message = "(request payload as #{request.class})"
+          end
+        end
+        request
+      end
+
+      def log_response response, try_number
+        return response unless @stub_logger
+        @stub_logger.info do |entry|
+          entry.set_system_name
+          entry.set_service
+          entry.set "rpcName", @method_name
+          entry.set "retryAttempt", try_number
+          entry.set "requestId", @request_id
+          case response
+          when StandardError
+            entry.set "exception", response.to_s
+            entry.message = "Received error for #{entry.service}.#{@method_name} (try #{try_number}): #{response}"
+          when Enumerable
+            entry.message = "Receiving stream for #{entry.service}.#{@method_name} (try #{try_number})"
+          else
+            entry.message = "Received response for #{entry.service}.#{@method_name} (try #{try_number})"
+          end
+        end
+        case response
+        when StandardError
+          response
+        when Enumerable
+          response.lazy.map do |resp|
+            log_single_response resp
+          end
+        else
+          log_single_response response
+        end
+      end
+
+      def log_single_response response
+        response_content = response.respond_to?(:to_h) ? (response.to_h rescue {}) : response.to_s
+        unless response_content.empty?
+          @stub_logger.debug do |entry|
+            entry.set "requestId", @request_id
+            entry.set "response", response_content
+            entry.message = "(response payload as #{response.class})"
+          end
+        end
+        response
       end
     end
   end

data/lib/gapic/grpc/service_stub.rb

@@ -17,6 +17,7 @@ require "googleauth"
 require "gapic/grpc/service_stub/rpc_call"
 require "gapic/grpc/service_stub/channel"
 require "gapic/grpc/service_stub/channel_pool"
+require "gapic/logging_concerns"
 require "gapic/universe_domain_concerns"
 
 module Gapic
@@ -32,6 +33,7 @@ module Gapic
   #
   class ServiceStub
     include UniverseDomainConcerns
+    include LoggingConcerns
 
     attr_reader :grpc_stub
     attr_reader :channel_pool
@@ -64,6 +66,9 @@ module Gapic
     #   be used for intercepting calls before they are executed Interceptors are an EXPERIMENTAL API.
     # @param channel_pool_config [::Gapic::ServiceStub:ChannelPool::Configuration] The configuration for channel
     #     pool. This argument will raise error when `credentials` is provided as a `::GRPC::Core::Channel`.
+    # @param logger [Logger,:default,nil] An explicit logger to use, or one
+    #   of the values `:default` (the default) to construct a default logger,
+    #   or `nil` to disable logging explicitly.
     #
     def initialize grpc_stub_class,
                    credentials:,
@@ -72,13 +77,19 @@ module Gapic
                    universe_domain: nil,
                    channel_args: nil,
                    interceptors: nil,
-                   channel_pool_config: nil
+                   channel_pool_config: nil,
+                   logger: :default
       raise ArgumentError, "grpc_stub_class is required" if grpc_stub_class.nil?
 
       setup_universe_domain universe_domain: universe_domain,
                             endpoint: endpoint,
                             endpoint_template: endpoint_template,
                             credentials: credentials
+      setup_logging logger: logger,
+                    system_name: grpc_stub_class,
+                    service: grpc_stub_class,
+                    endpoint: self.endpoint,
+                    client_id: object_id
 
       @channel_pool = nil
       @grpc_stub = nil
@@ -102,7 +113,7 @@ module Gapic
       end
       @channel_pool = ChannelPool.new grpc_stub_class, endpoint: endpoint, credentials: credentials,
                         channel_args: channel_args, interceptors: interceptors,
-                        config: channel_pool_config
+                        config: channel_pool_config, stub_logger: stub_logger
     end
 
     def create_grpc_stub grpc_stub_class, endpoint:, credentials:, channel_args: nil, interceptors: nil
@@ -201,7 +212,8 @@ module Gapic
     #
     def call_rpc method_name, request, options: nil, &block
       if @channel_pool.nil?
-        rpc_call = RpcCall.new @grpc_stub.method method_name
+        meth = @grpc_stub.method method_name
+        rpc_call = RpcCall.new meth, stub_logger: stub_logger, method_name: method_name
         rpc_call.call request, options: options, &block
       else
         @channel_pool.call_rpc method_name, request, options: options, &block

data/lib/gapic/headers.rb

@@ -38,7 +38,6 @@ module Gapic
     def self.x_goog_api_client ruby_version: nil, lib_name: nil, lib_version: nil, gax_version: nil,
                                gapic_version: nil, grpc_version: nil, rest_version: nil, protobuf_version: nil,
                                transports_version_send: [:grpc]
-
       ruby_version ||= ::RUBY_VERSION
       gax_version  ||= ::Gapic::Common::VERSION
       grpc_version ||= ::GRPC::VERSION if defined? ::GRPC::VERSION

data/lib/gapic/logging_concerns.rb

@@ -0,0 +1,210 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "google/cloud/env"
+require "google/logging/message"
+require "google/logging/structured_formatter"
+
+module Gapic
+  ##
+  # A mixin module that handles logging setup for a stub.
+  #
+  module LoggingConcerns
+    ##
+    # The logger for this object.
+    #
+    # @return [Logger]
+    #
+    attr_reader :logger
+
+    ##
+    # @private
+    # A convenience object used by stub-based logging.
+    #
+    class StubLogger
+      OMIT_FILES = [
+        /^#{Regexp.escape __dir__}/
+      ].freeze
+
+      def initialize logger: nil, **kwargs
+        @logger = logger
+        @kwargs = kwargs
+      end
+
+      def log severity
+        return unless @logger
+        locations = caller_locations
+        @logger.add severity do
+          builder = LogEntryBuilder.new(**@kwargs)
+          builder.set_source_location_from locations
+          yield builder
+          builder.build
+        rescue StandardError
+          # Do nothing
+        end
+      end
+
+      def info &block
+        log Logger::INFO, &block
+      end
+
+      def debug &block
+        log Logger::DEBUG, &block
+      end
+
+      ##
+      # @private
+      # Builder for a log entry, passed to {StubLogger#log}.
+      #
+      class LogEntryBuilder
+        def initialize system_name: nil,
+                       service: nil,
+                       endpoint: nil,
+                       client_id: nil
+          @system_name = system_name
+          @service = service
+          @endpoint = endpoint
+          @client_id = client_id
+          @message = nil
+          @caller_locations = caller_locations
+          @fields = { "clientId" => @client_id }
+        end
+
+        attr_reader :system_name
+
+        attr_reader :service
+
+        attr_reader :endpoint
+
+        attr_accessor :message
+
+        attr_writer :source_location
+
+        attr_reader :fields
+
+        def set name, value
+          fields[name] = value
+        end
+
+        def set_system_name
+          set "system", system_name
+        end
+
+        def set_service
+          set "serviceName", service
+        end
+
+        def set_credentials_fields creds
+          creds = creds.client if creds.respond_to? :client
+          set "credentialsId", creds.object_id
+          set "credentialsType", creds.class.name
+          set "credentialsScope", creds.scope if creds.respond_to? :scope
+          set "useSelfSignedJWT", creds.enable_self_signed_jwt? if creds.respond_to? :enable_self_signed_jwt?
+          set "universeDomain", creds.universe_domain if creds.respond_to? :universe_domain
+        end
+
+        def source_location
+          @source_location ||= Google::Logging::SourceLocation.for_caller omit_files: OMIT_FILES,
+                                                                          locations: @caller_locations
+        end
+
+        def set_source_location_from locations
+          @caller_locations = locations
+          @source_location = nil
+        end
+
+        def build
+          Google::Logging::Message.from message: message, source_location: source_location, fields: fields
+        end
+      end
+    end
+
+    ##
+    # @private
+    # Initialize logging concerns.
+    #
+    def setup_logging logger: :default,
+                      stream: nil,
+                      formatter: nil,
+                      level: nil,
+                      system_name: nil,
+                      service: nil,
+                      endpoint: nil,
+                      client_id: nil
+      service = LoggingConcerns.normalize_service service
+      system_name = LoggingConcerns.normalize_system_name system_name
+      logging_env = ENV["GOOGLE_SDK_RUBY_LOGGING_GEMS"].to_s.downcase
+      logger = nil if ["false", "none"].include? logging_env
+      if logger == :default
+        logger = nil
+        if ["true", "all"].include?(logging_env) || logging_env.split(",").include?(system_name)
+          stream ||= $stderr
+          level ||= "DEBUG"
+          formatter ||= Google::Logging::StructuredFormatter.new if Google::Cloud::Env.get.logging_agent_expected?
+          logger = Logger.new stream, progname: system_name, level: level, formatter: formatter
+        end
+      end
+      @logger = logger
+      @stub_logger = StubLogger.new logger: logger,
+                                    system_name: system_name,
+                                    service: service,
+                                    endpoint: endpoint,
+                                    client_id: client_id
+    end
+
+    # @private
+    attr_reader :stub_logger
+
+    class << self
+      # @private
+      def random_uuid4
+        ary = Random.bytes 16
+        ary.setbyte 6, ((ary.getbyte(6) & 0x0f) | 0x40)
+        ary.setbyte 8, ((ary.getbyte(8) & 0x3f) | 0x80)
+        ary.unpack("H8H4H4H4H12").join "-"
+      end
+
+      # @private
+      def normalize_system_name input
+        case input
+        when String
+          input
+        when Class
+          input.name.split("::")[..-3]
+               .map { |elem| elem.scan(/[A-Z][A-Z]*(?=[A-Z][a-z0-9]|$)|[A-Z][a-z0-9]+/).map(&:downcase).join("_") }
+               .join("-")
+        else
+          "googleapis"
+        end
+      end
+
+      # @private
+      def normalize_service input
+        case input
+        when String
+          input
+        when Class
+          mod = input.name.split("::")[..-2].inject(Object) { |m, n| m.const_get n }
+          if mod.const_defined? "Service"
+            mod.const_get("Service").service_name
+          else
+            name_segments = input.name.split("::")[..-3]
+            mod = name_segments.inject(Object) { |m, n| m.const_get n }
+            name_segments.join "." if mod.const_defined? "Rest"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gapic/rest/client_stub.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 require "googleauth"
+require "gapic/logging_concerns"
 require "gapic/rest/faraday_middleware"
 require "gapic/universe_domain_concerns"
 require "faraday/retry"
@@ -28,9 +29,11 @@ module Gapic
     #
     class ClientStub
       include UniverseDomainConcerns
+      include LoggingConcerns
 
       ##
       # Initializes with an endpoint and credentials
+      #
       # @param endpoint [String] The endpoint of the API. Overrides any endpoint_template.
       # @param endpoint_template [String] The endpoint of the API, where the
       #   universe domain component of the hostname is marked by the string in
@@ -41,12 +44,14 @@ module Gapic
       #   Credentials to send with calls in form of a googleauth credentials object.
       #   (see the [googleauth docs](https://googleapis.dev/ruby/googleauth/latest/index.html))
       # @param numeric_enums [Boolean] Whether to signal the server to JSON-encode enums as ints
-      #
       # @param raise_faraday_errors [Boolean]
       #   Whether to raise Faraday errors instead of wrapping them in `Gapic::Rest::Error`
       #   Added for backwards compatibility.
       #   Default is `true`. All REST clients (except for old versions of `google-cloud-compute-v1`)
       #   should explicitly set this parameter to `false`.
+      # @param logger [Logger,:default,nil] An explicit logger to use, or one
+      #   of the values `:default` (the default) to construct a default logger,
+      #   or `nil` to disable logging explicitly.
       #
       # @yield [Faraday::Connection]
       #
@@ -55,7 +60,10 @@ module Gapic
                      endpoint_template: nil,
                      universe_domain: nil,
                      numeric_enums: false,
-                     raise_faraday_errors: true
+                     raise_faraday_errors: true,
+                     logging_system: nil,
+                     service_name: nil,
+                     logger: :default
         setup_universe_domain universe_domain: universe_domain,
                               endpoint: endpoint,
                               endpoint_template: endpoint_template,
@@ -65,6 +73,12 @@ module Gapic
         endpoint_url = "https://#{endpoint_url}" unless /^https?:/.match? endpoint_url
         endpoint_url = endpoint_url.sub %r{/$}, ""
 
+        setup_logging logger: logger,
+                      system_name: logging_system,
+                      service: service_name,
+                      endpoint: endpoint_url,
+                      client_id: object_id
+
         @numeric_enums = numeric_enums
 
         @raise_faraday_errors = raise_faraday_errors
@@ -88,8 +102,8 @@ module Gapic
       # @param options [::Gapic::CallOptions,Hash] gapic options to be applied
       #     to the REST call. Currently only timeout and headers are supported.
       # @return [Faraday::Response]
-      def make_get_request uri:, params: {}, options: {}
-        make_http_request :get, uri: uri, body: nil, params: params, options: options
+      def make_get_request uri:, params: {}, options: {}, method_name: nil
+        make_http_request :get, uri: uri, body: nil, params: params, options: options, method_name: method_name
       end
 
       ##
@@ -100,8 +114,8 @@ module Gapic
       # @param options [::Gapic::CallOptions,Hash] gapic options to be applied
       #     to the REST call. Currently only timeout and headers are supported.
       # @return [Faraday::Response]
-      def make_delete_request uri:, params: {}, options: {}
-        make_http_request :delete, uri: uri, body: nil, params: params, options: options
+      def make_delete_request uri:, params: {}, options: {}, method_name: nil
+        make_http_request :delete, uri: uri, body: nil, params: params, options: options, method_name: method_name
       end
 
       ##
@@ -113,8 +127,8 @@ module Gapic
       # @param options [::Gapic::CallOptions,Hash] gapic options to be applied
       #     to the REST call. Currently only timeout and headers are supported.
       # @return [Faraday::Response]
-      def make_patch_request uri:, body:, params: {}, options: {}
-        make_http_request :patch, uri: uri, body: body, params: params, options: options
+      def make_patch_request uri:, body:, params: {}, options: {}, method_name: nil
+        make_http_request :patch, uri: uri, body: body, params: params, options: options, method_name: method_name
       end
 
       ##
@@ -126,8 +140,8 @@ module Gapic
       # @param options [::Gapic::CallOptions,Hash] gapic options to be applied
       #     to the REST call. Currently only timeout and headers are supported.
       # @return [Faraday::Response]
-      def make_post_request uri:, body: nil, params: {}, options: {}
-        make_http_request :post, uri: uri, body: body, params: params, options: options
+      def make_post_request uri:, body: nil, params: {}, options: {}, method_name: nil
+        make_http_request :post, uri: uri, body: body, params: params, options: options, method_name: method_name
       end
 
       ##
@@ -139,8 +153,8 @@ module Gapic
       # @param options [::Gapic::CallOptions,Hash] gapic options to be applied
       #     to the REST call. Currently only timeout and headers are supported.
       # @return [Faraday::Response]
-      def make_put_request uri:, body: nil, params: {}, options: {}
-        make_http_request :put, uri: uri, body: body, params: params, options: options
+      def make_put_request uri:, body: nil, params: {}, options: {}, method_name: nil
+        make_http_request :put, uri: uri, body: body, params: params, options: options, method_name: method_name
       end
 
       ##
@@ -154,27 +168,38 @@ module Gapic
       # @param is_server_streaming [Boolean] flag if method is streaming
       # @yieldparam chunk [String] The chunk of data received during server streaming.
       # @return [Faraday::Response]
-      def make_http_request verb, uri:, body:, params:, options:, is_server_streaming: false, &block
+      def make_http_request verb,
+                            uri:, body:, params:, options:,
+                            is_server_streaming: false, method_name: nil,
+                            &block
         # Converts hash and nil to an options object
         options = ::Gapic::CallOptions.new(**options.to_h) unless options.is_a? ::Gapic::CallOptions
         deadline = calculate_deadline options
         retried_exception = nil
         next_timeout = get_timeout deadline
+        request_id = LoggingConcerns.random_uuid4
+        try_number = 1
 
         begin
-          base_make_http_request(verb: verb, uri: uri, body: body,
-                                 params: params, metadata: options.metadata,
-                                 timeout: next_timeout,
-                                 is_server_streaming: is_server_streaming,
-                                 &block)
+          log_request method_name, request_id, try_number, body, options.metadata
+          response = base_make_http_request verb: verb, uri: uri, body: body,
+                                            params: params, metadata: options.metadata,
+                                            timeout: next_timeout,
+                                            is_server_streaming: is_server_streaming,
+                                            &block
+          log_response method_name, request_id, try_number, response, is_server_streaming
+          response
         rescue ::Faraday::TimeoutError => e
+          log_response method_name, request_id, try_number, e, is_server_streaming
           raise if @raise_faraday_errors
           raise Gapic::Rest::DeadlineExceededError.wrap_faraday_error e, root_cause: retried_exception
         rescue ::Faraday::Error => e
+          log_response method_name, request_id, try_number, e, is_server_streaming
           next_timeout = get_timeout deadline
 
           if check_retry?(next_timeout) && options.retry_policy.call(e)
             retried_exception = e
+            try_number += 1
             retry
           end
 
@@ -251,6 +276,54 @@ module Gapic
 
         timeout.positive?
       end
+
+      def log_request method_name, request_id, try_number, body, metadata
+        return unless stub_logger
+        stub_logger.info do |entry|
+          entry.set_system_name
+          entry.set_service
+          entry.set "rpcName", method_name
+          entry.set "retryAttempt", try_number
+          entry.set "requestId", request_id
+          entry.message = "Sending request to #{entry.service}.#{method_name} (try #{try_number})"
+        end
+        body = body.to_s
+        metadata = metadata.to_h rescue {}
+        return if body.empty? && metadata.empty?
+        stub_logger.debug do |entry|
+          entry.set "requestId", request_id
+          entry.set "request", body
+          entry.set "headers", metadata
+          entry.message = "(request payload as JSON)"
+        end
+      end
+
+      def log_response method_name, request_id, try_number, response, is_server_streaming
+        return unless stub_logger
+        stub_logger.info do |entry|
+          entry.set_system_name
+          entry.set_service
+          entry.set "rpcName", method_name
+          entry.set "retryAttempt", try_number
+          entry.set "requestId", request_id
+          if response.is_a? StandardError
+            entry.set "exception", response.to_s
+            entry.message = "Received error for #{entry.service}.#{method_name} (try #{try_number}): #{response}"
+          elsif is_server_streaming
+            entry.message = "Receiving stream for #{entry.service}.#{method_name} (try #{try_number})"
+          else
+            entry.message = "Received response for #{entry.service}.#{method_name} (try #{try_number})"
+          end
+        end
+        return if is_server_streaming || !response.respond_to?(:body)
+        body = response.body.to_s
+        return if body.empty?
+        stub_logger.debug do |entry|
+          entry.set "requestId", request_id
+          entry.set "response", body
+          entry.message = "(response payload as JSON)"
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gapic-common
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Google API Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-23 00:00:00.000000000 Z
+date: 2024-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -84,14 +84,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: google-cloud-env
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: google-logging-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
@@ -118,14 +146,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.65'
+        version: '1.66'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.65'
+        version: '1.66'
 description: 
 email:
 - googleapis-packages@google.com
@@ -159,6 +187,7 @@ files:
 - lib/gapic/grpc/service_stub/rpc_call.rb
 - lib/gapic/grpc/status_details.rb
 - lib/gapic/headers.rb
+- lib/gapic/logging_concerns.rb
 - lib/gapic/lru_hash.rb
 - lib/gapic/operation.rb
 - lib/gapic/operation/retry_policy.rb
@@ -196,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.21
+rubygems_version: 3.5.23
 signing_key: 
 specification_version: 4
 summary: Common code for GAPIC-generated API clients