Add Error Reporting GAPIC as dependency

error_reporting/google/cloud/error_reporting/_gax.py

@@ -0,0 +1,74 @@
+# 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._helpers import make_secure_channel
+from google.cloud._http import DEFAULT_USER_AGENT
+
+from google.cloud.gapic.errorreporting.v1beta1 import (
+    report_errors_service_client)
+from google.cloud.grpc.devtools.clouderrorreporting.v1beta1 import (
+    report_errors_service_pb2)
+from google.protobuf.json_format import ParseDict
+
+
+def make_report_error_api(client):
+    """Create an instance of the GAX Logging API.
+
+    :type client::class:`google.cloud.error_reporting.Client`
+    :param client: Error Reporting client.
+
+    :rtype: :class:_ErrorReportingGaxApi
+    :returns: An Error Reporting API instance.
+    """
+    channel = make_secure_channel(
+        client._connection.credentials,
+        DEFAULT_USER_AGENT,
+        report_errors_service_client.ReportErrorsServiceClient.SERVICE_ADDRESS)
+    gax_client = report_errors_service_client.ReportErrorsServiceClient(
+        channel=channel)
+    return _ErrorReportingGaxApi(gax_client, client.project)
+
+
+class _ErrorReportingGaxApi(object):
+    """Helper mapping Error Reporting-related APIs
+
+    :type gax_api:
+        :class:`v1beta1.report_errors_service_client.ReportErrorsServiceClient`
+    :param gax_api: API object used to make GAX requests.
+
+    :type project: str
+    :param project: Google Cloud Project ID
+    """
+
+    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 error_report: dict
+        :param error_report:
+            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,60 @@
+# 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
+
+    :type project: str
+    :param project: the project which the client acts on behalf of. If not
+                    passed falls back to the default inferred from the
+                    environment.
+
+    :type credentials: :class:`oauth2client.client.OAuth2Credentials` or
+                       :class:`NoneType`
+    :param credentials: The OAuth2 Credentials to use for the connection
+                        owned by this client. If not passed (and if no ``http``
+                        object is passed), falls back to the default inferred
+                        from the environment.
+
+    :type http: :class:`httplib2.Http` or class that defines ``request()``.
+    :param http: An optional HTTP object to make requests. If not passed, an
+                 ``http`` object is created that is bound to the
+                 ``credentials`` for the current object.
+    """
+    def __init__(self, project, credentials=None, http=None):
+        self.logging_client = google.cloud.logging.client.Client(
+            project, credentials, http)
+
+    def report_error_event(self, error_report):
+        """Report error payload.
+
+        :type error_report: dict
+        :param: error_report:
+            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
+            :meth:~`google.cloud.error_reporting.client._build_error_report`
+        """
+        logger = self.logging_client.logger('errors')
+        logger.log_struct(error_report)

error_reporting/google/cloud/error_reporting/client.py

@@ -12,13 +12,26 @@
 # 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
+    _HAVE_GAX = True
+except ImportError:  # pragma: NO COVER
+    _HAVE_GAX = False
+
+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 +109,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 +123,56 @@ 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.
 
-        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.
+        See:
+        https://cloud.google.com/logging/docs/api/reference/rest/v2/entries
+        https://cloud.google.com/logging/docs/api/reference/rest/v2/projects.logs
 
-        Currently this method sends the Error Report by formatting a structured
-        log message according to
+        :rtype:
+            :class:`_gax._ErrorReportingGaxApi`
+            or
+            :class:`._logging._ErrorReportingLoggingAPI`
+        :returns: A class that implements the report errors API.
+        """
+        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
+
+    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 +202,10 @@ 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.
-        """
+        :rtype: dict
+        :returns: A dict payload ready to be serialized to JSON and sent to
+                  the API.
+         """
         payload = {
             'serviceContext': {
                 'service': self.service,
@@ -178,9 +232,49 @@ def _send_error_report(self, message,
 
         if user:
             payload['context']['user'] = user
+        return 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.
 
-        logger = self.logging_client.logger('errors')
-        logger.log_struct(payload)
+        :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

error_reporting/setup.py

@@ -52,6 +52,7 @@
 REQUIREMENTS = [
     'google-cloud-core >= 0.22.1, < 0.23dev',
     'google-cloud-logging >= 0.22.0, < 0.23dev',
+    'gapic-google-cloud-error-reporting-v1beta1 >= 0.14.0, < 0.15dev'
 ]
 
 setup(

error_reporting/tox.ini

@@ -14,7 +14,7 @@ deps =
     pytest
 covercmd =
     py.test --quiet \
-      --cov=google.cloud.error-reporting \
+      --cov=google.cloud.error_reporting \
       --cov=unit_tests \
       --cov-config {toxinidir}/.coveragerc \
       unit_tests

error_reporting/unit_tests/test__gax.py

@@ -0,0 +1,53 @@
+# Copyright 2017 Google Inc.
+#
+# 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.
+
+import unittest
+
+import mock
+
+
+class Test_make_report_error_api(unittest.TestCase):
+
+    def test_make_report_error_api(self):
+        from google.cloud.error_reporting._gax import make_report_error_api
+        client = mock.Mock()
+        client.project = mock.Mock()
+        report_error_client = make_report_error_api(client)
+        self.assertEqual(report_error_client._project, client.project)
+
+
+class Test_ErrorReportingGaxApi(unittest.TestCase):
+
+    PROJECT = 'PROJECT'
+
+    def _call_fut(self, gax_api, project):
+        from google.cloud.error_reporting._gax import _ErrorReportingGaxApi
+        return _ErrorReportingGaxApi(gax_api, project)
+
+    def test_constructor(self):
+        gax_api = mock.Mock()
+        gax_client_wrapper = self._call_fut(gax_api, self.PROJECT)
+
+        self.assertEqual(gax_client_wrapper._project, self.PROJECT)
+        self.assertEqual(gax_client_wrapper._gax_api, gax_api)
+
+    @mock.patch("google.cloud.error_reporting._gax.ParseDict")
+    def test_report_error_event(self, _):
+        gax_api = mock.Mock()
+        gax_client_wrapper = self._call_fut(gax_api, self.PROJECT)
+
+        mock_error_report = mock.Mock()
+        gax_client_wrapper.report_error_event(mock_error_report)
+        self.assertTrue(gax_api.report_error_event.called_with,
+                        mock_error_report)