google-cloud-error_reporting 0.24.0 → 0.25.0

data/lib/google/cloud/error_reporting/credentials.rb

@@ -0,0 +1,41 @@
+# Copyright 2017 Google Inc. All rights reserved.
+#
+# 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
+#
+#     http://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/credentials"
+
+module Google
+  module Cloud
+    module ErrorReporting
+      ##
+      # @private Represents the OAuth 2.0 signing logic for ErrorReporting.
+      class Credentials < Google::Cloud::Credentials
+        SCOPE = ["https://www.googleapis.com/auth/cloud-platform"]
+        PATH_ENV_VARS = %w(ERROR_REPORTING_KEYFILE GOOGLE_CLOUD_KEYFILE)
+        JSON_ENV_VARS =
+          %w(ERROR_REPORTING_KEYFILE_JSON GOOGLE_CLOUD_KEYFILE_JSON)
+
+        ##
+        # @private Create credentials with given scope and/or keyfile.
+        def self.credentials_with_scope keyfile, scope = nil
+          if keyfile.nil?
+            default(scope: scope)
+          else
+            new(keyfile, scope: scope)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/error_reporting/error_event.rb

@@ -0,0 +1,313 @@
+# Copyright 2017 Google Inc. All rights reserved.
+#
+# 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
+#
+#     http://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.
+
+
+module Google
+  module Cloud
+    module ErrorReporting
+      ##
+      # # ErrorEvent
+      #
+      # An individual error event to report to Stackdriver Error Reporting
+      # service.
+      #
+      # Google::Cloud::ErrorReporting::ErrorEvent is able to be transformed
+      # into
+      # {Google::Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent}
+      # gRPC structure. Once an error event is reported, the GCP
+      # Stackdriver ErrorReporting service is able to parse the message and
+      # backtrace, then group the error events by content.
+      #
+      # @see https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events
+      #
+      # @example
+      #   require "google/cloud/error_reporting"
+      #
+      #   error_reporting = Google::Cloud::ErrorReporting.new
+      #
+      #   error_event = error_reporting.error_event "Error with Backtrace",
+      #                                             timestamp: Time.now,
+      #                                             service_name: "my_app_name",
+      #                                             service_version: "v8"
+      #   error_reporting.report error_event
+      #
+      class ErrorEvent
+        ##
+        # Time when the event occurred. If not provided, the time when the event
+        # was received by the Error Reporting system will be used.
+        attr_accessor :event_time
+
+        ##
+        # A message describing the error. The message can contain an exception
+        # stack in one of the supported programming languages and formats. In
+        # that case, the message is parsed and detailed exception information is
+        # returned when retrieving the error event again.
+        attr_accessor :message
+
+        ##
+        # An identifier of the service, such as the name of the executable, job,
+        # or Google App Engine service name. This field is expected to have a
+        # low number of values that are relatively stable over time, as opposed
+        # to version, which can be changed whenever new code is deployed.
+        attr_accessor :service_name
+
+        ##
+        # Represents the source code version that the developer provided, which
+        # could represent a version label or a Git SHA-1 hash, for example.
+        attr_accessor :service_version
+
+        ##
+        # The type of HTTP request, such as GET, POST, etc.
+        attr_accessor :http_method
+
+        ##
+        # The URL of the request.
+        attr_accessor :http_url
+
+        ##
+        # The user agent information that is provided with the request.
+        attr_accessor :http_user_agent
+
+        ##
+        # The referrer information that is provided with the request.
+        attr_accessor :http_referrer
+
+        ##
+        # The HTTP response status code for the request.
+        attr_accessor :http_status
+
+        ##
+        # The IP address from which the request originated. This can be IPv4,
+        # IPv6, or a token which is derived from the IP address, depending on
+        # the data that has been provided in the error report.
+        attr_accessor :http_remote_ip
+
+        ##
+        # The user who caused or was affected by the crash. This can be a user
+        # ID, an email address, or an arbitrary token that uniquely identifies
+        # the user. When sending an error report, leave this field empty if the
+        # user was not logged in. In this case the Error Reporting system will
+        # use other data, such as remote IP address, to distinguish affected
+        # users. See affectedUsersCount in ErrorGroupStats.
+        attr_accessor :user
+
+        ##
+        # The source code filename, which can include a truncated relative path,
+        # or a full path from a production machine.
+        attr_accessor :file_path
+
+        ##
+        # 1-based. 0 indicates that the line number is unknown.
+        attr_accessor :line_number
+
+        ##
+        # Human-readable name of a function or method. The value can include
+        # optional context like the class or package name. For example,
+        # my.package.MyClass.method in case of Java.
+        attr_accessor :function_name
+
+        ##
+        # Build a new ErrorEvent from a
+        # Google::Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent
+        # object.
+        #
+        # @param [
+        #   Google::Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent]
+        #   grpc A
+        #   Google::Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent
+        #   object
+        #
+        # @return [ErrorEvent] A new ErrorEvent instance derived from given grpc
+        #   object
+        #
+        def self.from_grpc grpc
+          return new if grpc.nil?
+          new.tap do |event|
+            event.event_time = extract_timestamp grpc.event_time
+            event.message = grpc.message
+
+            extract_service_context event, grpc.service_context
+            extract_error_context event, grpc.context
+          end
+        end
+
+        ##
+        # @private Get a Time object from a Google::Protobuf::Timestamp object.
+        #
+        # @param [Google::Protobuf::Timestamp] timestamp_grpc A protobuf
+        #   Timestamp object
+        #
+        # @return [Time] The time object derived from input grpc timestamp
+        #
+        def self.extract_timestamp timestamp_grpc
+          return nil if timestamp_grpc.nil?
+          Time.at timestamp_grpc.seconds, Rational(timestamp_grpc.nanos, 1000)
+        end
+
+        ##
+        # @private Extract service context info from gRPC into an ErrorEvent.
+        def self.extract_service_context error_event, service_context_grpc
+          return nil if service_context_grpc.nil?
+
+          error_event.service_name = service_context_grpc.service
+          error_event.service_version = service_context_grpc.version
+        end
+
+        ##
+        # @private Extract error context info from gRPC into an ErrorEvent.
+        def self.extract_error_context error_event, error_context_grpc
+          return nil if error_context_grpc.nil?
+
+          error_event.user = error_context_grpc.user
+          extract_http_request error_event, error_context_grpc.http_request
+          extract_source_location error_event,
+                                  error_context_grpc.report_location
+        end
+
+        ##
+        # @private Extract http request info from gRPC into an ErrorEvent.
+        def self.extract_http_request error_event, http_request_grpc
+          return nil if http_request_grpc.nil?
+
+          error_event.http_method = http_request_grpc["method"]
+          error_event.http_url = http_request_grpc.url
+          error_event.http_user_agent = http_request_grpc.user_agent
+          error_event.http_referrer = http_request_grpc.referrer
+          error_event.http_status = http_request_grpc.response_status_code
+          error_event.http_remote_ip = http_request_grpc.remote_ip
+        end
+
+        ##
+        # @private Extract source location info from gRPC into an ErrorEvent.
+        def self.extract_source_location error_event, source_location_grpc
+          return nil if source_location_grpc.nil?
+
+          error_event.file_path = source_location_grpc.file_path
+          error_event.line_number = source_location_grpc.line_number
+          error_event.function_name = source_location_grpc.function_name
+        end
+
+        private_class_method :extract_timestamp,
+                             :extract_service_context,
+                             :extract_error_context,
+                             :extract_http_request,
+                             :extract_source_location
+
+        ##
+        # Construct an ErrorEvent object based on a given exception.
+        #
+        # @param [Exception] exception A Ruby exception.
+        #
+        # @return [ErrorEvent] An ErrorEvent object containing information
+        #   from the given exception.
+        def self.from_exception exception
+          backtrace = exception.backtrace
+          message = exception.message
+
+          unless backtrace.nil?
+            error_location = backtrace.first
+
+            message = "#{error_location}: #{message} (#{exception.class})\n\t" +
+                      backtrace.drop(1).join("\n\t")
+            file_path, line_number, function_name = error_location.split(":")
+            function_name = function_name.to_s[/`(.*)'/, 1]
+          end
+
+          new.tap do |e|
+            e.message = message
+            e.file_path = file_path
+            e.line_number = line_number.to_i
+            e.function_name = function_name
+          end
+        end
+
+        ##
+        # Convert ErrorEvent object to gRPC struct.
+        #
+        # @return [Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent]
+        #   gRPC struct that represent an ErrorEvent.
+        def to_grpc
+          error_event_hash = {
+            event_time: event_time_hash,
+            message: message,
+            service_context: service_context_hash,
+            context: error_context_hash
+          }.delete_if { |_, v| v.nil? }
+
+          grpc_class =
+            Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent
+          grpc_class.decode_json error_event_hash.to_json
+        end
+
+        private
+
+        ##
+        # @private Formats the event_time as the hash representation of
+        # Google::Protobuf::Timestamp struct.
+        #
+        def event_time_hash
+          return nil if event_time.nil?
+          {
+            seconds: event_time.to_i,
+            nanos: event_time.nsec
+          }
+        end
+
+        ##
+        # @private Formats the service_name and service_version as the hash
+        # representation of
+        # Google::Devtools::Clouderrorreporting::V1beta1::SourceContext struct.
+        #
+        def service_context_hash
+          return nil if !service_name && !service_version
+          {
+            service: service_name,
+            version: service_version
+          }.delete_if { |_, v| v.nil? }
+        end
+
+        ##
+        # @private Formats the error context info as the hash
+        # representation of
+        # Google::Devtools::Clouderrorreporting::V1beta1::ErrorContext struct.
+        #
+        def error_context_hash
+          http_request_hash = {
+            method: http_method,
+            url: http_url,
+            user_agent: http_user_agent,
+            referrer: http_referrer,
+            response_status_code: http_status,
+            remote_ip: http_remote_ip
+          }.delete_if { |_, v| v.nil? }
+
+          source_location_hash = {
+            file_path: file_path,
+            line_number: line_number,
+            function_name: function_name
+          }.delete_if { |_, v| v.nil? }
+
+          result = {
+            http_request: http_request_hash.empty? ? nil : http_request_hash,
+            user: user,
+            report_location:
+              source_location_hash.empty? ? nil : source_location_hash
+          }.delete_if { |_, v| v.nil? }
+
+          result.empty? ? nil : result
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/error_reporting/middleware.rb

@@ -13,69 +13,51 @@
 # limitations under the License.
 
 
-require "google/cloud/env"
-require "google/cloud/error_reporting/v1beta1"
-require "rack"
-require "rack/request"
-
 module Google
   module Cloud
     module ErrorReporting
       ##
-      # Middleware
+      # # Middleware
       #
       # Google::Cloud::ErrorReporting::Middleware defines a Rack Middleware
       # that can automatically catch upstream exceptions and report them
       # to Stackdriver Error Reporting.
       #
       class Middleware
-        attr_reader :error_reporting, :ignore_classes, :project_id,
-                    :service_name, :service_version
+        # A Google::Cloud::ErrorReporting::Project client used to report
+        # error events.
+        attr_reader :error_reporting
 
         ##
-        # Construct a new instance of Middleware
+        # Construct a new instance of Middleware.
         #
-        # @param [Rack Application] app The Rack application
-        # @param [
-        #   Google::Cloud::ErrorReporting::V1beta1::ReportErrorsServiceClient]
-        #   error_reporting A ErrorReporting::V1beta1::ReportErrorsServiceClient
-        #   object to for reporting exceptions
-        # @param [String] project_id Name of GCP project. Default to
-        #   ENV["ERROR_REPORTING_PROJECT"] then ENV["GOOGLE_CLOUD_PROJECT"].
-        #   Automatically discovered if on GAE
-        # @param [String] service_name Name of the service. Default to
-        #   ENV["ERROR_REPORTING_SERVICE"] then "ruby". Automatically discovered
-        #   if on GAE
-        # @param [String] service_version Version of the service. Optional.
-        #   ENV["ERROR_REPORTING_VERSION"]. Automatically discovered if on GAE
-        # @param [Array<Class>] ignore_classes A single or an array of Exception
-        #   classes to ignore
+        # @param [Rack::Application] app The Rack application
+        # @param [Google::Cloud::ErrorReporting::Project] error_reporting A
+        #   Google::Cloud::ErrorReporting::Project client for reporting
+        #   exceptions
+        # @param [Hash] *kwargs Hash of configuration settings. Used for
+        #   backward API compatibility. See the [Configuration
+        #   Guide](https://googlecloudplatform.github.io/google-cloud-ruby/#/docs/stackdriver/guides/instrumentation_configuration)
+        #   for the prefered way to set configuration parameters.
         #
         # @return [Google::Cloud::ErrorReporting::Middleware] A new instance of
         #   Middleware
         #
-        def initialize app,
-                       error_reporting: V1beta1::ReportErrorsServiceClient.new,
-                       project_id: nil,
-                       service_name: nil,
-                       service_version: nil,
-                       ignore_classes: nil
+        def initialize app, error_reporting: nil, **kwargs
+          require "rack"
+          require "rack/request"
           @app = app
-          @error_reporting = error_reporting
-          @service_name = service_name ||
-                          ENV["ERROR_REPORTING_SERVICE"] ||
-                          Google::Cloud.env.app_engine_service_id ||
-                          "ruby"
-          @service_version = service_version ||
-                             ENV["ERROR_REPORTING_VERSION"] ||
-                             Google::Cloud.env.app_engine_service_version
-          @ignore_classes = Array(ignore_classes)
-          @project_id = project_id ||
-                        ENV["ERROR_REPORTING_PROJECT"] ||
-                        ENV["GOOGLE_CLOUD_PROJECT"] ||
-                        Google::Cloud.env.project_id
 
-          fail ArgumentError, "project_id is required" if @project_id.nil?
+          load_config kwargs
+
+          @error_reporting =
+            error_reporting ||
+            ErrorReporting.new(project: configuration.project_id,
+                               keyfile: configuration.keyfile)
+
+          # Set module default client to reuse the same client. Update module
+          # configuration parameters.
+          ErrorReporting.class_variable_set :@@default_client, @error_reporting
         end
 
         ##
@@ -116,23 +98,22 @@ module Google
         #
         def report_exception env, exception
           # Do not any exceptions that's specified by the ignore_classes list.
-          return if ignore_classes.include? exception.class
+          return if configuration.ignore_classes.include? exception.class
 
-          error_event_grpc = build_error_event_from_exception env, exception
+          error_event = error_event_from_exception env, exception
 
           # If this exception maps to a HTTP status code less than 500, do
           # not report it.
-          status_code =
-            error_event_grpc.context.http_request.response_status_code.to_i
+          status_code = error_event.http_status.to_i
           return if status_code > 0 && status_code < 500
 
-          error_reporting.report_error_event full_project_id, error_event_grpc
+          error_reporting.report error_event
         end
 
         ##
-        # Creates a GRPC ErrorEvent based on the exception. Fill in the
-        # HttpRequestContext section of the ErrorEvent based on the HTTP Request
-        # headers.
+        # Creates a {Google::Cloud::ErrorReporting::ErrorEvent} based on the
+        # exception. Fill in the HttpRequestContext section of the ErrorEvent
+        # based on the HTTP Request headers.
         #
         # When used in Rails environment. It replies on
         # ActionDispatch::ExceptionWrapper class to derive a HTTP status code
@@ -141,56 +122,74 @@ module Google
         # @param [Hash] env Rack environment hash
         # @param [Exception] exception Exception to convert from
         #
-        # @return [
-        #   Google::Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent]
-        #   The gRPC ReportedErrorEvent object that's based
-        #   on given exception
+        # @return [Google::Cloud::ErrorReporting::ErrorEvent] The gRPC
+        #   ErrorEvent object that's based on given env and exception
         #
-        def build_error_event_from_exception env, exception
-          error_event = ErrorEvent.from_exception exception
+        def error_event_from_exception env, exception
+          error_event = ErrorReporting::ErrorEvent.from_exception exception
 
           # Inject service_context info into error_event object
-          error_event[:service_context] = {
-            service: service_name,
-            version: service_version
-          }.delete_if { |_, v| v.nil? }
+          error_event.service_name = configuration.service_name
+          error_event.service_version = configuration.service_version
 
           # Inject http_request_context info into error_event object
           rack_request = Rack::Request.new env
-          error_event[:context][:http_request] = {
-            method: rack_request.request_method,
-            url: rack_request.url,
-            user_agent: rack_request.user_agent,
-            referrer: rack_request.referrer,
-            response_status_code: get_http_status(exception),
-            remote_ip: rack_request.ip
-          }.delete_if { |_, v| v.nil? }
-
-          error_event.to_grpc
+          error_event.http_method = rack_request.request_method
+          error_event.http_url = rack_request.url
+          error_event.http_user_agent = rack_request.user_agent
+          error_event.http_referrer = rack_request.referrer
+          error_event.http_status = http_status(exception)
+          error_event.http_remote_ip = rack_request.ip
+
+          error_event
         end
 
+        private
+
         ##
-        # Build full ReportErrorsServiceClient project_path from project_id,
-        # which is in "projects/#{project_id}" format.
-        #
-        # @return [String] fully qualified project id in
-        #   "projects/#{project_id}" format
-        def full_project_id
-          V1beta1::ReportErrorsServiceClient.project_path project_id
+        # Consolidate configurations from various sources. Also set
+        # instrumentation config parameters to default values if not set
+        # already.
+        #
+        def load_config **kwargs
+          configuration.project_id = kwargs[:project_id] ||
+                                     configuration.project_id
+          configuration.keyfile = kwargs[:keyfile] ||
+                                  configuration.keyfile
+          configuration.service_name = kwargs[:service_name] ||
+                                       configuration.service_name
+          configuration.service_version = kwargs[:service_version] ||
+                                          configuration.service_version
+          configuration.ignore_classes = kwargs[:ignore_classes] ||
+                                         configuration.ignore_classes
+
+          init_default_config
         end
 
-        private
+        ##
+        # Fallback to default configuration values if not defined already
+        def init_default_config
+          configuration.project_id ||= Cloud.configure.project_id ||
+                                       ErrorReporting::Project.default_project
+          configuration.keyfile ||= Cloud.configure.keyfile
+          configuration.service_name ||=
+            ErrorReporting::Project.default_service_name
+
+          configuration.service_version ||=
+            ErrorReporting::Project.default_service_version
+          configuration.ignore_classes = Array(configuration.ignore_classes)
+        end
 
         ##
         # Helper method to derive HTTP status code base on exception class in
-        # Rails. Returns nil if not in Rails environment
+        # Rails. Returns nil if not in Rails environment.
         #
         # @param [Exception] exception An Ruby exception
         #
         # @return [Integer] A number that represents HTTP status code or nil if
         #   status code can't be determined
         #
-        def get_http_status exception
+        def http_status exception
           http_status = nil
           if defined?(ActionDispatch::ExceptionWrapper) &&
              ActionDispatch::ExceptionWrapper.respond_to?(
@@ -206,108 +205,10 @@ module Google
         end
 
         ##
-        # This class implements a hash representation of
-        # Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent
-        class ErrorEvent
-          # Internal data structure mirroring gRPC ReportedErrorEvent structure
-          attr_reader :hash
-
-          ##
-          # Construct a new ErrorEvent object
-          #
-          # @return [ErrorEvent] A new ErrorEvent object
-          def initialize
-            @hash = {}
-          end
-
-          ##
-          # Construct an ErrorEvent object based on a given exception
-          #
-          # @param [Exception] exception A Ruby exception
-          #
-          # @return [ErrorEvent] An ErrorEvent object containing information
-          #   from the given exception
-          def self.from_exception exception
-            exception_data = extract_exception exception
-
-            # Build error_context hash
-            error_context = {
-              user: ENV["USER"],
-              report_location: {
-                file_path: exception_data[:file_path],
-                function_name: exception_data[:function_name],
-                line_number: exception_data[:line_number].to_i
-              }.delete_if { |_, v| v.nil? }
-            }.delete_if { |_, v| v.nil? }
-
-            # Build error_event hash
-            error_event = ErrorEvent.new
-            t = Time.now
-            error_event.hash.merge!({
-              event_time: {
-                seconds: t.to_i,
-                nanos: t.nsec
-              },
-              message: exception_data[:message],
-              context: error_context
-            }.delete_if { |_, v| v.nil? })
-
-            error_event
-          end
-
-          ##
-          # Helper method extract data from exception
-          #
-          # @param [Exception] exception A Ruby Exception
-          #
-          # @return [Hash] A hash containing formatted error message with
-          # backtrace, file_path, line_number, and function_name
-          def self.extract_exception exception
-            if exception.backtrace.nil? || exception.backtrace.empty?
-              message = exception.message
-            else
-              message = "#{exception.backtrace.first}: #{exception.message} " \
-                        "(#{exception.class})\n\t" +
-                        exception.backtrace.drop(1).join("\n\t")
-              file_path, line_number, function_name =
-                exception.backtrace.first.split(":")
-              function_name = function_name.to_s[/`(.*)'/, 1]
-            end
-
-            {
-              message: message,
-              file_path: file_path,
-              line_number: line_number,
-              function_name: function_name
-            }
-          end
-          private_class_method :extract_exception
-
-          ##
-          # Get the value of the given key from internal hash
-          def [] key
-            hash[key]
-          end
-
-          ##
-          # Write new value with the key in internal hash
-          def []= key, value
-            hash[key] = value
-          end
-
-          ##
-          # Convert ErrorEvent object to gRPC struct
-          #
-          # @return [Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent]
-          #   gRPC struct that represent an ErrorEvent
-          def to_grpc
-            grpc_module =
-              Devtools::Clouderrorreporting::V1beta1::ReportedErrorEvent
-            grpc_module.decode_json hash.to_json
-          end
+        # @private Get Google::Cloud::ErrorReporting.configure
+        def configuration
+          Google::Cloud::ErrorReporting.configure
         end
-
-        private_constant :ErrorEvent
       end
     end
   end