google-ads-googleads 5.1.0 → 9.0.0

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

@@ -16,52 +16,6 @@
 #
 # GoogleAds client class to configure settings and fetch services.
 
-# We need to define all modules for all known versions in advance because of a
-# generation issue where they are defined in a single line, which cannot be used
-# to create new modules.
-module Google
-  module Ads
-    module GoogleAds
-      module V1
-        module Common
-        end
-        module Enums
-        end
-        module Errors
-        end
-        module Resources
-        end
-        module Services
-        end
-      end
-      module V2
-        module Common
-        end
-        module Enums
-        end
-        module Errors
-        end
-        module Resources
-        end
-        module Services
-        end
-      end
-      module V3
-        module Common
-        end
-        module Enums
-        end
-        module Errors
-        end
-        module Resources
-        end
-        module Services
-        end
-      end
-    end
-  end
-end
-
 # this require needs to always come first to patch protobufs to have "autoboxing
 # fields"
 require 'google/ads/google_ads/autoboxing_fields'
@@ -73,14 +27,13 @@ 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'
+require 'google/ads/google_ads/interceptors/logging_interceptor'
 require 'google/ads/google_ads/factories'
 require 'google/ads/google_ads/errors'
 require 'google/ads/google_ads/service_lookup'
 require 'google/ads/google_ads/deprecation'
-require 'google/ads/google_ads/v1/services/google_ads_service_client'
 
-require 'google/gax'
+require 'grpc'
 
 require 'logger'
 require 'json'
@@ -110,7 +63,8 @@ module Google
             yield @config
           else
             if config_path.nil?
-              config_path = File.join(ENV['HOME'], DEFAULT_CONFIG_FILENAME)
+              config_path = ENV.fetch("GOOGLE_ADS_CONFIGURATION_FILE_PATH",
+                File.join(ENV['HOME'], DEFAULT_CONFIG_FILENAME))
             end
 
             unless File.exist?(config_path)
@@ -143,26 +97,48 @@ module Google
           yield @config
         end
 
+        def load_environment_config
+          # Generic variables
+          @config.refresh_token = ENV.fetch("GOOGLE_ADS_REFRESH_TOKEN", @config.refresh_token)
+          @config.client_id = ENV.fetch("GOOGLE_ADS_CLIENT_ID", @config.client_id)
+          @config.client_secret = ENV.fetch("GOOGLE_ADS_CLIENT_SECRET", @config.client_secret)
+          @config.keyfile = ENV.fetch("GOOGLE_ADS_JSON_KEY_FILE_PATH", @config.keyfile)
+          @config.impersonate = ENV.fetch("GOOGLE_ADS_IMPERSONATED_EMAIL", @config.impersonate)
+          @config.developer_token = ENV.fetch("GOOGLE_ADS_DEVELOPER_TOKEN", @config.developer_token)
+          @config.login_customer_id = ENV.fetch("GOOGLE_ADS_LOGIN_CUSTOMER_ID", @config.login_customer_id)
+          @config.linked_customer_id = ENV.fetch("GOOGLE_ADS_LINKED_CUSTOMER_ID", @config.linked_customer_id)
+          @config.api_endpoint = ENV.fetch("GOOGLE_ADS_ENDPOINT", @config.api_endpoint)
+
+          # Client library-specific variables
+          @config.log_level = ENV.fetch("GOOGLE_ADS_RUBY_LOG_LEVEL", @config.log_level)
+          @config.http_proxy = ENV.fetch("GOOGLE_ADS_RUBY_HTTP_PROXY", @config.http_proxy)
+        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 service
-          service_path = ENV['GOOGLEADS_SERVICE_PATH']
-
           ServiceLookup.new(
             lookup_util,
-            service_path,
             @logger,
             @config,
             make_channel,
+            endpoint,
+            deprecator,
           ).call
         end
 
-        def make_channel
+        def endpoint
+          target.split(":443").first
+        end
+
+        def target
           default_target = "googleads.googleapis.com:443"
-          target = ENV.fetch('GOOGLEADS_SERVICE_PATH', default_target)
+          target = @config.api_endpoint || default_target
+        end
 
+        def make_channel
           channel_args = {
             MAX_MESSAGE_LENGTH => 64*1024*1024,
             MAX_METADATA_SIZE => 16*1024*1024,
@@ -287,11 +263,14 @@ module Google
         end
 
         def deprecate(deprecation)
-          @deprecation ||= Google::Ads::GoogleAds::Deprecation.new(
+          deprecator.deprecate(deprecation)
+        end
+
+        def deprecator
+          Google::Ads::GoogleAds::Deprecation.new(
             @config.treat_deprecation_warnings_as_errors,
             @config.warn_on_all_deprecations,
           )
-          @deprecation.deprecate(deprecation)
         end
       end
     end

data/lib/google/ads/google_ads/interceptors/error_interceptor.rb

@@ -0,0 +1,84 @@
+# Encoding: utf-8
+#
+# Copyright 2020 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.
+#
+# Interceptor to transform error responses to GoogleAdsErrors.
+
+require 'grpc/generic/interceptors'
+
+module Google
+  module Ads
+    module GoogleAds
+      module Interceptors
+        class ErrorInterceptor < GRPC::ClientInterceptor
+          ERROR_TRANSFORMER = lambda do |gax_error|
+            begin
+              gax_error.status_details.each do |detail|
+                # If there is an underlying GoogleAdsFailure, throw that one.
+                if detail.class.name.start_with?("Google::Ads::GoogleAds") &&
+                    detail.class.name.end_with?("GoogleAdsFailure")
+                  return Google::Ads::GoogleAds::Errors::GoogleAdsError.new(
+                    detail
+                  )
+                elsif detail.is_a?(Google::Protobuf::Any)
+                  type = Google::Protobuf::DescriptorPool.generated_pool.lookup(
+                    detail.type_name
+                  ).msgclass
+                  failure = detail.unpack(type)
+
+                  return Google::Ads::GoogleAds::Errors::GoogleAdsError.new(
+                    failure
+                  )
+                end
+              end
+            rescue Google::Ads::GoogleAds::Errors::GoogleAdsError => e
+              return e
+            rescue NoMethodError
+              # Sometimes status_details is just a String; in that case, we should
+              # just raise the original exception.
+            end
+            # If we don't find an error of the correct type, or if we run into an
+            # error while processing, just throw the original.
+            gax_error
+          end
+
+          def initialize()
+            # Don't propagate args, parens are necessary
+            super()
+            @error_transformer = ERROR_TRANSFORMER
+          end
+
+          def request_response(request:, call:, method:, metadata: {})
+            begin
+              yield
+            rescue Exception => e
+              raise @error_transformer.call(e)
+            end
+          end
+
+          def server_streamer(request:, call:, method:, metadata: {})
+            responses = yield
+            Enumerator.new do |y|
+              responses.each { |response| y << response }
+            rescue BasicObject => e
+              raise @error_transformer.call(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,366 @@
+# Encoding: utf-8
+#
+# Copyright 2018 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.
+#
+# 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'
+
+module Google
+  module Ads
+    module GoogleAds
+      module Interceptors
+        class LoggingInterceptor < GRPC::ClientInterceptor
+
+          HEADERS_TO_MASK = [:"developer-token"]
+          SEARCH_RESPONSE_FIELDS_TO_MASK = %w[
+            emailAddress
+            inviterUserEmailAddress
+            userEmail
+          ]
+          SEARCH_REQUEST_MASK = /
+            customer_user_access.email_address|
+            customer_user_access_invitation.email_address|
+            change_event.user_email|
+            feed.places_location_feed_data.email_address
+          /x
+
+          MASK_REPLACEMENT = "REDACTED"
+
+          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.debug { 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
+
+          def server_streamer(request:, call:, method:, metadata: {})
+            begin
+              @logger.info { build_summary_message(request, call, method, false) }
+              responses = yield
+              Enumerator.new do |y|
+                responses.each { |response|
+                  @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.debug { build_partial_failure_message(response) }
+                  end
+                  y << response
+                }
+                @logger.debug {
+                  request_id = call
+                    .instance_variable_get(:@wrapped)
+                    .instance_variable_get(:@call)
+                    .trailing_metadata["request-id"]
+                  "Request ID for preceding streaming request: #{request_id}"
+                }
+              rescue Exception
+                handle_error(request, call, method, metadata)
+              end
+            rescue Exception
+              handle_error(request, call, method, metadata)
+            end
+          end
+
+          private
+
+          def handle_error(request, call, method, metadata)
+            @logger.warn { build_summary_message(request, call, method, true) }
+            @logger.info { build_request_message(metadata, request) }
+            @logger.info { build_error_response_message }
+            raise
+          end
+
+          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
+            exception = $!
+            response_message = ""
+            response_message << "Incoming response (errors): \n"
+            response_message << error_details(exception).join
+            response_message
+          end
+
+          def error_details(exception)
+            last_user_line = CallerFilter.first_non_google_ads_line
+            exception_details = [
+              "  ",
+              exception.class,
+              "(",
+              exception.message,
+              "): "
+            ]
+
+            case exception
+            when Google::Ads::GoogleAds::Errors::GoogleAdsError
+              exception.failure.errors.each do |error|
+                exception_details << error.message
+              end
+            when GRPC::InvalidArgument
+              exception_details << exception.details
+            end
+
+            exception_details << [
+              "\n",
+              "  called from: ",
+              last_user_line
+            ]
+
+            exception_details
+          end
+
+          def build_success_response_message(response)
+            "Incoming response: Payload: #{sanitize_message(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
+                                sanitize_message(request).to_json
+                              end
+            "Outgoing request: Headers: #{sanitize_headers(metadata).to_json} " \
+              "Payload: #{request_inspect}"
+          end
+
+          def sanitize_headers(metadata)
+            metadata = metadata.clone
+            HEADERS_TO_MASK.each do |header|
+              metadata[header] = MASK_REPLACEMENT
+            end
+            metadata
+          end
+
+          def clone_to_json(message)
+            JSON.parse(message.to_json)
+          end
+
+          def sanitize_message(message)
+            message_class = message.class.to_s.split("::").last
+            if %w[SearchGoogleAdsStreamResponse SearchGoogleAdsResponse].include?(
+                message_class)
+              # Sanitize all known sensitive fields across all search responses.
+              message = clone_to_json(message)
+              message["fieldMask"].split(",").each do |path|
+                if SEARCH_RESPONSE_FIELDS_TO_MASK.include?(path.split(".").last)
+                  message["results"]&.each do |result|
+                    sanitize_field(result, path)
+                  end
+                end
+              end
+              message
+            elsif %w[SearchGoogleAdsRequest SearchGoogleAdsStreamRequest].include?(
+                message_class)
+              if SEARCH_REQUEST_MASK === message.query
+                message = clone_to_json(message)
+                message["query"] = MASK_REPLACEMENT
+              end
+              message
+            elsif "CustomerUserAccess" == message_class
+              # Sanitize sensitive fields specific to CustomerUserAccess get requests.
+              message = clone_to_json(message)
+              sanitize_customer_user_access(message)
+            elsif "MutateCustomerUserAccessRequest" == message_class
+              # Sanitize sensitive fields when mutating a CustomerUserAccess.
+              message = clone_to_json(message)
+              if message.include?("operation") && message["operation"].include?("update")
+                message["operation"]["update"] =
+                  sanitize_customer_user_access(message["operation"]["update"])
+              end
+              message
+            elsif "CustomerUserAccessInvitation" == message_class
+              # Sanitize sensitive fields specific to CustomerUserAccessInvitation get requests.
+              message = clone_to_json(message)
+              sanitize_customer_user_access_invitation(message)
+            elsif "MutateCustomerUserAccessInvitationRequest" == message_class
+              # Sanitize sensitive fields when mutating a CustomerUserAccessInvitation.
+              message = clone_to_json(message)
+              if message.include?("operation") && message["operation"].include?("create")
+                message["operation"]["create"] =
+                  sanitize_customer_user_access_invitation(message["operation"]["create"])
+              end
+              message
+            elsif "Feed" == message_class
+              # Sanitize sensitive fields specific to Feed get requests.
+              message = clone_to_json(message)
+              if message.include?("placesLocationFeedData") &&
+                  message["placesLocationFeedData"].include?("emailAddress")
+                message["placesLocationFeedData"]["emailAddress"] = MASK_REPLACEMENT
+              end
+              message
+            elsif "MutateFeedsRequest" == message_class
+              # Sanitize sensitive fields when mutating a Feed.
+              message = clone_to_json(message)
+              sanitize_feeds_request(message)
+            elsif "CreateCustomerClientRequest" == message_class
+              # Sanitize sensitive fields when creating a CustomerClient.
+              message = clone_to_json(message)
+              if message.include?("emailAddress")
+                message["emailAddress"] = MASK_REPLACEMENT
+              end
+              message
+            else
+              message
+            end
+          end
+
+          def sanitize_customer_user_access(message)
+            if message.include?("emailAddress")
+              message["emailAddress"] = MASK_REPLACEMENT
+            end
+            if message.include?("inviterUserEmailAddress")
+              message["inviterUserEmailAddress"] = MASK_REPLACEMENT
+            end
+            message
+          end
+
+          def sanitize_customer_user_access_invitation(message)
+            if message.include?("emailAddress")
+              message["emailAddress"] = MASK_REPLACEMENT
+            end
+            message
+          end
+
+          def sanitize_feeds_request(message)
+            if message.include?("operations")
+              message["operations"].each do |operation|
+                if operation.include?("create")
+                  operation = operation["create"]
+                elsif operation.include?("update")
+                  operation = operation["update"]
+                else
+                  # Only create and update can contain sensitive fields.
+                  next
+                end
+                if operation.include?("placesLocationFeedData") &&
+                    operation["placesLocationFeedData"].include?("emailAddress")
+                  operation["placesLocationFeedData"]["emailAddress"] = MASK_REPLACEMENT
+                end
+              end
+            end
+            message
+          end
+
+          def sanitize_field(object, path)
+            split_path = path.split(".")
+            target_field = split_path.last
+            split_path.inject(object) do |obj, field|
+              if obj.include?(target_field)
+                obj[target_field] = MASK_REPLACEMENT
+                break
+              end
+              obj[field]
+            end
+          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
+
+            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)
+            @cycle_finder = CycleFinder.new
+            contains_bytes_field?(request.class.descriptor)
+          end
+
+          def contains_bytes_field?(descriptor)
+            return false if descriptor.nil?
+            return false if @cycle_finder.is_cycle?(descriptor)
+
+            @cycle_finder.add_object(descriptor)
+
+            descriptor.map { |x| x.type == :bytes || (x.type == :message && contains_bytes_field?(x.subtype)) }.any?
+          end
+
+          def interesting_error_classes
+            @interesting_error_classes ||= Google::Ads::GoogleAds::Errors.namespaces.map do |namespace|
+              namespace.const_get(:GoogleAdsFailure)
+            end
+          end
+
+          class CycleFinder
+            def initialize
+              @objects_seen = Set.new
+            end
+
+            def is_cycle?(object)
+              @objects_seen.include?(object.object_id)
+            end
+
+            def add_object(object)
+              @objects_seen.add(object.object_id)
+            end
+          end
+        end
+      end
+    end
+  end
+end