google-ads-googleads 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a1a539dda2e56f08c9b1daac7d65c2a31a8f78d20906f3a1f9e393c65c8d563
-  data.tar.gz: 0543d6351bab5085cefe55b257659145f9405252c31de9b7d7885184de995984
+  metadata.gz: 4cf7ec45c64d8e3b15c113cedc904e46d667d301740608146d0985537f6e3e44
+  data.tar.gz: 0a33073c1cf8401df2388172f6026d4c0cbe3a4f8f8e81b5da710ac57766dc01
 SHA512:
-  metadata.gz: 775083f4e4d3f15f33607ab7cd0bdc7ff232118536617bb6d8e0abc90f1f4bec0c2cd9de32b7f46432c15905f2295af477510bf1648c6c92ec596378a7fc257f
-  data.tar.gz: af918d18fee221dd34da5453538bb81670591d56bea0467d27a57204c0ab67f8b708d3e13ec83d2116e4789d4213b772ecccd5ad847212af9cac248c1a0d7073
+  metadata.gz: 0d36f3d385b11ce0efa43e7c4008af8569f4b3f1133d8c151eb1cf472958c50489c3dbd43c8180935588a21ef47413fea5135785187b84297a3ab27b28f2d012
+  data.tar.gz: 7c42c6b2bc5edb4f5b795ffe5b5316d0e5a539a6ceaa5dd1a913b5c7f1c54a61c4bc5f0873ea3ac8c215ebe8599699a54df712dd962a94fc3b9c6e50725bc945

data/ChangeLog

@@ -1,3 +1,11 @@
+1.1.0:
+  - Adding support for Google Ads API v1_1.
+  - Refactored proto and path lookup utils to be accessible before client
+    instantiation.
+  - Numerous fixes to logging, including support for logging large images and
+    partial failure errors.
+  - New partial failure decoder utility.
+
 1.0.0:
   - Adding support for Google Ads API v1.
   - Adding support for versioned path and proto lookup utils.

data/google_ads_config.rb

@@ -31,4 +31,10 @@ Google::Ads::GoogleAds::Config.new do |c|
   # You can provide a filename as a String, an IO object like STDOUT or STDERR,
   # or an open file.
   c.log_target = STDOUT
+
+  # Instead of specifying logging through level and target, you can also
+  # pass a logger directly (for e.g. passing Rails.logger in a
+  # config/initializer). The passed logger will override log_level and
+  # log_target
+  # c.logger = Logger.new(STDOUT)
 end

data/lib/google/ads/google_ads/api_versions.rb

@@ -0,0 +1,8 @@
+module Google
+  module Ads
+    module GoogleAds
+      KNOWN_API_VERSIONS = [:V0, :V1]
+      DEFAULT_API_VERSION = :V1
+    end
+  end
+end

data/lib/google/ads/google_ads/config.rb

@@ -28,6 +28,7 @@ module Google
 
         attr_accessor :log_level
         attr_accessor :log_target
+        attr_accessor :logger
 
         def initialize(&block)
           @refresh_token = nil
@@ -38,6 +39,7 @@ module Google
 
           @log_level = nil
           @log_target = nil
+          @logger = nil
           yield self if block_given?
         end
 

data/lib/google/ads/google_ads/google_ads_client.rb

@@ -55,6 +55,7 @@ require 'googleauth'
 require 'google/ads/google_ads/patches'
 require 'google/ads/google_ads/config'
 require 'google/ads/google_ads/field_mask_util'
+require 'google/ads/google_ads/lookup_util'
 require 'google/ads/google_ads/wrapper_util'
 require 'google/ads/google_ads/logging_interceptor'
 
@@ -69,12 +70,12 @@ module Google
   module Ads
     module GoogleAds
       class GoogleAdsClient
-        DEFAULT_API_VERSION = :V1
-        KNOWN_API_VERSIONS = [:V0, :V1]
 
         DEFAULT_CONFIG_FILENAME = 'google_ads_config.rb'
 
         attr_reader :logger
+        # Allow setting the lookup_util manually for users who use it before creating the client.
+        attr_writer :lookup_util
 
         def initialize(config_path = nil, &block)
           if block_given?
@@ -103,8 +104,6 @@ module Google
             end
             @config = eval_result
           end
-          @proto_lookup_utils = {}
-          @path_lookup_utils = {}
 
           begin
             @logger = create_default_logger
@@ -122,21 +121,24 @@ module Google
         # :Campaign will return an instantiated CampaignServiceClient.
         #
         # Raises ArgumentError if no service can be found for the provided type.
-        def service(name, version = DEFAULT_API_VERSION)
+        def service(name, version = default_api_version)
           service_path = ENV['GOOGLEADS_SERVICE_PATH']
 
           # We need a local reference to refer to from within the class block
           # below.
           logger = @logger
 
-          class_to_return = proto_lookup_util(version).service(name)
+          class_to_return = lookup_util.raw_service(name, version)
           class_to_return = Class.new(class_to_return) do
             unless service_path.nil? || service_path.empty?
               const_set('SERVICE_ADDRESS', service_path.freeze)
             end
-            logging_interceptor =
-                Google::Ads::GoogleAds::LoggingInterceptor.new(logger)
-            const_set('GRPC_INTERCEPTORS', [logging_interceptor])
+
+            if logger
+              logging_interceptor =
+                  Google::Ads::GoogleAds::LoggingInterceptor.new(logger)
+              const_set('GRPC_INTERCEPTORS', [logging_interceptor])
+            end
           end
 
           headers = {
@@ -144,7 +146,7 @@ module Google
           }
           if @config.login_customer_id
             login_customer_id = @config.login_customer_id
-            if !login_customer_id.is_a? Integer || login_customer_id <= 0 ||
+            if !login_customer_id.is_a?(Integer) || login_customer_id <= 0 ||
                 login_customer_id > 9_999_999_999
               raise sprintf('Invalid login_customer_id. Must be an integer ' \
                   '0 < x <= 9,999,999,999. Got %s', login_customer_id)
@@ -162,16 +164,16 @@ module Google
         # example, passing :Campaign will return an instantiated Campaign.
         #
         # Raises ArgumentError if no entity can be found for the provided type.
-        def resource(name, version = DEFAULT_API_VERSION)
-          proto_lookup_util(version).resource(name).new
+        def resource(name, version = default_api_version)
+          lookup_util.resource(name, version)
         end
 
         # Return an operation for the provided entity type. For example, passing
         # :Campaign will return an instantiated CampaignOperation.
         #
         # Raises ArgumentError if no entity can be found for the provided type.
-        def operation(name, version = DEFAULT_API_VERSION)
-          proto_lookup_util(version).operation(name).new
+        def operation(name, version = default_api_version)
+          lookup_util.operation(name, version)
         end
 
         # Return a reference to the enum class for the provided enum type. For
@@ -179,8 +181,8 @@ module Google
         # CampaignStatusEnum.
         #
         # Raises ArgumentError if no enum can be found for the provided type.
-        def enum(name, version = DEFAULT_API_VERSION)
-          proto_lookup_util(version).enum(name)
+        def enum(name, version = default_api_version)
+          lookup_util.enum(name, version)
         end
 
         # Returns a reference to the FieldMaskUtil class for ease of access.
@@ -194,8 +196,8 @@ module Google
         end
 
         # Returns a reference to the PathLookupUtil to generate resource names.
-        def path(version = DEFAULT_API_VERSION)
-          path_lookup_util(version)
+        def path(version = default_api_version)
+          lookup_util.path(version)
         end
 
         # Set the logger to use. This will only take effect on services fetched
@@ -204,6 +206,13 @@ module Google
           @logger = logger
         end
 
+        # Decode a partial failure error from a response.
+        # See Google::Ads::GoogleAds::PartialFailureErrorDecoder for full
+        # documentation.
+        def decode_partial_failure_error(pfe)
+          PartialFailureErrorDecoder.decode(pfe)
+        end
+
         private
 
         ERROR_TRANSFORMER = Proc.new do |gax_error|
@@ -249,59 +258,21 @@ module Google
 
         # Create the default logger, useful if the user hasn't defined one.
         def create_default_logger()
-          logger = Logger.new(@config.log_target)
-          logger.level = Logger.const_get(@config.log_level)
-          return logger
-        end
-
-        def valid_version?(version)
-          KNOWN_API_VERSIONS.include?(version)
-        end
-
-        # Load up the proto lookup util for the given version, storing a copy
-        # of it if this is the first time we needed it.
-        def proto_lookup_util(version)
-          unless valid_version?(version)
-            raise sprintf('Unknown version %s', version)
-          end
-          if @proto_lookup_utils[version].nil?
-            path_version = version.downcase
-            require sprintf('google/ads/google_ads/utils/%s/proto_lookup_util',
-                path_version)
-            class_path = sprintf(
-              'Google::Ads::GoogleAds::Utils::%s::ProtoLookupUtil',
-              version
-            )
-            @proto_lookup_utils[version] = class_for_path(class_path).new
+          if @config.logger.nil?
+            logger = Logger.new(@config.log_target)
+            logger.level = Logger.const_get(@config.log_level)
+            logger
+          else
+            @config.logger
           end
-          @proto_lookup_utils[version]
         end
 
-        # Load up the path lookup util for the given version, storing a copy
-        # of it if this is the first time we needed it.
-        def path_lookup_util(version)
-          unless valid_version?(version)
-            raise sprintf('Unknown version %s', version)
-          end
-          if @path_lookup_utils[version].nil?
-            path_version = version.downcase
-            require sprintf('google/ads/google_ads/utils/%s/path_lookup_util',
-                path_version)
-            class_path = sprintf(
-              'Google::Ads::GoogleAds::Utils::%s::PathLookupUtil',
-              version
-            )
-            @path_lookup_utils[version] = class_for_path(class_path).new(
-                proto_lookup_util(version))
-          end
-          @path_lookup_utils[version]
+        def lookup_util
+          @lookup_util ||= Google::Ads::GoogleAds::LookupUtil.new
         end
 
-        # Converts complete class path into class object.
-        def class_for_path(path)
-          path.split('::').inject(Kernel) do |scope, const_name|
-            scope.const_get(const_name)
-          end
+        def default_api_version
+          Google::Ads::GoogleAds::DEFAULT_API_VERSION
         end
       end
     end

data/lib/google/ads/google_ads/logging_interceptor.rb

@@ -16,6 +16,8 @@
 #
 # Interceptor to log outgoing requests and incoming responses.
 
+require 'google/ads/google_ads/api_versions'
+require 'google/ads/google_ads/partial_failure_error_decoder'
 require 'grpc/generic/interceptors'
 require 'json'
 
@@ -23,56 +25,126 @@ module Google
   module Ads
     module GoogleAds
       class LoggingInterceptor < GRPC::ClientInterceptor
+        INTERESTING_ERROR_CLASSES = ::Google::Ads::GoogleAds::KNOWN_API_VERSIONS.map { |v|
+          require "google/ads/google_ads/#{v.downcase}/errors/errors_pb"
+          const_get("Google::Ads::GoogleAds::#{v}::Errors::GoogleAdsFailure")
+        }
+
         def initialize(logger)
+          # Don't propagate args, parens are necessary
           super()
           @logger = logger
         end
 
         def request_response(request:, call:, method:, metadata: {})
+          begin
+            response = yield
+
+            @logger.info(build_summary_message(request, call, method, false))
+            @logger.debug(build_request_message(metadata, request))
+            @logger.debug(build_success_response_message(response))
+            if response.respond_to?(:partial_failure_error) && response.partial_failure_error
+              @logger.warn(build_partial_failure_message(response))
+            end
+            response
+          rescue Exception
+            @logger.warn(build_summary_message(request, call, method, true))
+            @logger.info(build_request_message(metadata, request))
+            @logger.info(build_error_response_message)
+            raise
+          end
+        end
+
+        private
+
+        def build_partial_failure_message(response)
+          errors = PartialFailureErrorDecoder.decode(
+            response.partial_failure_error
+          )
+          errors.reduce("Partial failure errors: ") do |accum, error|
+            accum += error.to_json + "\n"
+            accum
+          end
+        end
+
+        def build_error_response_message
+          # this looks like "magic", but the Google::Gax::GaxError grabs
+          # the current exception as its cause, and then parses details
+          # out of that exception. So this sets it up so that
+          # most_recent_error.status_details contains useful information about
+          # our failure
+          most_recent_error = Google::Gax::GaxError.new('')
+          response_message = "Incoming response (errors): \n"
+
+          formatted_details = case most_recent_error.status_details
+          when nil
+            ""
+          when String
+            most_recent_error.status_details
+          when Array
+            most_recent_error.status_details.select { |detail|
+              INTERESTING_ERROR_CLASSES.include?(detail.class)
+            }.map { |detail|
+              response_error_from_detail(detail)
+            }.join("\n")
+          end
+
+          response_message += formatted_details
+          response_message
+        end
+
+        def build_success_response_message(response)
+          "Incoming response: Payload: #{response.to_json}"
+        end
+
+        def build_request_message(metadata, request)
+          # calling #to_json on some protos (specifically those with non-UTF8
+          # encodable byte values) causes a segfault, however #inspect works
+          # so we check if the proto contains a bytevalue, and if it does
+          # we #inspect instead of #to_json
+          request_inspect = if use_bytes_inspect?(request)
+                              request.inspect
+                            else
+                              request.to_json
+                            end
+          "Outgoing request: Headers: #{metadata.to_json} Payload: #{request_inspect}"
+        end
+
+        def build_summary_message(request, call, method, is_fault)
           customer_id = "N/A"
           customer_id = request.customer_id if request.respond_to?(:customer_id)
           # CustomerService get requests have a different format.
           if request.respond_to?(:resource_name)
             customer_id = request.resource_name.split('/').last
           end
-          summary_message =
-              sprintf("CID: %s, Host: %s, Method: %s",
-                customer_id,
-                call.instance_variable_get('@wrapped').peer,
-                method
-              )
-          request_message = sprintf("Outgoing request: Headers: %s Payload: %s",
-              metadata.to_json, request.to_json)
-          begin
-            response = yield
-            summary_message += ", IsFault: no"
-            response_message = sprintf("Incoming response: Payload: %s",
-                response.to_json)
-
-            @logger.info(summary_message)
-            @logger.debug(request_message)
-            @logger.debug(response_message)
-            return response
-          rescue Exception => e
-            summary_message += sprintf(", IsFault: yes")
-            response_message = "Incoming response (errors): \n"
-
-            most_recent_error = Google::Gax::GaxError.new('')
-            most_recent_error.status_details && most_recent_error.status_details.each do |detail|
-              if detail.is_a?(
-                  Google::Ads::GoogleAds::V0::Errors::GoogleAdsFailure)
-                detail.errors.each_with_index do |error, i|
-                  response_message +=
-                      sprintf("Error %d: %s\n", i + 1, error.to_json)
-                end
-              end
-            end
 
-            @logger.warn(summary_message)
-            @logger.info(request_message)
-            @logger.info(response_message)
-            raise
+          is_fault_string = if is_fault
+            "yes"
+          else
+            "no"
           end
+
+          [
+            "CID: #{customer_id}",
+            "Host: #{call.instance_variable_get('@wrapped').peer}",
+            "Method: #{method}",
+            "IsFault: #{is_fault_string}",
+          ].join(", ")
+        end
+
+        def response_error_from_detail(detail)
+          detail.errors.map.with_index { |error, i|
+            "Error #{i + 1}: #{error.to_json}"
+          }.join("\n")
+        end
+
+        def use_bytes_inspect?(request)
+          contains_bytes_field?(request.class.descriptor)
+        end
+
+        def contains_bytes_field?(descriptor)
+          return false if descriptor.nil?
+          descriptor.map { |x| x.type == :bytes || (x.type == :message && contains_bytes_field?(x.subtype)) }.any?
         end
       end
     end

data/lib/google/ads/google_ads/lookup_util.rb

@@ -0,0 +1,105 @@
+module Google
+  module Ads
+    module GoogleAds
+      class LookupUtil
+
+        def initialize
+          @proto_lookup_utils = {}
+          @path_lookup_utils = {}
+        end
+
+        # Return a resource or common entity for the provided entity type. For
+        # example, passing :Campaign will return an instantiated Campaign.
+        #
+        # Raises ArgumentError if no entity can be found for the provided type.
+        def resource(name, version)
+          proto_lookup_util(version).resource(name).new
+        end
+
+        # Return an operation for the provided entity type. For example, passing
+        # :Campaign will return an instantiated CampaignOperation.
+        #
+        # Raises ArgumentError if no entity can be found for the provided type.
+        def operation(name, version)
+          proto_lookup_util(version).operation(name).new
+        end
+
+        # Return a reference to the enum class for the provided enum type. For
+        # example, passing :CampaignStatus will return a reference to the
+        # CampaignStatusEnum.
+        #
+        # Raises ArgumentError if no enum can be found for the provided type.
+        def enum(name, version)
+          proto_lookup_util(version).enum(name)
+        end
+
+        # Return a service for the provided entity type. For example, passing
+        # :Campaign will return an instantiated CampaignServiceClient.
+        #
+        # Raises ArgumentError if no service can be found for the provided type.
+        def raw_service(name, version)
+          proto_lookup_util(version).service(name)
+        end
+
+        # Returns a reference to the PathLookupUtil to generate resource names.
+        def path(version)
+          path_lookup_util(version)
+        end
+
+        private
+
+        attr_reader :proto_lookup_utils, :path_lookup_utils
+
+        # Load up the proto lookup util for the given version, storing a copy
+        # of it if this is the first time we needed it.
+        def proto_lookup_util(version)
+          unless valid_version?(version)
+            raise sprintf('Unknown version %s', version)
+          end
+          if proto_lookup_utils[version].nil?
+            path_version = version.downcase
+            require sprintf('google/ads/google_ads/utils/%s/proto_lookup_util',
+                path_version)
+            class_path = sprintf(
+              'Google::Ads::GoogleAds::Utils::%s::ProtoLookupUtil',
+              version
+            )
+            proto_lookup_utils[version] = class_for_path(class_path).new
+          end
+          proto_lookup_utils[version]
+        end
+
+        # Load up the path lookup util for the given version, storing a copy
+        # of it if this is the first time we needed it.
+        def path_lookup_util(version)
+          unless valid_version?(version)
+            raise sprintf('Unknown version %s', version)
+          end
+          if path_lookup_utils[version].nil?
+            path_version = version.downcase
+            require sprintf('google/ads/google_ads/utils/%s/path_lookup_util',
+                path_version)
+            class_path = sprintf(
+              'Google::Ads::GoogleAds::Utils::%s::PathLookupUtil',
+              version
+            )
+            path_lookup_utils[version] = class_for_path(class_path).new(
+                proto_lookup_util(version))
+          end
+          path_lookup_utils[version]
+        end
+
+        # Converts complete class path into class object.
+        def class_for_path(path)
+          path.split('::').inject(Kernel) do |scope, const_name|
+            scope.const_get(const_name)
+          end
+        end
+
+        def valid_version?(version)
+          Google::Ads::GoogleAds.valid_version?(version)
+        end
+      end
+    end
+  end
+end

data/lib/google/ads/google_ads/partial_failure_error_decoder.rb

@@ -0,0 +1,24 @@
+module Google
+  module Ads
+    module GoogleAds
+      class PartialFailureErrorDecoder
+        # decodes a partial_failure_error (Google::Rpc::Status instance) to
+        # an array of meaningful error protos
+        #
+        # Return an Array of protobuf objects, typed depending on what was
+        # in the passed object (which will mostly be Google::Protobuf::Any,
+        # so the types could be any valid protobuf type)
+        def self.decode(partial_failure_error)
+          partial_failure_error.details.select { |detail|
+            Google::Protobuf::Any === detail
+          }.map { |detail|
+            type = Google::Protobuf::DescriptorPool.generated_pool.lookup(
+              detail.type_name
+            ).msgclass
+            detail.unpack(type)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/google/ads/google_ads/utils/v0/proto_lookup_util.rb

@@ -272,7 +272,10 @@ module Google
               KeywordParameters: ['services', 'recommendation_service_pb', 'ApplyRecommendationOperation::KeywordParameters'],
               TargetCpaOptInParameters: ['services', 'recommendation_service_pb', 'ApplyRecommendationOperation::TargetCpaOptInParameters'],
               LocationNames: ['services', 'geo_target_constant_service_pb', 'SuggestGeoTargetConstantsRequest::LocationNames'],
-              GeoTargets: ['services', 'geo_target_constant_service_pb', 'SuggestGeoTargetConstantsRequest::GeoTargets']
+              GeoTargets: ['services', 'geo_target_constant_service_pb', 'SuggestGeoTargetConstantsRequest::GeoTargets'],
+              KeywordAndUrlSeed: ['services', 'keyword_plan_idea_service_pb', 'KeywordAndUrlSeed'],
+              KeywordSeed: ['services', 'keyword_plan_idea_service_pb', 'KeywordSeed'],
+              UrlSeed: ['services', 'keyword_plan_idea_service_pb', 'UrlSeed']
             }.freeze
 
             ENUMS = {

data/lib/google/ads/google_ads/utils/v1/path_lookup_util.rb

@@ -137,6 +137,13 @@ module Google
               )
             end
 
+            def asset(customer_id, asset_id)
+              @proto_lookup_util.service(:Asset).asset_path(
+                customer_id.to_s,
+                asset_id.to_s
+              )
+            end
+
             def bidding_strategy(customer_id, bidding_strategy_id)
               @proto_lookup_util.service(:BiddingStrategy).
                   bidding_strategy_path(
@@ -601,7 +608,10 @@ module Google
             end
 
             def shopping_performance_view(customer_id)
-              sprintf('customers/%s/shoppingPerformanceView', customer_id.to_s)
+              @proto_lookup_util.service(:ShoppingPerformanceView).
+                  shopping_performance_view_path(
+                    customer_id.to_s
+                  )
             end
 
             def topic_constant(vertical_id)