Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# -*- coding: utf-8 -*-
2# Copyright 2025 Google LLC
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15#
16import json
17import logging as std_logging
18import pickle
19import warnings
20from typing import Callable, Dict, Optional, Sequence, Tuple, Union
22from google.api_core import grpc_helpers
23from google.api_core import gapic_v1
24import google.auth # type: ignore
25from google.auth import credentials as ga_credentials # type: ignore
26from google.auth.transport.grpc import SslCredentials # type: ignore
27from google.protobuf.json_format import MessageToJson
28import google.protobuf.message
30import grpc # type: ignore
31import proto # type: ignore
33from google.cloud.errorreporting_v1beta1.types import report_errors_service
34from .base import ReportErrorsServiceTransport, DEFAULT_CLIENT_INFO
36try:
37 from google.api_core import client_logging # type: ignore
39 CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER
40except ImportError: # pragma: NO COVER
41 CLIENT_LOGGING_SUPPORTED = False
43_LOGGER = std_logging.getLogger(__name__)
46class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER
47 def intercept_unary_unary(self, continuation, client_call_details, request):
48 logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
49 std_logging.DEBUG
50 )
51 if logging_enabled: # pragma: NO COVER
52 request_metadata = client_call_details.metadata
53 if isinstance(request, proto.Message):
54 request_payload = type(request).to_json(request)
55 elif isinstance(request, google.protobuf.message.Message):
56 request_payload = MessageToJson(request)
57 else:
58 request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
60 request_metadata = {
61 key: value.decode("utf-8") if isinstance(value, bytes) else value
62 for key, value in request_metadata
63 }
64 grpc_request = {
65 "payload": request_payload,
66 "requestMethod": "grpc",
67 "metadata": dict(request_metadata),
68 }
69 _LOGGER.debug(
70 f"Sending request for {client_call_details.method}",
71 extra={
72 "serviceName": "google.devtools.clouderrorreporting.v1beta1.ReportErrorsService",
73 "rpcName": str(client_call_details.method),
74 "request": grpc_request,
75 "metadata": grpc_request["metadata"],
76 },
77 )
78 response = continuation(client_call_details, request)
79 if logging_enabled: # pragma: NO COVER
80 response_metadata = response.trailing_metadata()
81 # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
82 metadata = (
83 dict([(k, str(v)) for k, v in response_metadata])
84 if response_metadata
85 else None
86 )
87 result = response.result()
88 if isinstance(result, proto.Message):
89 response_payload = type(result).to_json(result)
90 elif isinstance(result, google.protobuf.message.Message):
91 response_payload = MessageToJson(result)
92 else:
93 response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
94 grpc_response = {
95 "payload": response_payload,
96 "metadata": metadata,
97 "status": "OK",
98 }
99 _LOGGER.debug(
100 f"Received response for {client_call_details.method}.",
101 extra={
102 "serviceName": "google.devtools.clouderrorreporting.v1beta1.ReportErrorsService",
103 "rpcName": client_call_details.method,
104 "response": grpc_response,
105 "metadata": grpc_response["metadata"],
106 },
107 )
108 return response
111class ReportErrorsServiceGrpcTransport(ReportErrorsServiceTransport):
112 """gRPC backend transport for ReportErrorsService.
114 An API for reporting error events.
116 This class defines the same methods as the primary client, so the
117 primary client can load the underlying transport implementation
118 and call it.
120 It sends protocol buffers over the wire using gRPC (which is built on
121 top of HTTP/2); the ``grpcio`` package must be installed.
122 """
124 _stubs: Dict[str, Callable]
126 def __init__(
127 self,
128 *,
129 host: str = "clouderrorreporting.googleapis.com",
130 credentials: Optional[ga_credentials.Credentials] = None,
131 credentials_file: Optional[str] = None,
132 scopes: Optional[Sequence[str]] = None,
133 channel: Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]] = None,
134 api_mtls_endpoint: Optional[str] = None,
135 client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
136 ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
137 client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
138 quota_project_id: Optional[str] = None,
139 client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
140 always_use_jwt_access: Optional[bool] = False,
141 api_audience: Optional[str] = None,
142 ) -> None:
143 """Instantiate the transport.
145 Args:
146 host (Optional[str]):
147 The hostname to connect to (default: 'clouderrorreporting.googleapis.com').
148 credentials (Optional[google.auth.credentials.Credentials]): The
149 authorization credentials to attach to requests. These
150 credentials identify the application to the service; if none
151 are specified, the client will attempt to ascertain the
152 credentials from the environment.
153 This argument is ignored if a ``channel`` instance is provided.
154 credentials_file (Optional[str]): A file with credentials that can
155 be loaded with :func:`google.auth.load_credentials_from_file`.
156 This argument is ignored if a ``channel`` instance is provided.
157 scopes (Optional(Sequence[str])): A list of scopes. This argument is
158 ignored if a ``channel`` instance is provided.
159 channel (Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]]):
160 A ``Channel`` instance through which to make calls, or a Callable
161 that constructs and returns one. If set to None, ``self.create_channel``
162 is used to create the channel. If a Callable is given, it will be called
163 with the same arguments as used in ``self.create_channel``.
164 api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
165 If provided, it overrides the ``host`` argument and tries to create
166 a mutual TLS channel with client SSL credentials from
167 ``client_cert_source`` or application default SSL credentials.
168 client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
169 Deprecated. A callback to provide client SSL certificate bytes and
170 private key bytes, both in PEM format. It is ignored if
171 ``api_mtls_endpoint`` is None.
172 ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
173 for the grpc channel. It is ignored if a ``channel`` instance is provided.
174 client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
175 A callback to provide client certificate bytes and private key bytes,
176 both in PEM format. It is used to configure a mutual TLS channel. It is
177 ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided.
178 quota_project_id (Optional[str]): An optional project to use for billing
179 and quota.
180 client_info (google.api_core.gapic_v1.client_info.ClientInfo):
181 The client info used to send a user-agent string along with
182 API requests. If ``None``, then default info will be used.
183 Generally, you only need to set this if you're developing
184 your own client library.
185 always_use_jwt_access (Optional[bool]): Whether self signed JWT should
186 be used for service account credentials.
188 Raises:
189 google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
190 creation failed for any reason.
191 google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
192 and ``credentials_file`` are passed.
193 """
194 self._grpc_channel = None
195 self._ssl_channel_credentials = ssl_channel_credentials
196 self._stubs: Dict[str, Callable] = {}
198 if api_mtls_endpoint:
199 warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
200 if client_cert_source:
201 warnings.warn("client_cert_source is deprecated", DeprecationWarning)
203 if isinstance(channel, grpc.Channel):
204 # Ignore credentials if a channel was passed.
205 credentials = None
206 self._ignore_credentials = True
207 # If a channel was explicitly provided, set it.
208 self._grpc_channel = channel
209 self._ssl_channel_credentials = None
211 else:
212 if api_mtls_endpoint:
213 host = api_mtls_endpoint
215 # Create SSL credentials with client_cert_source or application
216 # default SSL credentials.
217 if client_cert_source:
218 cert, key = client_cert_source()
219 self._ssl_channel_credentials = grpc.ssl_channel_credentials(
220 certificate_chain=cert, private_key=key
221 )
222 else:
223 self._ssl_channel_credentials = SslCredentials().ssl_credentials
225 else:
226 if client_cert_source_for_mtls and not ssl_channel_credentials:
227 cert, key = client_cert_source_for_mtls()
228 self._ssl_channel_credentials = grpc.ssl_channel_credentials(
229 certificate_chain=cert, private_key=key
230 )
232 # The base transport sets the host, credentials and scopes
233 super().__init__(
234 host=host,
235 credentials=credentials,
236 credentials_file=credentials_file,
237 scopes=scopes,
238 quota_project_id=quota_project_id,
239 client_info=client_info,
240 always_use_jwt_access=always_use_jwt_access,
241 api_audience=api_audience,
242 )
244 if not self._grpc_channel:
245 # initialize with the provided callable or the default channel
246 channel_init = channel or type(self).create_channel
247 self._grpc_channel = channel_init(
248 self._host,
249 # use the credentials which are saved
250 credentials=self._credentials,
251 # Set ``credentials_file`` to ``None`` here as
252 # the credentials that we saved earlier should be used.
253 credentials_file=None,
254 scopes=self._scopes,
255 ssl_credentials=self._ssl_channel_credentials,
256 quota_project_id=quota_project_id,
257 options=[
258 ("grpc.max_send_message_length", -1),
259 ("grpc.max_receive_message_length", -1),
260 ],
261 )
263 self._interceptor = _LoggingClientInterceptor()
264 self._logged_channel = grpc.intercept_channel(
265 self._grpc_channel, self._interceptor
266 )
268 # Wrap messages. This must be done after self._logged_channel exists
269 self._prep_wrapped_messages(client_info)
271 @classmethod
272 def create_channel(
273 cls,
274 host: str = "clouderrorreporting.googleapis.com",
275 credentials: Optional[ga_credentials.Credentials] = None,
276 credentials_file: Optional[str] = None,
277 scopes: Optional[Sequence[str]] = None,
278 quota_project_id: Optional[str] = None,
279 **kwargs,
280 ) -> grpc.Channel:
281 """Create and return a gRPC channel object.
282 Args:
283 host (Optional[str]): The host for the channel to use.
284 credentials (Optional[~.Credentials]): The
285 authorization credentials to attach to requests. These
286 credentials identify this application to the service. If
287 none are specified, the client will attempt to ascertain
288 the credentials from the environment.
289 credentials_file (Optional[str]): A file with credentials that can
290 be loaded with :func:`google.auth.load_credentials_from_file`.
291 This argument is mutually exclusive with credentials.
292 scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
293 service. These are only used when credentials are not specified and
294 are passed to :func:`google.auth.default`.
295 quota_project_id (Optional[str]): An optional project to use for billing
296 and quota.
297 kwargs (Optional[dict]): Keyword arguments, which are passed to the
298 channel creation.
299 Returns:
300 grpc.Channel: A gRPC channel object.
302 Raises:
303 google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
304 and ``credentials_file`` are passed.
305 """
307 return grpc_helpers.create_channel(
308 host,
309 credentials=credentials,
310 credentials_file=credentials_file,
311 quota_project_id=quota_project_id,
312 default_scopes=cls.AUTH_SCOPES,
313 scopes=scopes,
314 default_host=cls.DEFAULT_HOST,
315 **kwargs,
316 )
318 @property
319 def grpc_channel(self) -> grpc.Channel:
320 """Return the channel designed to connect to this service."""
321 return self._grpc_channel
323 @property
324 def report_error_event(
325 self,
326 ) -> Callable[
327 [report_errors_service.ReportErrorEventRequest],
328 report_errors_service.ReportErrorEventResponse,
329 ]:
330 r"""Return a callable for the report error event method over gRPC.
332 Report an individual error event and record the event to a log.
334 This endpoint accepts **either** an OAuth token, **or** an `API
335 key <https://support.google.com/cloud/answer/6158862>`__ for
336 authentication. To use an API key, append it to the URL as the
337 value of a ``key`` parameter. For example:
339 ``POST https://clouderrorreporting.googleapis.com/v1beta1/{projectName}/events:report?key=123ABC456``
341 **Note:** [Error Reporting]
342 (https://cloud.google.com/error-reporting) is a service built on
343 Cloud Logging and can analyze log entries when all of the
344 following are true:
346 - Customer-managed encryption keys (CMEK) are disabled on the
347 log bucket.
348 - The log bucket satisfies one of the following:
350 - The log bucket is stored in the same project where the
351 logs originated.
352 - The logs were routed to a project, and then that project
353 stored those logs in a log bucket that it owns.
355 Returns:
356 Callable[[~.ReportErrorEventRequest],
357 ~.ReportErrorEventResponse]:
358 A function that, when called, will call the underlying RPC
359 on the server.
360 """
361 # Generate a "stub function" on-the-fly which will actually make
362 # the request.
363 # gRPC handles serialization and deserialization, so we just need
364 # to pass in the functions for each.
365 if "report_error_event" not in self._stubs:
366 self._stubs["report_error_event"] = self._logged_channel.unary_unary(
367 "/google.devtools.clouderrorreporting.v1beta1.ReportErrorsService/ReportErrorEvent",
368 request_serializer=report_errors_service.ReportErrorEventRequest.serialize,
369 response_deserializer=report_errors_service.ReportErrorEventResponse.deserialize,
370 )
371 return self._stubs["report_error_event"]
373 def close(self):
374 self._logged_channel.close()
376 @property
377 def kind(self) -> str:
378 return "grpc"
381__all__ = ("ReportErrorsServiceGrpcTransport",)