Add GAX to Error Reporting

Author: Bill Prin

error_reporting/google/cloud/error_reporting/_gax.py

@@ -0,0 +1,56 @@
+# Copyright 2016 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.
+
+"""GAX wrapper for Error Reporting API requests."""
+
+from google.cloud.gapic.errorreporting.v1beta1 import report_errors_service_api
+from google.devtools.clouderrorreporting.v1beta1 import report_errors_service_pb2
+from google.protobuf.json_format import ParseDict
+
+
+def make_report_error_api(project):
+    """Create an instance of the GAX Logging API."""
+    api = report_errors_service_api.ReportErrorsServiceApi()
+    return _ErrorReportingGaxApi(api, project)
+
+
+class _ErrorReportingGaxApi(object):
+    """Helper mapping Error Reporting-related APIs
+
+    :type gax_api:
+        :class:`google.cloud.gapic.errorreporting.v1beta1
+        .report_errors_service_api.report_errors_service_api`
+    :param gax_api: API object used to make GAX requests.
+    """
+    def __init__(self, gax_api, project):
+        self._gax_api = gax_api
+        self._project = project
+
+    def report_error_event(self, error_report):
+        """Uses the GAX client to report the error.
+
+        :type project: str
+        :param: project: Project ID to report the error to
+
+        :type error: dict:
+        :param: error: dict payload of the error report formatted
+                       according to
+                       https://cloud.google.com/error-reporting/docs/formatting-error-messages
+                       This object should be built using
+                       Use :meth:~`google.cloud.error_reporting.client._build_error_report`
+        """
+        project_name = self._gax_api.project_path(self._project)
+        error_report_payload = report_errors_service_pb2.ReportedErrorEvent()
+        ParseDict(error_report, error_report_payload)
+        self._gax_api.report_error_event(project_name, error_report_payload)

error_reporting/google/cloud/error_reporting/_logging.py

@@ -0,0 +1,34 @@
+# Copyright 2016 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.
+
+"""Interact with Stackdriver Error Reporting via Logging API.
+
+It's possible to report Stackdriver Error Reporting errors by formatting
+structured log messages in Stackdriver Logging in a given format. This
+client provides a mechanism to report errors using that technique.
+"""
+
+import google.cloud.logging.client
+
+
+class _ErrorReportingLoggingAPI(object):
+    """Report to Stackdriver Error Reporting via Logging API
+    """
+    def __init__(self, project, credentials, http):
+        self.logging_client = google.cloud.logging.client.Client(
+            project, credentials, http)
+
+    def report_error_event(self, project, error_report):
+        logger = self.logging_client.logger('errors')
+        logger.log_struct(error_report)

error_reporting/google/cloud/error_reporting/client.py

@@ -12,13 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Client for interacting with the Stackdriver Logging API"""
+"""Client for interacting with the Stackdriver Error Reporting API"""
 
+import os
 import traceback
 
-import google.cloud.logging.client
+try:
+    from google.cloud.error_reporting._gax import make_report_error_api
+except ImportError:  # pragma: NO COVER
+    _HAVE_GAX = False
+else:
+    _HAVE_GAX = True
+
+from google.cloud._helpers import _determine_default_project
+from google.cloud.error_reporting._logging import _ErrorReportingLoggingAPI
+from google.cloud.environment_vars import DISABLE_GRPC
+
 import six
 
+_DISABLE_GAX = os.getenv(DISABLE_GRPC, False)
+_USE_GAX = _HAVE_GAX and not _DISABLE_GAX
+
 
 class HTTPContext(object):
     """HTTPContext defines an object that captures the parameter for the
@@ -96,6 +110,12 @@ class Client(object):
                     SHA-1 hash, for example. If the developer did not provide
                     a version, the value is set to default.
 
+    :type use_gax: bool
+    :param use_gax: (Optional) Explicitly specifies whether
+                    to use the gRPC transport (via GAX) or HTTP. If unset,
+                    falls back to the ``GOOGLE_CLOUD_DISABLE_GRPC`` environment
+                    variable.
+
     :raises: :class:`ValueError` if the project is neither passed in nor
              set in the environment.
     """
@@ -104,24 +124,48 @@ def __init__(self, project=None,
                  credentials=None,
                  http=None,
                  service=None,
-                 version=None):
-        self.logging_client = google.cloud.logging.client.Client(
-            project, credentials, http)
+                 version=None,
+                 use_gax=None):
+        if project is None:
+            self._project = _determine_default_project()
+        else:
+            self._project = project
+        self._credentials = credentials
+        self._http = http
+
+        self._report_errors_api = None
+
         self.service = service if service else self.DEFAULT_SERVICE
         self.version = version
+        if use_gax is None:
+            self._use_gax = _USE_GAX
+        else:
+            self._use_gax = use_gax
 
     DEFAULT_SERVICE = 'python'
 
-    def _send_error_report(self, message,
-                           report_location=None, http_context=None, user=None):
-        """Makes the call to the Error Reporting API via the log stream.
+    @property
+    def report_errors_api(self):
+        """Helper for logging-related API calls.
+
+        See:
+        https://cloud.google.com/logging/docs/api/reference/rest/v2/entries
+        https://cloud.google.com/logging/docs/api/reference/rest/v2/projects.logs
+        """
+        if self._report_errors_api is None:
+            if self._use_gax:
+                self._report_errors_api = make_report_error_api(self._project)
+            else:
+                self._report_errors_api = _ErrorReportingLoggingAPI(
+                    self._project, self._credentials, self._http)
+        return self._report_errors_api
 
-        This is the lower-level interface to build the payload, generally
-        users will use either report() or report_exception() to automatically
-        gather the parameters for this method.
 
-        Currently this method sends the Error Report by formatting a structured
-        log message according to
+    def _build_error_report(self, message,
+                            report_location=None, http_context=None, user=None):
+        """Builds the Error Reporting object to report.
+
+        This builds the object according to
 
         https://cloud.google.com/error-reporting/docs/formatting-error-messages
 
@@ -151,7 +195,7 @@ def _send_error_report(self, message,
                      logged in. In this  case the Error Reporting system will
                      use other data, such as remote IP address,
                      to distinguish affected users.
-        """
+         """
         payload = {
             'serviceContext': {
                 'service': self.service,
@@ -174,13 +218,50 @@ def _send_error_report(self, message,
             payload['context']['httpContext'] = {
                 key: value for key, value in six.iteritems(http_context_dict)
                 if value is not None
-            }
+                }
 
         if user:
             payload['context']['user'] = user
+        return payload
 
-        logger = self.logging_client.logger('errors')
-        logger.log_struct(payload)
+    def _send_error_report(self, message,
+                   report_location=None, http_context=None, user=None):
+        """Makes the call to the Error Reporting API.
+
+        This is the lower-level interface to build and send the payload,
+        generally users will use either report() or report_exception() to
+        automatically gather the parameters for this method.
+
+        :type message: str
+        :param message: The stack trace that was reported or logged by the
+                   service.
+
+        :type report_location: dict
+        :param report_location:  The location in the source code where the
+               decision was made to report the error, usually the place
+               where it was logged. For a logged exception this would be the
+               source line where the exception is logged, usually close to
+               the place where it was caught.
+
+               This should be a Python dict that contains the keys 'filePath',
+               'lineNumber', and 'functionName'
+
+        :type http_context: :class`google.cloud.error_reporting.HTTPContext`
+        :param http_context: The HTTP request which was processed when the
+                             error was triggered.
+
+        :type user: str
+        :param user: 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.
+        """
+        error_report = self._build_error_report(message, report_location,
+                                                http_context, user)
+        self.report_errors_api.report_error_event(error_report)
 
     def report(self, message, http_context=None, user=None):
         """ Reports a message to Stackdriver Error Reporting